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

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

@@ -1,102 +0,0 @@
-# Copyright 2020 John Harwell, All rights reserved.
-#
-# SPDX-License-Identifier: MIT
-"""Classes for the population size batch criteria.
-
-See :ref:`ln-sierra-platform-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 xml
-from sierra.core import types
-from sierra.core.variables import population_size
-
-
-@implements.implements(bc.IConcreteBatchCriteria)
-@implements.implements(bc.IQueryableBatchCriteria)
-class PopulationSize(population_size.BasePopulationSize):
-    """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[xml.AttrChangeSet]:
-        return [xml.AttrChangeSet(xml.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.BasePopulationSize.__init__(self,
-                                                    cli_arg,
-                                                    main_config,
-                                                    batch_input_root)
-        self.size_list = size_list
-        self.attr_changes = []  # type: tp.List[xml.AttrChangeSet]
-
-    def gen_attr_changelist(self) -> tp.List[xml.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 gen_exp_names(self, cmdopts: types.Cmdopts) -> tp.List[str]:
-        changes = self.gen_attr_changelist()
-        return ['exp' + str(x) for x in range(0, len(changes))]
-
-    def n_robots(self, exp_num: int) -> int:
-        return self.size_list[exp_num]
-
-
-def factory(cli_arg: str,
-            main_config: types.YAMLDict,
-            cmdopts: types.Cmdopts,
-            **kwargs) -> PopulationSize:
-    """Create a :class:`PopulationSize` derived class from the cmdline definition.
-
-    """
-    parser = population_size.Parser()
-    max_sizes = parser.to_sizes(parser(cli_arg))
-
-    def __init__(self) -> None:
-        PopulationSize.__init__(self,
-                                cli_arg,
-                                main_config,
-                                cmdopts['batch_input_root'],
-                                max_sizes)
-
-    return type(cli_arg,  # type: ignore
-                (PopulationSize,),
-                {"__init__": __init__})
-
-
-__api__ = [
-    'PopulationSize'
-]

sierra/plugins/platform/argos/variables/population_variable_density.py

@@ -1,132 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-#
-"""Classes for the variable population density batch criteria.
-
-See :ref:`ln-sierra-platform-argos-bc-population-variable-density` for usage
-documentation.
-
-"""
-
-# Core packages
-import typing as tp
-import logging
-import numpy as np
-
-# 3rd party packages
-import implements
-
-# Project packages
-from sierra.core.variables import variable_density as vd
-import sierra.core.variables.batch_criteria as bc
-from sierra.core.vector import Vector3D
-from sierra.core.experiment import xml
-from sierra.core import types, utils
-
-
-@implements.implements(bc.IConcreteBatchCriteria)
-class PopulationVariableDensity(vd.VariableDensity):
-    """Defines XML changes for variable population density within a single arena.
-
-    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 ranges.
-
-    """
-
-    def __init__(self, *args, **kwargs) -> None:
-        vd.VariableDensity.__init__(self, *args, **kwargs)
-        self.already_added = False
-        self.logger = logging.getLogger(__name__)
-
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
-        """Generate XML modifications to achieve the desired population densities.
-
-        Robots are approximated as point masses.
-
-        """
-        if not self.already_added:
-            for density in self.densities:
-                # ARGoS won't start if there are 0 robots, so you always
-                # need to put at least 1.
-                n_robots = int(self.extent.area() * (density / 100.0))
-                if n_robots == 0:
-                    n_robots = 1
-                    self.logger.warning("n_robots set to 1 even though \
-                    calculated as 0 for area=%d,density=%s",
-                                        self.extent.area(),
-                                        density)
-                changeset = xml.AttrChangeSet(xml.AttrChange(".//arena/distribute/entity",
-                                                             "quantity",
-                                                             str(n_robots)))
-                self.attr_changes.append(changeset)
-                self.logger.debug("Calculated swarm size=%d for extent=%s,density=%s",
-                                  n_robots,
-                                  str(self.extent),
-                                  density)
-
-            self.already_added = True
-
-        return self.attr_changes
-
-    def gen_exp_names(self, cmdopts: types.Cmdopts) -> tp.List[str]:
-        changes = self.gen_attr_changelist()
-        return ['exp' + str(x) for x in range(0, len(changes))]
-
-    def graph_xticks(self,
-                     cmdopts: types.Cmdopts,
-                     exp_names: tp.Optional[tp.List[str]] = None) -> tp.List[float]:
-
-        if exp_names is None:
-            exp_names = self.gen_exp_names(cmdopts)
-
-        return [p / self.extent.area() for p in self.populations(cmdopts, exp_names)]
-
-    def graph_xticklabels(self,
-                          cmdopts: types.Cmdopts,
-                          exp_names: tp.Optional[tp.List[str]] = None) -> tp.List[str]:
-        return list(map(lambda x: str(round(x, 4)),
-                        self.graph_xticks(cmdopts, exp_names)))
-
-    def graph_xlabel(self, cmdopts: types.Cmdopts) -> str:
-        return r"Population Density"
-
-    def n_robots(self, exp_num: int) -> int:
-        return int(self.extent.area() * self.densities[exp_num] / 100.0)
-
-
-def factory(cli_arg: str,
-            main_config: types.YAMLDict,
-            cmdopts: types.Cmdopts,
-            **kwargs) -> PopulationVariableDensity:
-    """
-    Create a :class:`PopulationVariableDensity` derived class.
-    """
-    attr = vd.Parser()(cli_arg)
-    kw = utils.gen_scenario_spec(cmdopts, **kwargs)
-
-    extent = utils.ArenaExtent(Vector3D(kw['arena_x'],
-                                        kw['arena_y'],
-                                        kw['arena_z']))
-
-    densities = list(x for x in np.linspace(attr['density_min'],
-                                            attr['density_max'],
-                                            num=attr['cardinality']))
-
-    def __init__(self) -> None:
-        PopulationVariableDensity.__init__(self,
-                                           cli_arg,
-                                           main_config,
-                                           cmdopts['batch_input_root'],
-                                           densities,
-                                           extent)
-
-    return type(cli_arg,  # type: ignore
-                (PopulationVariableDensity,),
-                {"__init__": __init__})
-
-
-__api__ = [
-    'PopulationVariableDensity'
-]

sierra/plugins/platform/argos/variables/rendering.py

@@ -1,104 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-
-"""
-ARGoS headless QT rendering configuration.
-"""
-
-# Core packages
-import typing as tp
-
-# 3rd party packages
-import implements
-
-# Project packages
-from sierra.core.variables.base_variable import IBaseVariable
-from sierra.core.experiment import xml
-import sierra.core.config
-from sierra.core import types
-
-import sierra.plugins.platform.argos.variables.exp_setup as exp
-
-
-@implements.implements(IBaseVariable)
-class ARGoSQTHeadlessRendering():
-    """
-    Sets up ARGoS headless rendering with QT.
-
-    Attributes:
-
-        tsetup: Simulation time definitions.
-
-        extents: List of (X,Y,Zs) tuple of dimensions of area to assign to
-                 engines of the specified type.
-    """
-
-    kFrameSize = "1600x1200"
-    kQUALITY = 100
-    kFRAME_RATE = 10
-
-    def __init__(self, setup: exp.ExpSetup) -> None:
-        self.setup = setup
-        self.tag_adds = []  # type: tp.List[xml.TagAddList]
-
-    def gen_attr_changelist(self) -> tp.List[xml.AttrChangeSet]:
-        """
-        No effect.
-
-        All tags/attributes are either deleted or added.
-        """
-        return []
-
-    def gen_tag_rmlist(self) -> tp.List[xml.TagRmList]:
-        """Remove the ``<qt_opengl>`` tag if it exists.
-
-        Obviously you *must* call this function BEFORE adding new definitions.
-
-        """
-        return [xml.TagRmList(xml.TagRm("./visualization", "qt-opengl"))]
-
-    def gen_tag_addlist(self) -> tp.List[xml.TagAddList]:
-        if not self.tag_adds:
-            self.tag_adds = [xml.TagAddList(xml.TagAdd('.',
-                                                       'visualization',
-                                                       {},
-                                                       False),
-                                            xml.TagAdd('./visualization',
-                                                       'qt-opengl',
-                                                       {'autoplay': "true"},
-                                                       False
-                                                       ),
-                                            xml.TagAdd('./visualization/qt-opengl',
-                                                       'frame_grabbing',
-                                                       {
-                                                           'directory': 'frames',
-                                                           'base_name': 'frame_',
-                                                           'format': sierra.core.config.kImageExt[1:],
-                                                           'headless_grabbing': "true",
-                                                           'headless_frame_size': "{0}".format(self.kFrameSize),
-                                                           'headless_frame_rate': "{0}".format(self.kFRAME_RATE),
-                                                       },
-                                                       False),
-                                            xml.TagAdd('visualization/qt-opengl',
-                                                       'user_functions',
-                                                       {'label': '__EMPTY__'},
-                                                       False))]
-
-        return self.tag_adds
-
-    def gen_files(self) -> None:
-        pass
-
-
-def factory(cmdopts: types.Cmdopts) -> ARGoSQTHeadlessRendering:
-    """Set up QT headless rendering for the specified experimental setup.
-
-    """
-
-    return ARGoSQTHeadlessRendering(exp.factory(cmdopts["exp_setup"]))
-
-
-__api__ = [
-    'ARGoSQTHeadlessRendering',
-]

sierra/plugins/platform/ros1gazebo/__init__.py

@@ -1,9 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-
-# Core packages
-
-# 3rd party packages
-
-# Project packages

sierra/plugins/platform/ros1gazebo/cmdline.py

@@ -1,213 +0,0 @@
-# Copyright 2021 John Harwell, All rights reserved.
-#
-#  SPDX-License-Identifier: MIT
-#
-"""
-Command line parsing and validation for the :term:`ROS1+Gazebo` platform.
-"""
-
-# Core packages
-import typing as tp
-import argparse
-
-# 3rd party packages
-
-# Project packages
-from sierra.core import types
-from sierra.core import config
-import sierra.core.cmdline as corecmd
-from sierra.core import hpc, ros1
-
-
-class PlatformCmdline(corecmd.BaseCmdline):
-    """Defines :term:`ROS1+Gazebo` extensions to :class:`~sierra.core.cmdline.CoreCmdline`.
-
-    """
-
-    def __init__(self,
-                 parents: tp.Optional[tp.List[argparse.ArgumentParser]],
-                 stages: tp.List[int]) -> None:
-
-        if parents is not None:
-            self.parser = argparse.ArgumentParser(parents=parents,
-                                                  add_help=False,
-                                                  allow_abbrev=False)
-        else:
-            self.parser = argparse.ArgumentParser(add_help=False,
-                                                  allow_abbrev=False)
-
-        self.scaffold_cli()
-        self.init_cli(stages)
-
-    def scaffold_cli(self) -> None:
-        self.stage1_exp = self.parser.add_argument_group('Stage1: Experiment setup')
-        self.stage1_physics = self.parser.add_argument_group(
-            'Stage1: Configuring Gazebo physics engines')
-
-    def init_cli(self, stages: tp.List[int]) -> None:
-        if 1 in stages:
-            self.init_stage1()
-
-    def init_stage1(self) -> None:
-        # Experiment options
-        positions_omitted_doc = ("If omitted: effective arena dimensions must "
-                                 "be given as part of ``--scenario``.")
-
-        self.stage1_exp.add_argument("--robot-positions",
-
-                                     help="""
-
-                                     A list of space-separated "X,Y,Z" tuples
-                                     (no quotes) passed on the command line as
-                                     valid starting positions for the robots
-                                     within the world.
-
-                                     """ + self.stage_usage_doc([1],
-                                                                positions_omitted_doc),
-                                     nargs='+',
-                                     default=[])
-
-        # Physics engines options
-        self.stage1_physics.add_argument("--physics-engine-type",
-                                         choices=['ode', 'bullet',
-                                                  'dart', 'simbody'],
-                                         help="""
-
-                                         The type of 3D physics engine to use
-                                         for managing spatial extents within the
-                                         arena, choosing one of the types that
-                                         :term:`Gazebo` supports. A single
-                                         engine instance is used to manage all
-                                         physics in the arena.
-
-                                         """ + self.stage_usage_doc([1]),
-                                         default='ode')
-
-        self.stage1_physics.add_argument("--physics-iter-per-tick",
-                                         type=int,
-                                         help="""
-
-                                         The # of iterations all physics engines
-                                         should perform per tick each time the
-                                         controller loops are run (the # of
-                                         ticks per second for controller control
-                                         loops is set via ``--exp-setup``).
-
-                             """ + self.stage_usage_doc([1]),
-                                         default=config.kGazebo['physics_iter_per_tick'])
-
-        self.stage1_physics.add_argument("--physics-n-threads",
-                                         type=int,
-                                         help="""
-
-                                         Gazebo can group non-interacting
-                                         entities into computational "islands"
-                                         and do the physics updates for those
-                                         islands in parallel each timestep
-                                         (islands) are recomputed after each
-                                         timestep). Gazebo can also parallelize
-                                         the computation of velocity/position
-                                         updates with the computation of
-                                         resolving collisions (i.e., the
-                                         timestep impulse results in one entity
-                                         "inside" another). You can assign
-                                         multiple threads to a pool for
-                                         cumulative use for these two
-                                         parallelization methods (threads will
-                                         be allocated evenly between them). The
-                                         point at which adding more threads will
-                                         start to DECREASE performance depends
-                                         on the complexity of your world, the
-                                         number and type of robots in it, etc.,
-                                         so don't just set this parameter to the
-                                         # of cores for your machine as a
-                                         default.
-
-                                         From the Gazebo Parallel Physics
-                                         Report, setting the pool size to the #
-                                         robots/# joint trees in your simulation
-                                         usually gives good results, as long as
-                                         you have more cores available than you
-                                         allocate to this pool (Gazebo has other
-                                         threads too).
-
-                                         This only applies if
-                                         ``--physics-engine-type``\\=ode.
-
-                                         A value of 0=no threads.
-
-                                         """ + self.stage_usage_doc([1]),
-                                         default=0)
-
-        self.stage1_physics.add_argument("--physics-ec-threadpool",
-                                         type=int,
-                                         help="""
-
-                                         Gazebo can parallelize the computation
-                                         of velocity/position updates with the
-                                         computation of resolving collisions
-                                         (i.e., the timestep impulse results in
-                                         one entity "inside" another). You can
-                                         assign multiple threads to a pool for
-                                         cumulative use for this purpose. The
-                                         point at which adding more threads will
-                                         start to DECREASE performance depends
-                                         on the complexity of your world, the
-                                         number and type of robots in it, etc.,
-                                         so don't just set this parameter to the
-                                         # of cores for your machine as a
-                                         default.
-
-                                         From the Gazebo Parallel Physics
-                                         Report, setting the pool size to the #
-                                         robots/#joint trees in your simulation
-                                         usually gives good results, as long as
-                                         you have more cores than than you
-                                         allocate to physics (Gazebo has other
-                                         threads too).
-
-                                         This only applies if ``--physics-engine-type``\\=ode.
-
-                                         A value of 0=no threads.
-
-                                         """ + self.stage_usage_doc([1]),
-                                         default=0)
-
-    @staticmethod
-    def cmdopts_update(cli_args: argparse.Namespace,
-                       cmdopts: types.Cmdopts) -> None:
-        """Update cmdopts with ROS1+Gazebo-specific cmdline options.
-
-        """
-        hpc.cmdline.HPCCmdline.cmdopts_update(cli_args, cmdopts)
-        ros1.cmdline.ROSCmdline.cmdopts_update(cli_args, cmdopts)
-
-        updates = {
-            # stage 1
-            'robot_positions': cli_args.robot_positions,
-
-            'physics_n_engines': 1,  # Always 1 for gazebo...
-            'physics_n_threads': cli_args.physics_n_threads,
-            'physics_engine_type': cli_args.physics_engine_type,
-            'physics_iter_per_tick': cli_args.physics_iter_per_tick,
-        }
-
-        cmdopts.update(updates)
-
-
-class CmdlineValidator(corecmd.CoreCmdlineValidator):
-    """
-    Stub implementation.
-    """
-
-
-def sphinx_cmdline_stage1():
-    parent1 = hpc.cmdline.HPCCmdline([1]).parser
-    parent2 = ros1.cmdline.ROSCmdline([1]).parser
-    return PlatformCmdline([parent1, parent2], [1]).parser
-
-
-def sphinx_cmdline_stage2():
-    parent1 = hpc.cmdline.HPCCmdline([2]).parser
-    parent2 = ros1.cmdline.ROSCmdline([2]).parser
-    return PlatformCmdline([parent1, parent2], [2]).parser