def __init__(self,
name: str,
notes: Optional[str] = None,
value: Optional[BaseValue] = None,
template: Optional[TaurusParameterTemplate] = None,
origin: Optional[str] = "unknown",
file_links: Optional[List[FileLink]] = None):
TaurusParameter.__init__(self,
name=name,
notes=notes,
value=value,
template=template,
origin=origin,
file_links=file_links)
def test_deserialize():
"""Round-trip serde should leave the object unchanged."""
condition = Condition(name="A condition", value=NominalReal(7, ''))
parameter = Parameter(name="A parameter", value=NormalReal(mean=17, std=1, units=''))
measurement = MeasurementRun(tags="A tag on a measurement", conditions=condition,
parameters=parameter)
copy_meas = copy(measurement)
assert(copy_meas.conditions[0].value == measurement.conditions[0].value)
assert(copy_meas.parameters[0].value == measurement.parameters[0].value)
assert(copy_meas.uids["auto"] == measurement.uids["auto"])
def test_measurement_spec():
"""Test the measurement spec/run connection survives ser/de."""
condition = Condition(name="Temp condition",
value=NominalReal(nominal=298, units='kelvin'))
parameter = Parameter(name="Important parameter")
spec = MeasurementSpec(name="Precise way to do a measurement",
parameters=parameter,
conditions=condition)
# Create a measurement run from this measurement spec
measurement = MeasurementRun(conditions=condition, spec=spec)
copy = loads(dumps(measurement))
assert dumps(copy.spec) == dumps(measurement.spec), \
"Measurement spec should be preserved if measurement run is serialized"
def test_recursive_foreach():
"""Test that recursive_foreach() applies a method to every object."""
new_tag = "Extra tag"
def func(base_ent):
"""Adds a specific tag to the object."""
base_ent.tags.extend([new_tag])
return
param_template = ParameterTemplate("a param template", bounds=RealBounds(0, 100, ''))
meas_template = MeasurementTemplate("Measurement template", parameters=[param_template])
parameter = Parameter(name="A parameter", value=NormalReal(mean=17, std=1, units=''))
measurement = MeasurementSpec(name="name", parameters=parameter, template=meas_template)
test_dict = {"foo": measurement}
recursive_foreach(test_dict, func, apply_first=True)
for ent in [param_template, meas_template, measurement]:
assert new_tag in ent.tags
def test_serialize():
"""Serializing a nested object should be identical to individually serializing each piece."""
condition = Condition(name="A condition", value=NominalReal(7, ''))
parameter = Parameter(name="A parameter", value=NormalReal(mean=17, std=1, units=''))
input_material = MaterialRun(tags="input")
process = ProcessRun(tags="A tag on a process run")
ingredient = IngredientRun(material=input_material, process=process)
material = MaterialRun(tags=["A tag on a material"], process=process)
measurement = MeasurementRun(tags="A tag on a measurement", conditions=condition,
parameters=parameter, material=material)
# serialize the root of the tree
native_object = json.loads(dumps(measurement))
# ingredients don't get serialized on the process
assert(len(native_object[0]) == 3)
assert(native_object[1]["type"] == LinkByUID.typ)
# serialize all of the nodes
native_batch = json.loads(dumps([material, process, measurement, ingredient]))
assert(len(native_batch[0]) == 5)
assert(len(native_batch[1]) == 4)
assert(all(x["type"] == LinkByUID.typ for x in native_batch[1]))
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(spec=x), binder_specs)
powder_runs = keymap(lambda x: MaterialRun(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(
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(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(template=firing_template)
firing_process = ProcessRun(
conditions=[measured_firing_temperature],
parameters=[specified_firing_setting],
spec=firing_spec
)
IngredientRun(
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(template=measurement_template)
measurement = MeasurementRun(
properties=[measured_density, measured_modulus],
spec=measurement_spec
)
tags = [tag] if tag else []
material_spec = MaterialSpec(template=material_template)
material_run = MaterialRun(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
def make_cake(seed=None):
"""Define all objects that go into making a demo cake."""
if seed is not None:
random.seed(seed)
######################################################################
# Parent Objects
tmpl = make_cake_templates()
cake_spec = make_cake_spec()
######################################################################
# Objects
cake = make_instance(cake_spec)
operators = ['gwash', 'jadams', 'thomasj', 'jmadison', 'jmonroe']
cake.process.source = PerformedSource(performed_by=random.choice(operators),
performed_date='2015-03-14')
# Replace Abstract/In General
queue = [cake]
while queue:
item = queue.pop(0)
item.name = item.name.replace('Abstract ', '').replace(', in General', '')
if item.spec.tags is not None:
item.tags = list(item.spec.tags)
if item.spec.notes: # None or empty string
item.notes = 'The spec says "{}"'.format(item.spec.notes)
if isinstance(item, MaterialRun):
queue.append(item.process)
elif isinstance(item, ProcessRun):
queue.extend(item.ingredients)
if item.template.name == "Procurement":
item.source = PerformedSource(performed_by='hamilton',
performed_date='2015-02-17')
else:
item.source = cake.process.source
elif isinstance(item, IngredientRun):
queue.append(item.material)
fuzz = 0.95 + 0.1 * random.random()
if item.spec.absolute_quantity is not None:
item.absolute_quantity = \
NormalReal(mean=fuzz * item.spec.absolute_quantity.nominal,
std=0.05 * item.spec.absolute_quantity.nominal,
units=item.spec.absolute_quantity.units)
if item.spec.volume_fraction is not None:
item.volume_fraction = \
NormalReal(mean=fuzz * item.spec.volume_fraction.nominal,
std=0.05 * item.spec.volume_fraction.nominal,
units=item.spec.volume_fraction.units)
if item.spec.mass_fraction is not None:
item.mass_fraction = \
UniformReal(lower_bound=(fuzz - 0.05) * item.spec.mass_fraction.nominal,
upper_bound=(fuzz + 0.05) * item.spec.mass_fraction.nominal,
units=item.spec.mass_fraction.units)
if item.spec.number_fraction is not None:
item.number_fraction = \
NormalReal(mean=fuzz * item.spec.number_fraction.nominal,
std=0.05 * item.spec.number_fraction.nominal,
units=item.spec.number_fraction.units)
else:
raise TypeError("Unexpected object in the queue")
frosting = \
next(x.material for x in cake.process.ingredients if 'rosting' in x.name)
baked = \
next(x.material for x in cake.process.ingredients if 'aked' in x.name)
# Add measurements
cake_taste = MeasurementRun(name='Final Taste', material=cake)
cake_appearance = MeasurementRun(name='Final Appearance', material=cake)
frosting_taste = MeasurementRun(name='Frosting Taste', material=frosting)
frosting_sweetness = MeasurementRun(name='Frosting Sweetness', material=frosting)
# and spec out the measurements
cake_taste.spec = MeasurementSpec(name='Taste')
cake_appearance.spec = MeasurementSpec(name='Appearance')
frosting_taste.spec = cake_taste.spec # Taste
frosting_sweetness.spec = MeasurementSpec(name='Sweetness')
######################################################################
# Let's add some attributes
baked.process.conditions.append(Condition(name='Cooking time',
template=tmpl['Cooking time'],
origin=Origin.MEASURED,
value=NominalReal(nominal=48, units='min')))
baked.spec.process.conditions.append(Condition(name='Cooking time',
template=tmpl['Cooking time'],
origin=Origin.SPECIFIED,
value=NormalReal(mean=50, std=5, units='min')))
baked.process.conditions.append(Condition(name='Oven temperature',
origin="measured",
value=NominalReal(nominal=362, units='degF')))
baked.spec.process.parameters.append(Parameter(name='Oven temperature setting',
template=tmpl['Oven temperature setting'],
origin="specified",
value=NominalReal(nominal=350, units='degF')))
cake_taste.properties.append(Property(name='Tastiness',
origin=Origin.MEASURED,
template=tmpl['Tastiness'],
value=NominalInteger(nominal=5)))
cake_appearance.properties.append(Property(name='Visual Appeal',
origin=Origin.MEASURED,
value=NominalInteger(nominal=5)))
frosting_taste.properties.append(Property(name='Tastiness',
origin=Origin.MEASURED,
template=tmpl['Tastiness'],
value=NominalInteger(nominal=4)))
frosting_sweetness.properties.append(Property(name='Sweetness (Sucrose-basis)',
origin=Origin.MEASURED,
value=NominalReal(nominal=1.7, units='')))
baked.process.spec.template = tmpl['Baking in an oven']
cake_taste.spec.template = tmpl['Taste test']
frosting_taste.spec.template = tmpl['Taste test']
cake.spec.template = tmpl['Dessert']
frosting.spec.template = tmpl['Dessert']
# Code to force all scopes to 'id'
set_uuids([cake, cake_taste, cake_appearance, frosting_taste, frosting_sweetness], name='id')
id_queue = [x for x in cake.process.ingredients]
while id_queue:
x = id_queue.pop(0)
set_uuids([x], name='id')
id_queue += x.material.process.ingredients
return cake