sierra-research 1.3.6__py3-none-any.whl → 1.5.0__py3-none-any.whl

sierra/plugins/{platform → engine}/argos/variables/physics_engines.py

@@ -18,7 +18,7 @@ import implements
 # Project packages
 from sierra.core.variables.base_variable import IBaseVariable
 from sierra.core.utils import ArenaExtent
-from sierra.core.experiment import xml
+from sierra.core.experiment import definition
 from sierra.core import types, config
 
 
@@ -27,7 +27,6 @@ class PhysicsEngines():
     """Defines 2D/3D physics engines within ARGoS and how they are laid out.
 
     Attributes:
-
         engine_type: The type of physics engine to use (one supported by ARGoS).
 
         n_engines: # of engines. Can be one of [1,4,8,16,24].
@@ -57,17 +56,17 @@ class PhysicsEngines():
         self.iter_per_tick = iter_per_tick
         self.layout = layout
         self.extents = extents
-        self.tag_adds = []  # type: tp.List[xml.TagAddList]
+        self.element_adds = []  # type: tp.List[definition.ElementAddList]
 
         # If we are given multiple extents to map, we need to divide the
         # specified # of engines among them.
         self.n_engines = int(self.n_engines / float(len(self.extents)))
-        assert self.layout == 'uniform_grid2D',\
+        assert self.layout == 'uniform_grid2D', \
             "Only uniform_grid2D physics engine layout currently supported"
 
         self.logger = logging.getLogger(__name__)
 
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
+    def gen_attr_changelist(self) -> tp.List[definition.AttrChangeSet]:
         """
         No effect.
 
@@ -75,41 +74,41 @@ class PhysicsEngines():
         """
         return []
 
-    def gen_tag_rmlist(self) -> tp.List[xml.TagRmList]:
+    def gen_tag_rmlist(self) -> tp.List[definition.ElementRmList]:
         """Remove the ``<physics_engines>`` tag if it exists may be desirable.
 
         Obviously you *must* call this function BEFORE adding new definitions.
 
         """
-        return [xml.TagRmList(xml.TagRm(".", "./physics_engines"))]
+        return [definition.ElementRmList(definition.ElementRm(".", "./physics_engines"))]
 
-    def gen_tag_addlist(self) -> tp.List[xml.TagAddList]:
+    def gen_element_addlist(self) -> tp.List[definition.ElementAddList]:
         self.logger.debug("Mapping %s physics engines of type %s to extents=%s",
                           self.n_engines,
                           self.engine_type,
                           [str(s) for s in self.extents])
-        if not self.tag_adds:
+        if not self.element_adds:
             if self.n_engines == 1:
-                self.tag_adds = [self._gen1_engines()]
+                self.element_adds = [self._gen1_engines()]
             elif self.n_engines == 2:
-                self.tag_adds = [self._gen2_engines(s) for s in self.extents]
+                self.element_adds = [self._gen2_engines(s) for s in self.extents]
             elif self.n_engines == 4:
-                self.tag_adds = [self._gen4_engines(s) for s in self.extents]
+                self.element_adds = [self._gen4_engines(s) for s in self.extents]
             elif self.n_engines == 6:
-                self.tag_adds = [self._gen6_engines(s) for s in self.extents]
+                self.element_adds = [self._gen6_engines(s) for s in self.extents]
             elif self.n_engines == 8:
-                self.tag_adds = [self._gen8_engines(s) for s in self.extents]
+                self.element_adds = [self._gen8_engines(s) for s in self.extents]
             elif self.n_engines == 12:
-                self.tag_adds = [self._gen12_engines(s) for s in self.extents]
+                self.element_adds = [self._gen12_engines(s) for s in self.extents]
             elif self.n_engines == 16:
-                self.tag_adds = [self._gen16_engines(s) for s in self.extents]
+                self.element_adds = [self._gen16_engines(s) for s in self.extents]
             elif self.n_engines == 24:
-                self.tag_adds = [self._gen24_engines(s) for s in self.extents]
+                self.element_adds = [self._gen24_engines(s) for s in self.extents]
             else:
                 raise RuntimeError(
-                    "Bad # of physics engines specified: {0}".format(self.n_engines))
+                    f"Bad # of physics engines specified: {self.n_engines}")
 
-        return self.tag_adds
+        return self.element_adds
 
     def gen_files(self) -> None:
         pass
@@ -118,11 +117,12 @@ class PhysicsEngines():
                          extent: ArenaExtent,
                          n_engines_x: int,
                          n_engines_y: int,
-                         forward_engines: tp.List[int]) -> xml.TagAddList:
+                         forward_engines: tp.List[int]) -> definition.ElementAddList:
         """Generate definitions for the specified # of engines for the extent.
 
         """
-        adds = xml.TagAddList(xml.TagAdd('.', 'physics_engines', {}, False))
+        adds = definition.ElementAddList(
+            definition.ElementAdd('.', 'physics_engines', {}, False))
 
         for i in range(0, self.n_engines):
             adds.extend(self.gen_single_engine(i,
@@ -138,7 +138,7 @@ class PhysicsEngines():
                           extent: ArenaExtent,
                           n_engines_x: int,
                           n_engines_y: int,
-                          forward_engines: tp.List[int]) -> xml.TagAddList:
+                          forward_engines: tp.List[int]) -> definition.ElementAddList:
         """
         Generate definitions for a specific 2D/3D engine.
 
