initial commit for "experiment" entity

Author: dyllamt

taurus/entity/experiment/__init__.py

@@ -0,0 +1,42 @@
+from taurus.entity.base_entity import BaseEntity
+
+from taurus.entity.template.base_template import BaseTemplate
+from taurus.entity.object.base_object import BaseObject
+
+
+class BaseExperiment(BaseEntity):
+    """An experiment is a collection of Taurus objects, with defined connections between them.
+    """
+
+    def __init__(self, objects, connections, uids, tags):
+        BaseEntity.__init__(self, uids=uids, tags=tags)
+        self._objects = None
+        self._connections = None
+
+        self.objects = objects
+        self.connections = connections
+
+    @property
+    def objects(self):
+        return self._objects
+
+    @objects.setter
+    def objects(self, objects):
+        for obj in objects.values():
+            assert isinstance(obj, (BaseTemplate, BaseObject))
+        self._objects = objects
+
+    @property
+    def connections(self):
+        return self._connections
+
+    @connections.setter
+    def connections(self, connections):
+        self._connections = connections  # TODO: check all str in objects mapping
+
+    def visualize(self):
+        """Graphs the objects in this data model."""
+        from dagre_py.core import plot
+        nodes = [{"label": p} for p in self.templates.keys()]
+        edges = [{"source": s, "target": t} for s, t in self.connections]
+        plot({"nodes": nodes, "edges": edges})

taurus/entity/experiment/base_experiment.py

@@ -0,0 +1,31 @@
+from taurus.entity.experiment.base_experiment import BaseExperiment
+
+
+class ExperimentRun(BaseExperiment):
+    """An experiment run is a collection of Taurus run objects, with connections between them.
+    """
+
+    def __init__(self, objects, connections, uids, tags, spec):
+        BaseExperiment.__init__(
+            self, objects=objects, connections=connections, uids=uids, tags=tags
+        )
+        self._spec = None
+        self.spec = spec
+
+    @property
+    def spec(self):
+        return self._spec
+
+    @spec.setter
+    def spec(self, spec):
+        from taurus.entity.experiment.spec import ExperimentSpec
+        assert isinstance(spec, ExperimentSpec)
+        self._spec = spec
+
+    @property
+    def objects(self):
+        return self._objects
+
+    @objects.setter
+    def objects(self, objects):
+        self._objects = objects  # TODO: check all objects are runs

taurus/entity/experiment/experiment_run.py

@@ -0,0 +1,46 @@
+from taurus.entity.experiment.base_experiment import BaseExperiment
+
+
+class ExperimentSpec(BaseExperiment):
+    """An experiment spec is a collection of Taurus spec objects, with connections between them.
+    """
+
+    def __init__(self, objects, connections, uids, tags, template):
+        BaseExperiment.__init__(
+            self, objects=objects, connections=connections, uids=uids, tags=tags
+        )
+        self._template = None
+        self.template = template
+
+    @property
+    def template(self):
+        return self._template
+
+    @template.setter
+    def template(self, template):
+        from taurus.entity.experiment.template import ExperimentTemplate
+        assert isinstance(template, ExperimentTemplate)
+        self._template = template
+
+    @property
+    def objects(self):
+        return self._objects
+
+    @objects.setter
+    def objects(self, objects):
+        self._objects = objects  # TODO: check all objects are specs
+
+    def __call__(self):
+        """Create a run state of this spec experiment."""
+        from taurus.entity.experiment.run_experiment import ExperimentRun
+
+        runs = dict()
+        connections = list()
+
+        return ExperimentRun(
+            objects=runs,
+            connections=connections,
+            uids=self.uids,
+            tags=self.tags,
+            spec_experiment=self,
+        )

taurus/entity/experiment/experiment_spec.py

