def _add_config(self):
        # Add config data to the trajectory
        if self._do_single_runs:
            # Only add parameters if we actually want single runs to be performed
            config_name = 'environment.%s.multiproc' % self.name
            self._traj.f_add_config(Parameter, config_name, self._multiproc,
                                    comment='Whether or not to use multiprocessing.').f_lock()

            if self._multiproc:
                config_name = 'environment.%s.use_pool' % self.name
                self._traj.f_add_config(Parameter, config_name, self._use_pool,
                                        comment='Whether to use a pool of processes or '
                                                'spawning individual processes for '
                                                'each run.').f_lock()

                config_name = 'environment.%s.use_scoop' % self.name
                self._traj.f_add_config(Parameter, config_name, self._use_scoop,
                                        comment='Whether to use scoop to launch single '
                                                'runs').f_lock()

                if self._niceness is not None:
                    config_name = 'environment.%s.niceness' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._niceness,
                                        comment='Niceness value of child processes.').f_lock()

                if self._use_pool:
                    config_name = 'environment.%s.freeze_input' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._freeze_input,
                                        comment='If inputs to each run are static and '
                                                'are not mutated during each run, '
                                                'can speed up pool running.').f_lock()

                elif self._use_scoop:
                    pass
                else:
                    config_name = 'environment.%s.cpu_cap' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._cpu_cap,
                                            comment='Maximum cpu usage beyond '
                                                    'which no new processes '
                                                    'are spawned.').f_lock()

                    config_name = 'environment.%s.memory_cap' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._memory_cap,
                                            comment='Tuple, first entry: Maximum RAM usage beyond '
                                                    'which no new processes are spawned; '
                                                    'second entry: Estimated usage per '
                                                    'process in MB. 0 if not estimated.').f_lock()

                    config_name = 'environment.%s.swap_cap' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._swap_cap,
                                            comment='Maximum Swap memory usage beyond '
                                                    'which no new '
                                                    'processes are spawned').f_lock()

                    config_name = 'environment.%s.immediate_postprocessing' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._immediate_postproc,
                                            comment='Whether to use immediate '
                                                    'postprocessing.').f_lock()

                config_name = 'environment.%s.ncores' % self.name
                self._traj.f_add_config(Parameter, config_name, self._ncores,
                                        comment='Number of processors in case of '
                                                'multiprocessing').f_lock()

                config_name = 'environment.%s.wrap_mode' % self.name
                self._traj.f_add_config(Parameter, config_name, self._wrap_mode,
                                        comment='Multiprocessing mode (if multiproc),'
                                                ' i.e. whether to use QUEUE'
                                                ' or LOCK or NONE'
                                                ' for thread/process safe storing').f_lock()

                if (self._wrap_mode == pypetconstants.WRAP_MODE_QUEUE or
                                self._wrap_mode == pypetconstants.WRAP_MODE_PIPE):
                    config_name = 'environment.%s.queue_maxsize' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._queue_maxsize,
                                        comment='Maximum size of Storage Queue/Pipe in case of '
                                                'multiprocessing and QUEUE/PIPE wrapping').f_lock()

                if self._wrap_mode == pypetconstants.WRAP_MODE_NETLOCK:
                    config_name = 'environment.%s.url' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._url,
                                        comment='URL of lock distribution server, including '
                                                'protocol and port.').f_lock()

                if self._wrap_mode == pypetconstants.WRAP_MODE_NETLOCK or self._use_scoop:
                    config_name = 'environment.%s.timeout' % self.name
                    timeout = self._timeout
                    if timeout is None:
                        timeout = -1.0
                    self._traj.f_add_config(Parameter, config_name, timeout,
                                        comment='Timout for scoop and NETLOCK, '
                                                '-1.0 means no timeout.').f_lock()

                if (self._gc_interval and
                        (self._wrap_mode == pypetconstants.WRAP_MODE_LOCAL or
                            self._wrap_mode == pypetconstants.WRAP_MODE_QUEUE or
                                self._wrap_mode == pypetconstants.WRAP_MODE_PIPE)):
                    config_name = 'environment.%s.gc_interval' % self.name
                    self._traj.f_add_config(Parameter, config_name, self._gc_interval,
                                        comment='Intervals with which ``gc.collect()`` '
                                                'is called.').f_lock()


            config_name = 'environment.%s.clean_up_runs' % self._name
            self._traj.f_add_config(Parameter, config_name, self._clean_up_runs,
                                    comment='Whether or not results should be removed after the '
                                            'completion of a single run. '
                                            'You are not advised to set this '
                                            'to `False`. Only do it if you know what you are '
                                            'doing.').f_lock()

            config_name = 'environment.%s.resumable' % self._name
            self._traj.f_add_config(Parameter, config_name, self._resumable,
                                    comment='Whether or not resume files should '
                                            'be created. If yes, everything is '
                                            'handled by `dill`.').f_lock()

            config_name = 'environment.%s.graceful_exit' % self._name
            self._traj.f_add_config(Parameter, config_name, self._graceful_exit,
                                    comment='Whether or not to allow graceful handling '
                                            'of `SIGINT` (`CTRL+C`).').f_lock()

        config_name = 'environment.%s.trajectory.name' % self.name
        self._traj.f_add_config(Parameter, config_name, self.trajectory.v_name,
                                comment='Name of trajectory').f_lock()

        config_name = 'environment.%s.trajectory.timestamp' % self.name
        self._traj.f_add_config(Parameter, config_name, self.trajectory.v_timestamp,
                                comment='Timestamp of trajectory').f_lock()

        config_name = 'environment.%s.timestamp' % self.name
        self._traj.f_add_config(Parameter, config_name, self.timestamp,
                                comment='Timestamp of environment creation').f_lock()

        config_name = 'environment.%s.hexsha' % self.name
        self._traj.f_add_config(Parameter, config_name, self.hexsha,
                                comment='SHA-1 identifier of the environment').f_lock()

        config_name = 'environment.%s.automatic_storing' % self.name
        if not self._traj.f_contains('config.' + config_name):
            self._traj.f_add_config(Parameter, config_name, self._automatic_storing,
                                    comment='If trajectory should be stored automatically in the '
                                            'end.').f_lock()

        try:
            config_name = 'environment.%s.script' % self.name
            self._traj.f_add_config(Parameter, config_name, main.__file__,
                                    comment='Name of the executed main script').f_lock()
        except __HOLE__:
            pass  # We end up here if we use pypet within an ipython console

        for package_name, version in pypetconstants.VERSIONS_TO_STORE.items():
            config_name = 'environment.%s.versions.%s' % (self.name, package_name)
            self._traj.f_add_config(Parameter, config_name, version,
                                    comment='Particular version of a package or distribution '
                                            'used during experiment. N/A if package could not '
                                            'be imported.').f_lock()

        self._traj.config.environment.v_comment = 'Settings for the different environments ' \
                                                  'used to run the experiments'
dataset/ETHPy150Open SmokinCaterpillar/pypet/pypet/environment.py/Environment._add_config