@@ -152,10 +152,6 @@ class PhysicsEngines():
 
             extent: The mapped extent for ALL physics engines.
 
-            exceptions: List of lists of points defining polygons which should
-                        NOT be managed by any of the engines currently being
-                        processed.
-
             n_engines_x: # engines in the x direction.
 
             n_engines_y: # engines in the y direction.
@@ -165,7 +161,7 @@ class PhysicsEngines():
 
         """
 
-        adds = xml.TagAddList()
+        adds = definition.ElementAddList()
 
         size_x = extent.xsize() / n_engines_x
         size_y = extent.ysize() / n_engines_y
@@ -173,33 +169,33 @@ class PhysicsEngines():
 
         name = self._gen_engine_name(engine_id)
 
-        adds.append(xml.TagAdd('.//physics_engines',
-                               self.engine_type,
-                               {
-                                   'id': name,
-                                   'iterations': str(self.iter_per_tick)
-                               },
-                               True))
-        adds.append(xml.TagAdd(f".//physics_engines/*[@id='{name}']",
-                               "boundaries",
-                               {},
-                               True))
-        adds.append(xml.TagAdd(f".//physics_engines/*[@id='{name}']/boundaries",
-                               "top",
-                               {
-                                   'height': str(size_z)
-                               },
-                               True))
-        adds.append(xml.TagAdd(f".//physics_engines/*[@id='{name}']/boundaries",
-                               "bottom",
-                               {
-                                   'height': '0.0'
-                               },
-                               True))
-        adds.append(xml.TagAdd(f".//physics_engines/*[@id='{name}']/boundaries",
-                               "sides",
-                               {},
-                               True))
+        adds.append(definition.ElementAdd('.//physics_engines',
+                                          self.engine_type,
+                                          {
+                                              'id': name,
+                                              'iterations': str(self.iter_per_tick)
+                                          },
+                                          True))
+        adds.append(definition.ElementAdd(f".//physics_engines/*[@id='{name}']",
+                                          "boundaries",
+                                          {},
+                                          True))
+        adds.append(definition.ElementAdd(f".//physics_engines/*[@id='{name}']/boundaries",
+                                          "top",
+                                          {
+                                              'height': str(size_z)
+        },
+            True))
+        adds.append(definition.ElementAdd(f".//physics_engines/*[@id='{name}']/boundaries",
+                                          "bottom",
+                                          {
+                                              'height': '0.0'
+        },
+            True))
+        adds.append(definition.ElementAdd(f".//physics_engines/*[@id='{name}']/boundaries",
+                                          "sides",
+                                          {},
+                                          True))
 
         # Engine lower X coord increasing as engine id increases
         if engine_id in forward_engines:
@@ -230,30 +226,30 @@ class PhysicsEngines():
         vertices = [(ll_x, ll_y), (lr_x, lr_y), (ur_x, ur_y), (ul_x, ul_y)]
 
         for v in vertices:
-            adds.append(xml.TagAdd(f".//physics_engines/*[@id='{name}']/boundaries/sides",
-                                   "vertex",
-                                   {
-                                       "point": "{0}, {1}".format(v[0], v[1])
-                                   },
-                                   True))
+            adds.append(definition.ElementAdd(f".//physics_engines/*[@id='{name}']/boundaries/sides",
+                                              "vertex",
+                                              {
+                                                  "point": "{0}, {1}".format(v[0], v[1])
+            },
+                True))
         return adds
 
-    def _gen1_engines(self) -> xml.TagAddList:
+    def _gen1_engines(self) -> definition.ElementAddList:
         """Generate definitions for 1 physics engine for the specified extent.
 
         """
 
         name = self._gen_engine_name(0)
 
-        return xml.TagAddList(xml.TagAdd('.', 'physics_engines', {}, False),
-                              xml.TagAdd(".//physics_engines",
-                                         self.engine_type,
-                                         {
-                                             'id': name
-                                         },
-                                         True))
+        return definition.ElementAddList(definition.ElementAdd('.', 'physics_engines', {}, False),
+                                         definition.ElementAdd(".//physics_engines",
+                                                               self.engine_type,
+                                                               {
+                                                                   'id': name
+                                                               },
+                                                               True))
 
-    def _gen2_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen2_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 2 physics engines for the specified extents.
 
         Engines are layed out as follows in 2D, regardless if they are 2D or 3D
@@ -271,7 +267,7 @@ class PhysicsEngines():
                                      n_engines_y=1,
                                      forward_engines=[])
 
-    def _gen4_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen4_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 4 physics engines for the specified extent.
 
         Engines are layed out as follows in 2D, regardless if they are 2D or 3D
@@ -290,7 +286,7 @@ class PhysicsEngines():
                                      n_engines_y=2,
                                      forward_engines=[0, 1])
 
-    def _gen6_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen6_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 6 physics engines for the specified extent.
 
         Engines are layed out as follows in 2D, regardless if they are 2D or 3D
@@ -309,7 +305,7 @@ class PhysicsEngines():
                                      n_engines_y=2,
                                      forward_engines=[0, 1, 2])
 
-    def _gen8_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen8_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 8 physics engines for the specified extent.
 
         The 2D layout is:
@@ -327,7 +323,7 @@ class PhysicsEngines():
                                      n_engines_y=2,
                                      forward_engines=[0, 1, 2, 3])
 
-    def _gen12_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen12_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 12 physics engines for the specified extent.
 
         The 2D layout is:
@@ -346,7 +342,7 @@ class PhysicsEngines():
                                      n_engines_y=3,
                                      forward_engines=[0, 1, 2, 3, 8, 9, 10, 11])
 
-    def _gen16_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen16_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 16 physics engines for the specified extent.
 
         The 2D layout is:
@@ -366,7 +362,7 @@ class PhysicsEngines():
                                      n_engines_y=4,
                                      forward_engines=[0, 1, 2, 3, 8, 9, 10, 11])
 
-    def _gen24_engines(self, extent: ArenaExtent) -> xml.TagAddList:
+    def _gen24_engines(self, extent: ArenaExtent) -> definition.ElementAddList:
         """Generate definitions for 16 physics engines for the specified extent.
 
         The 2D layout is:
