@not_in_run<EOL><INDENT>def f_explore(self, build_dict):<DEDENT>
for run_idx in range(len(self)):<EOL><INDENT>if self.f_is_completed(run_idx):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>added_explored_parameters = []<EOL>try:<EOL><INDENT>length = len(self)<EOL>for key, builditerable in build_dict.items():<EOL><INDENT>act_param = self.f_get(key)<EOL>if not act_param.v_is_leaf or not act_param.v_is_parameter:<EOL><INDENT>raise ValueError('<STR_LIT>' % key)<EOL><DEDENT>act_param.f_unlock()<EOL>act_param._explore(builditerable)<EOL>added_explored_parameters.append(act_param)<EOL>full_name = act_param.v_full_name<EOL>self._explored_parameters[full_name] = act_param<EOL>act_param._explored = True<EOL>if len(self._explored_parameters) == <NUM_LIT:1>:<EOL><INDENT>length = act_param.f_get_range_length()<EOL><DEDENT>elif not length == act_param.f_get_range_length():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>for irun in range(length):<EOL><INDENT>self._add_run_info(irun)<EOL><DEDENT>self._test_run_addition(length)<EOL><DEDENT>except Exception:<EOL><INDENT>for param in added_explored_parameters:<EOL><INDENT>param.f_unlock()<EOL>param._shrink()<EOL>param._explored = False<EOL>full_name = param.v_full_name<EOL>del self._explored_parameters[full_name]<EOL><DEDENT>if len(self._explored_parameters) == <NUM_LIT:0>:<EOL><INDENT>self.f_shrink(force=True)<EOL><DEDENT>raise<EOL><DEDENT>
Prepares the trajectory to explore the parameter space.


        To explore the parameter space you need to provide a dictionary with the names of the
        parameters to explore as keys and iterables specifying the exploration ranges as values.

        All iterables need to have the same length otherwise a ValueError is raised.
        A ValueError is also raised if the names from the dictionary map to groups or results
        and not parameters.

        If your trajectory is already explored but not stored yet and your parameters are
        not locked you can add new explored parameters to the current ones if their
        iterables match the current length of the trajectory.

        Raises an AttributeError if the names from the dictionary are not found at all in
        the trajectory and NotUniqueNodeError if the keys not unambiguously map
        to single parameters.

        Raises a TypeError if the trajectory has been stored already, please use
        :func:`~pypet.trajectory.Trajectory.f_expand` then instead.

        Example usage:

        >>> traj.f_explore({'groupA.param1' : [1,2,3,4,5], 'groupA.param2':['a','b','c','d','e']})

        Could also be called consecutively:

        >>> traj.f_explore({'groupA.param1' : [1,2,3,4,5]})
        >>> traj.f_explore({'groupA.param2':['a','b','c','d','e']})

        NOTE:

        Since parameters are very conservative regarding the data they accept
        (see :ref:`type_conservation`), you sometimes won't be able to use Numpy arrays
        for exploration as iterables.

        For instance, the following code snippet won't work:

        ::

            import numpy a np
            from pypet.trajectory import Trajectory
            traj = Trajectory()
            traj.f_add_parameter('my_float_parameter', 42.4,
                                 comment='My value is a standard python float')

            traj.f_explore( { 'my_float_parameter': np.arange(42.0, 44.876, 0.23) } )


        This will result in a `TypeError` because your exploration iterable
        `np.arange(42.0, 44.876, 0.23)` contains `numpy.float64` values
        whereas you parameter is supposed to use standard python floats.

        Yet, you can use Numpys `tolist()` function to overcome this problem:

        ::

            traj.f_explore( { 'my_float_parameter': np.arange(42.0, 44.876, 0.23).tolist() } )


        Or you could specify your parameter directly as a numpy float:

        ::

            traj.f_add_parameter('my_float_parameter', np.float64(42.4),
                                   comment='My value is a numpy 64 bit float')