sample

class zfit.core.sample.EventSpace(obs: Union[str, Iterable[str], zfit.Space], limits: Union[Tuple[Tuple[Tuple[float, ...]]], Tuple[float, float], bool], factory=None, name: Optional[str] = 'Space')[source]

Bases: zfit.core.limits.Space

EXPERIMENTAL SPACE CLASS!

ANY = <Any>
ANY_LOWER = <Any Lower Limit>
ANY_UPPER = <Any Upper Limit>
AUTO_FILL = <object object>
add(other: Union[zfit.Space, Iterable[zfit.Space]])[source]

Add the limits of the spaces. Only works for the same obs.

In case the observables are different, the order of the first space is taken.

Parameters:other (Space) –
Returns:
Return type:Space
area() → float

Return the total area of all the limits and axes. Useful, for example, for MC integration.

axes

The axes (“obs with int”) the space is defined in.

Returns:

combine(other: Union[zfit.Space, Iterable[zfit.Space]])[source]

Combine spaces with different obs (but consistent limits).

Parameters:other (Space) –
Returns:
Return type:Space
copy(name: Optional[str] = None, **overwrite_kwargs) → zfit.Space

Create a new Space using the current attributes and overwriting with overwrite_overwrite_kwargs.

Parameters:
  • name (str) – The new name. If not given, the new instance will be named the same as the current one.
  • () (**overwrite_kwargs) –
Returns:

Space
create_limits(n)[source]
factory
classmethod from_axes(axes: Union[int, Iterable[int]], limits: Union[Tuple[Tuple[Tuple[float, ...]]], Tuple[float, float], bool, None] = None, name: str = None) → zfit.Space

Create a space from axes instead of from obs.

Parameters:
  • () (limits) –
  • () –
  • name (str) –
Returns:

Space
get_axes(obs: Union[str, Iterable[str], zfit.Space] = None, as_dict: bool = False, autofill: bool = False) → Union[Tuple[int], None, Dict[str, int]]

Return the axes corresponding to the obs (or all if None).

Parameters:
  • () (obs) –
  • as_dict (bool) – If True, returns a ordered dictionary with {obs: axis}
  • autofill (bool) – If True and the axes are not specified, automatically fill them with the default numbering and return (not setting them).
Returns:

Tuple, OrderedDict
Raises:
  • ValueError – if the requested obs do not match with the one defined in the range
  • AxesNotSpecifiedError – If the axes in this Space have not been specified.
get_obs_axes(obs: Union[str, Iterable[str], zfit.Space] = None, axes: Union[int, Iterable[int]] = None)
get_reorder_indices(obs: Union[str, Iterable[str], zfit.Space] = None, axes: Union[int, Iterable[int]] = None) → Tuple[int]

Indices that would order self.obs as obs respectively self.axes as axes.

Parameters:
  • () (axes) –
  • () –

Returns:

get_subspace(obs: Union[str, Iterable[str], zfit.Space] = None, axes: Union[int, Iterable[int]] = None, name: Optional[str] = None) → zfit.Space

Create a Space consisting of only a subset of the obs/axes (only one allowed).

Parameters:
  • obs (str, Tuple[str]) –
  • axes (int, Tuple[int]) –
  • () (name) –

Returns:

is_generator
iter_areas(rel: bool = False) → Tuple[float, ...][source]

Return the areas of each interval

Parameters:rel (bool) – If True, return the relative fraction of each interval
Returns:
Return type:Tuple[float]
iter_limits(as_tuple: bool = True) → Union[Tuple[zfit.Space], Tuple[Tuple[Tuple[float]]], Tuple[Tuple[float]]]

Return the limits, either as Space objects or as pure limits-tuple.

This makes iterating over limits easier: for limit in space.iter_limits() allows to, for example, pass limit to a function that can deal with simple limits only or if as_tuple is True the limit can be directly used to calculate something.

Example

for lower, upper in space.iter_limits(as_tuple=True):
    integrals = integrate(lower, upper)  # calculate integral
integral = sum(integrals)
Returns:
Return type:List[Space] or List[limit,…]
limit1d

return the tuple(lower, upper).

Returns:so lower, upper = space.limit1d for a simple, 1 obs limit.
Return type:tuple(float, float)
Raises:RuntimeError – if the conditions (n_obs or n_limits) are not satisfied.
Type:Simplified limits getter for 1 obs, 1 limit only
limit2d

return the tuple(low_obs1, low_obs2, up_obs1, up_obs2).

Returns:
so low_x, low_y, up_x, up_y = space.limit2d for a single, 2 obs limit.
low_x is the lower limit in x, up_x is the upper limit in x etc.
Return type:tuple(float, float, float, float)
Raises:RuntimeError – if the conditions (n_obs or n_limits) are not satisfied.
Type:Simplified limits for exactly 2 obs, 1 limit
limits

Return the limits.

Returns:

limits1d

return the tuple(low_1, …, low_n, up_1, …, up_n).