@@ -434,7 +430,7 @@ class PhysicsEngines2D(PhysicsEngines):
                           extent: ArenaExtent,
                           n_engines_x: int,
                           n_engines_y: int,
-                          forward_engines: tp.List[int]) -> xml.TagAddList:
+                          forward_engines: tp.List[int]) -> definition.ElementAddList:
         adds = super().gen_single_engine(engine_id,
                                          extent,
                                          n_engines_x,
@@ -442,13 +438,13 @@ class PhysicsEngines2D(PhysicsEngines):
                                          forward_engines)
         if self.engine_type == 'dynamics2d' and self.spatial_hash_info is not None:
             name = self._gen_engine_name(engine_id)
-            adds.append(xml.TagAdd(f".//physics_engines/*[@id='{name}']",
-                                   "spatial_hash",
-                                   {
-                                       'cell_size': str(self.spatial_hash_info['cell_size']),
-                                       'cell_num': str(self.spatial_hash_info['cell_num'])
-                                   },
-                                   True))
+            adds.append(definition.ElementAdd(f".//physics_engines/*[@id='{name}']",
+                                              "spatial_hash",
+                                              {
+                                                  'cell_size': str(self.spatial_hash_info['cell_size']),
+                                                  'cell_num': str(self.spatial_hash_info['cell_num'])
+            },
+                True))
         return adds
 
 