@@ -0,0 +1,152 @@
+from taurus.entity.template.base_template import BaseTemplate
+from taurus.entity.template.material_template import MaterialTemplate
+from taurus.entity.template.measurement_template import MeasurementTemplate
+from taurus.entity.template.process_template import ProcessTemplate
+
+from taurus.entity.object.ingredient_spec import IngredientSpec
+
+from taurus.entity.experiment.base_experiment import BaseExperiment
+
+
+class ExperimentTemplate(BaseExperiment):
+    """An experiment template is a collection of Taurus templates, with connections between them.
+    """
+
+    def __init__(self, objects, connections, uids, tags):
+        BaseExperiment.__init__(
+            self, objects=objects, connections=connections, uids=uids, tags=tags
+        )
+
+    @property
+    def objects(self):
+        return self._objects
+
+    @objects.setter
+    def objects(self, objects):
+        for obj in objects.values():
+            assert isinstance(obj, BaseTemplate)
+        self._objects = objects
+
+    def __call__(self):
+        """Create a spec state of this template model."""
+        from taurus.entity.experiment.experiment_spec import ExperimentSpec
+
+        specs = dict()
+        connections = list()
+
+        # first, add processes to the specs collection
+        for key, template in self.objects.items():
+            if isinstance(template, ProcessTemplate):
+                specs[key] = template()  # creates a spec from template
+
+        # second, add materials which are linked to process specs
+        for key, template in self.objects.items():
+            if isinstance(template, MaterialTemplate):
+                creating_process = [
+                    source for source, destination in self.connections if destination == key
+                ][0]
+                specs[key] = template(process=specs[creating_process])
+                connections.append((creating_process, key))
+
+        # third, add ingredients that feed into processes
+        infered_ingredients = []
+        for source, destination in self.connections:
+            if isinstance(self.objects[source], MaterialTemplate) & isinstance(
+                self.objects[destination], ProcessTemplate
+            ):
+                infered_ingredients.append((source, destination))
+        for material, process in infered_ingredients:
+            ingredient_name = "ingredient: {}".format(material)
+            specs[ingredient_name] = IngredientSpec(
+                name=ingredient_name, material=specs[material], process=specs[process]
+            )
+            connections.append((material, ingredient_name))
+            connections.append((ingredient_name, process))
+
+        # fourth, add measurements attached to materials
+        for key, template in self.objects.items():
+            if isinstance(template, MeasurementTemplate):
+                specs[key] = template()
+
+        return ExperimentSpec(
+            objects=specs,
+            connections=connections,
+            uids=self.uids,
+            tags=self.tags,
+            template_model=self,
+        )
+
+
+if __name__ == "__main__":
+    from taurus.entity.template.property_template import PropertyTemplate
+    from taurus.entity.template.condition_template import ConditionTemplate
+    from taurus.entity.template.parameter_template import ParameterTemplate
+
+    from taurus.entity.bounds.categorical_bounds import CategoricalBounds
+    from taurus.entity.bounds.real_bounds import RealBounds
+
+    from taurus.util.impl import flatten
+
+    # property templates
+    conductivity = PropertyTemplate(
+        name="conductivity",
+        bounds=RealBounds(lower_bound=0, upper_bound=100000, default_units="S/m"),
+    )
+    seebeck = PropertyTemplate(
+        name="Seebeck", bounds=RealBounds(lower_bound=-500, upper_bound=500, default_units="uV/K"),
+    )
+
+    # condition templates
+    atmosphere = ConditionTemplate(name="atmosphere", bounds=CategoricalBounds(["air", "argon"]))
+    pressure = ConditionTemplate(
+        name="pressure", bounds=RealBounds(lower_bound=0, upper_bound=1, default_units="atm")
+    )
+    day_of_the_week = ConditionTemplate(
+        name="day of the week", bounds=CategoricalBounds(["M", "T", "W", "Th", "F"])
+    )
+
+    # parameter templates
+    vendor = ParameterTemplate(
+        name="vendor", bounds=CategoricalBounds(["alpha-aesar", "sigma-aldrich"])
+    )
+    field_strength = ParameterTemplate(
+        name="field_strength", bounds=RealBounds(lower_bound=0, upper_bound=5, default_units="T"),
+    )
+    temperature = ParameterTemplate(
+        name="temperaure", bounds=RealBounds(lower_bound=300, upper_bound=1000, default_units="K")
+    )
+
+    # object templates
+    material = MaterialTemplate(name="test material", properties=[conductivity, seebeck])
+    measurement = MeasurementTemplate(
+        name="test measurement",
+        properties=[conductivity, seebeck],
+        conditions=[atmosphere, pressure],
+        parameters=[field_strength],
+    )
+    procure = ProcessTemplate(name="procure", conditions=[day_of_the_week], parameters=[vendor])
+    heat_treat = ProcessTemplate(
+        name="heat treat", conditions=[atmosphere], parameters=[temperature]
+    )
+
+    templates = {
+        "procure": procure,
+        "initial_sample": material,
+        "initial_measurement": measurement,
+        "heat_treat": heat_treat,
+        "treated_sample": material,
+        "treated_measurement": measurement,
+    }
+    connections = [
+        ("procure", "initial_sample"),
+        ("initial_sample", "initial_measurement"),
+        ("initial_sample", "heat_treat"),
+        ("heat_treat", "treated_sample"),
+        ("treated_sample", "treated_measurement"),
+    ]
+
+    data_model = TemplateModel(templates=templates, connections=connections)
+    data_model.visualize()
+
+    specs, connections = data_model.spec
+    print(flatten(specs["treated_sample"]))