Returns:
so low_1, low_2, up_1, up_2 = space.limits1d for several, 1 obs limits.
low_1 to up_1 is the first interval, low_2 to up_2 is the second interval etc.
Return type:tuple(float, float, ..)
Raises:RuntimeError – if the conditions (n_obs or n_limits) are not satisfied.
Type:Simplified .limits for exactly 1 obs, n limits
lower

Return the lower limits.

Returns:

n_limits

The number of different limits.

Returns:int >= 1
n_obs

Return the number of observables/axes.

Returns:int >= 1
name

The name of the object.

obs

The observables (“axes with str”)the space is defined in.

Returns:

obs_axes
reorder_by_indices(indices: Tuple[int])

Return a Space reordered by the indices.

Parameters:() (indices) –
upper

Return the upper limits.

Returns:

with_autofill_axes(overwrite: bool = False) → zfit.Space

Return a Space with filled axes corresponding to range(len(n_obs)).

Parameters:overwrite (bool) – If self.axes is not None, replace the axes with the autofilled ones. If axes is already set, don’t do anything if overwrite is False.
Returns:Space
with_axes(axes: Union[int, Iterable[int]]) → zfit.Space

Sort by obs and return the new instance.

Parameters:() (axes) –
Returns:Space
with_limits(limits: Union[Tuple[Tuple[Tuple[float, ...]]], Tuple[float, float], bool], name: Optional[str] = None) → zfit.Space

Return a copy of the space with the new limits (and the new name).

Parameters:
  • () (limits) –
  • name (str) –
Returns:

Space
with_obs(obs: Union[str, Iterable[str], zfit.Space]) → zfit.Space

Sort by obs and return the new instance.

Parameters:() (obs) –
Returns:Space
with_obs_axes(obs_axes: Union[OrderedDict[str, int], Dict[str, int]], ordered: bool = False, allow_subset=False) → zfit.Space

Return a new Space with reordered observables and set the axes.

Parameters:
  • obs_axes (OrderedDict[str, int]) – An ordered dict with {obs: axes}.
  • ordered (bool) – If True (and the obs_axes is an OrderedDict), the
  • () (allow_subset) –
Returns:
Return type:

Space
class zfit.core.sample.UniformSampleAndWeights[source]

Bases: object

zfit.core.sample.accept_reject_sample(prob: Callable, n: int, limits: zfit.core.limits.Space, sample_and_weights_factory: Callable = <class 'zfit.core.sample.UniformSampleAndWeights'>, dtype=tf.float64, prob_max: Union[None, int] = None, efficiency_estimation: float = 1.0) → tensorflow.python.framework.ops.Tensor[source]

Accept reject sample from a probability distribution.

Parameters:
  • prob (function) – A function taking x a Tensor as an argument and returning the probability (or anything that is proportional to the probability).
  • n (int) – Number of samples to produce
  • limits (Space) – The limits to sample from
  • sample_and_weights_factory (Callable) –

    A factory function that returns the following function: A function that returns the sample to insert into prob and the weights (probability density) of each sample together with the random thresholds. The API looks as follows:

    • Parameters:
      • n_to_produce (int, tf.Tensor): The number of events to produce (not exactly).
      • limits (Space): the limits in which the samples will be.
      • dtype (dtype): DType of the output.
    • Return:
      A tuple of length 5: - proposed sample (tf.Tensor with shape=(n_to_produce, n_obs)): The new (proposed) sample
      whose values are inside limits.
      • thresholds_unscaled (tf.Tensor with shape=(n_to_produce,): Uniformly distributed
        random values between 0 and 1.
      • weights (tf.Tensor with shape=(n_to_produce)): (Proportional to the) probability
        for each sample of the distribution it was drawn from.
      • weights_max (int, tf.Tensor, None): The maximum of the weights (if known). This is
        what the probability maximum will be scaled with, so it should be rather lower than the maximum if the peaks do not exactly coincide. Otherwise return None (which will assume that the peaks coincide).
      • n_produced: the number of events produced. Can deviate from the requested number.
  • () (dtype) –
  • prob_max (Union[None, int]) – The maximum of the model function for the given limits. If None is given, it will be automatically, safely estimated (by a 10% increase in computation time (constant weak scaling)).
  • efficiency_estimation (float) – estimation of the initial sampling efficiency.
Returns:
Return type:

tf.Tensor
zfit.core.sample.extended_sampling(pdfs: Union[Iterable[zfit.core.interfaces.ZfitPDF], zfit.core.interfaces.ZfitPDF], limits: zfit.core.limits.Space) → tensorflow.python.framework.ops.Tensor[source]

Create a sample from extended pdfs by sampling poissonian using the yield.

Parameters:
Returns:
Return type:

Union[tf.Tensor]
zfit.core.sample.extract_extended_pdfs(pdfs: Union[Iterable[zfit.core.interfaces.ZfitPDF], zfit.core.interfaces.ZfitPDF]) → List[zfit.core.interfaces.ZfitPDF][source]

Return all extended pdfs that are daughters.

Parameters:pdfs (Iterable[pdfs]) –
Returns:
Return type:List[pdfs]