@@ -473,7 +469,7 @@ class PhysicsEngines3D(PhysicsEngines):
 
 def factory(engine_type: str,
             n_engines: int,
-            n_robots: tp.Optional[int],
+            n_agents: tp.Optional[int],
             robot_type: str,
             cmdopts: types.Cmdopts,
             extents: tp.List[ArenaExtent]) -> PhysicsEngines:
@@ -484,11 +480,11 @@ def factory(engine_type: str,
     # remain so in the future, so we employ a factory function to make
     # implementation of diverging functionality easier later.
     if '2d' in engine_type:
-        if n_robots and cmdopts['physics_spatial_hash2D']:
+        if n_agents and cmdopts['physics_spatial_hash2D']:
             spatial_hash = {
                 # Per ARGoS documentation in 'argos3 -q dynamics2d'
                 'cell_size': config.kARGoS['spatial_hash2D'][robot_type],
-                'cell_num': n_robots / float(n_engines) * 10
+                'cell_num': n_agents / float(n_engines) * 10
             }
             logging.debug(("Using 2D spatial hash for physics engines: "
                            "cell_size=%f,cell_num=%d"),
@@ -511,7 +507,7 @@ def factory(engine_type: str,
                                 extents)
 
 
-__api__ = [
+__all__ = [
     'PhysicsEngines',
     'PhysicsEngines2D',
     'PhysicsEngines3D',

sierra/plugins/engine/argos/variables/population_constant_density.py

@@ -0,0 +1,178 @@
+# Copyright 2021 John Harwell, All rights reserved.
+#
+#  SPDX-License-Identifier: MIT
+#
+"""Classes for the constant population density batch criteria.
+
+See :ref:`plugins/engine/argos/bc/population-constant-density` for usage
+documentation.
+
+"""
+
+# Core packages
+import typing as tp
+import logging
+import math
+import pathlib
+
+# 3rd party packages
+import implements
+
+# Project packages
+from sierra.plugins.engine.argos.variables import constant_density as cd
+from sierra.core import utils, types
+from sierra.core.vector import Vector3D
+from sierra.core.experiment import definition
+from sierra.core.graphs import bcbridge
+
+
+@implements.implements(bcbridge.IGraphable)
+class PopulationConstantDensity(cd.ConstantDensity):
+    """Defines XML changes for maintain population density across arena sizes.
+
+    This class is a base class which should (almost) never be used on its
+    own. Instead, the ``factory()`` function should be used to dynamically
+    create derived classes expressing the user's desired density.
+
+    Does not change the # blocks/block manifest.
+
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        cd.ConstantDensity.__init__(self, *args, **kwargs)
+        self.already_added = False
+        self.logger = logging.getLogger(__name__)
+
+    def gen_attr_changelist(self) -> tp.List[definition.AttrChangeSet]:
+        """Generate XML modifications to to maintain constant population density.
+
+        Robots are approximated as point masses.
+
+        """
+        if not self.already_added:
+            for changeset in self.attr_changes:
+                for path, attr, value in changeset:
+
+                    if path == ".//arena" and attr == "size":
+                        x, y, z = [int(float(_)) for _ in value.split(",")]
+                        extent = utils.ArenaExtent(Vector3D(x, y, z))
+                        # ARGoS won't start if there are 0 robots, so you always
+                        # need to put at least 1.
+                        n_agents = int(extent.area() * (self.target_density / 100.0))
+                        if n_agents == 0:
+                            n_agents = 1
+                            self.logger.warning(
+                                (
+                                    "n_agents set to 1 even though "
+                                    "calculated as 0 for area=%s,"
+                                    "density=%s"
+                                ),
+                                str(extent.area()),
+                                self.target_density / 100.0,
+                            )
+
+                        changeset.add(
+                            definition.AttrChange(
+                                ".//arena/distribute/entity", "quantity", str(n_agents)
+                            )
+                        )
+                        self.logger.debug(
+                            "Calculated population size=%d for extent=%s,density=%s",
+                            n_agents,
+                            str(extent),
+                            self.target_density,
+                        )
+                        break
+
+            self.already_added = True
+
+        return self.attr_changes
+
+    def graph_info(
+        self,
+        cmdopts: types.Cmdopts,
+        batch_output_root: tp.Optional[pathlib.Path] = None,
+        exp_names: tp.Optional[tp.List[str]] = None,
+    ) -> bcbridge.GraphInfo:
+        info = bcbridge.GraphInfo(
+            cmdopts,
+            batch_output_root,
+            exp_names if exp_names else self.gen_exp_names(),
+        )
+        if info.cmdopts["plot_log_xscale"]:
+            info.xlabel = r"$\log_{2}$(Population Size)"
+        else:
+            info.xlabel = "Population Size"
+
+        tmp = map(float, self.populations(info.cmdopts, info.exp_names))
+
+        info.xticklabels = list(map(lambda x: str(int(round(x, 4))), tmp))
+
+        tmp2 = list(map(float, self.populations(info.cmdopts, info.exp_names)))
+
+        if info.cmdopts["plot_log_xscale"]:
+            info.xticks = [int(math.log2(x)) for x in tmp2]
+        elif info.cmdopts["plot_enumerated_xscale"]:
+            info.xticks = list(range(0, len(tmp2)))
+
+        return info
+
+    def n_agents(self, exp_num: int) -> int:
+        return int(self.target_density / 100.0 * self.dimensions[exp_num].area())
+
+
+def calc_dims(
+    cmdopts: types.Cmdopts, attr: types.CLIArgSpec, **kwargs
+) -> tp.List[utils.ArenaExtent]:
+
+    kw = utils.gen_scenario_spec(cmdopts, **kwargs)
+
+    is_2x1 = kw["arena_x"] == 2 * kw["arena_y"]
+    is_1x1 = kw["arena_x"] == kw["arena_y"]
+
+    if is_2x1:
+        r = range(
+            kw["arena_x"],
+            kw["arena_x"] + attr["cardinality"] * attr["arena_size_inc"],
+            attr["arena_size_inc"],
+        )
+        return list(
+            utils.ArenaExtent(Vector3D(x, int(x / 2), kw["arena_z"])) for x in r
+        )
+    elif is_1x1:
+        r = range(
+            kw["arena_x"],
+            kw["arena_x"] + attr["cardinality"] * attr["arena_size_inc"],
+            attr["arena_size_inc"],
+        )
+
+        return list(utils.ArenaExtent(Vector3D(x, x, kw["arena_z"])) for x in r)
+    else:
+        raise NotImplementedError(
+            "Unsupported arena X,Y scaling '{0}': Must be [2x1,1x1]"
+        )
+
+
+def factory(
+    cli_arg: str,
+    main_config: types.YAMLDict,
+    cmdopts: types.Cmdopts,
+    batch_input_root: pathlib.Path,
+    **kwargs,
+) -> PopulationConstantDensity:
+    """Create a :class:`PopulationConstantDensity` derived class."""
+    attr = cd.parse(cli_arg)
+    kw = utils.gen_scenario_spec(cmdopts, **kwargs)
+    dims = calc_dims(cmdopts, attr, **kwargs)
+
+    return PopulationConstantDensity(
+        cli_arg,
+        main_config,
+        batch_input_root,
+        attr["target_density"],
+        dims,
+        kw["scenario_tag"],
+    )
+
+
+__all__ = ["PopulationConstantDensity"]

sierra/plugins/engine/argos/variables/population_size.py

@@ -0,0 +1,115 @@
+# Copyright 2020 John Harwell, All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+"""Classes for the population size batch criteria.
+
+See :ref:`plugins/engine/argos/bc/population-size` for usage documentation.
+
+"""
+
+# Core packages
+import typing as tp
+import pathlib
+
+# 3rd party packages
+import implements
+
+# Project packages
+from sierra.core.variables import batch_criteria as bc
+from sierra.core.experiment import definition
+from sierra.core import types
+from sierra.core.variables import population_size
+from sierra.core.graphs import bcbridge
+
+
+@implements.implements(bcbridge.IGraphable)
+@implements.implements(bc.IQueryableBatchCriteria)
+class PopulationSize(population_size.PopulationSize):
+    """A univariate range of swarm sizes used to define batch experiments.
+
+    This class is a base class which should (almost) never be used on its
+    own. Instead, the ``factory()`` function should be used to dynamically
+    create derived classes expressing the user's desired size distribution.
+
+    Note: Usage of this class assumes homogeneous swarms.
+
+    Attributes:
+        size_list: List of integer swarm sizes defining the range of the
+                   variable for the batch experiment.
+
+    """
+
+    @staticmethod
+    def gen_attr_changelist_from_list(
+        sizes: tp.List[int],
+    ) -> tp.List[definition.AttrChangeSet]:
+        return [
+            definition.AttrChangeSet(
+                definition.AttrChange(".//arena/distribute/entity", "quantity", str(s))
+            )
+            for s in sizes
+        ]
+
+    def __init__(
+        self,
+        cli_arg: str,
+        main_config: types.YAMLDict,
+        batch_input_root: pathlib.Path,
+        size_list: tp.List[int],
+    ) -> None:
+        population_size.PopulationSize.__init__(
+            self, cli_arg, main_config, batch_input_root
+        )
+        self.size_list = size_list
+        self.attr_changes = []  # type: tp.List[definition.AttrChangeSet]
+
+    def gen_attr_changelist(self) -> tp.List[definition.AttrChangeSet]:
+        """
+        Generate list of sets of changes for swarm sizes to define a batch experiment.
+        """
+
+        if not self.attr_changes:
+            self.attr_changes = PopulationSize.gen_attr_changelist_from_list(
+                self.size_list
+            )
+        return self.attr_changes
+
+    def n_agents(self, exp_num: int) -> int:
+        return self.size_list[exp_num]
+
+    def graph_info(
+        self,
+        cmdopts: types.Cmdopts,
+        batch_output_root: tp.Optional[pathlib.Path] = None,
+        exp_names: tp.Optional[tp.List[str]] = None,
+    ) -> bcbridge.GraphInfo:
+        info = bcbridge.GraphInfo(
+            cmdopts,
+            batch_output_root,
+            exp_names if exp_names else self.gen_exp_names(),
+        )
+
+        info.xlabel = super().graph_xlabel(info.cmdopts)
+        info.xticklabels = super().graph_xticklabels(
+            info.cmdopts, info.batch_output_root, info.exp_names
+        )
+        info.xticks = super().graph_xticks(
+            info.cmdopts, info.batch_output_root, info.exp_names
+        )
+        return info
+
+
+def factory(
+    cli_arg: str,
+    main_config: types.YAMLDict,
+    cmdopts: types.Cmdopts,
+    batch_input_root: pathlib.Path,
+    **kwargs,
+) -> PopulationSize:
+    """Create a :class:`PopulationSize` derived class from the cmdline definition."""
+    max_sizes = population_size.parse(cli_arg)
+
+    return PopulationSize(cli_arg, main_config, batch_input_root, max_sizes)
+
+
+__all__ = ["PopulationSize"]