Skip to content

Tuning curves

pynapple.process.tuning_curves

compute_discrete_tuning_curves

compute_discrete_tuning_curves(group, dict_ep)

Compute discrete tuning curves of a TsGroup using a dictionary of epochs. The function returns a pandas DataFrame with each row being a key of the dictionary of epochs and each column being a neurons.

This function can typically being used for a set of stimulus being presented for multiple epochs. An example of the dictionary is :

>>> dict_ep =  {
        "stim0": nap.IntervalSet(start=0, end=1),
        "stim1":nap.IntervalSet(start=2, end=3)
    }

In this case, the function will return a pandas DataFrame :

>>> tc
           neuron0    neuron1    neuron2
stim0        0 Hz       1 Hz       2 Hz
stim1        3 Hz       4 Hz       5 Hz

Parameters:

Name Type Description Default
group TsGroup

The group of Ts/Tsd for which the tuning curves will be computed

required
dict_ep dict

Dictionary of IntervalSets

required

Returns:

Type Description
DataFrame

Table of firing rate for each neuron and each IntervalSet

Raises:

Type Description
RuntimeError

If group is not a TsGroup object.

Source code in pynapple/process/tuning_curves.py
def compute_discrete_tuning_curves(group, dict_ep):
    """
    Compute discrete tuning curves of a TsGroup using a dictionary of epochs.
    The function returns a pandas DataFrame with each row being a key of the dictionary of epochs
    and each column being a neurons.

       This function can typically being used for a set of stimulus being presented for multiple epochs.
    An example of the dictionary is :

        >>> dict_ep =  {
                "stim0": nap.IntervalSet(start=0, end=1),
                "stim1":nap.IntervalSet(start=2, end=3)
            }
    In this case, the function will return a pandas DataFrame :

        >>> tc
                   neuron0    neuron1    neuron2
        stim0        0 Hz       1 Hz       2 Hz
        stim1        3 Hz       4 Hz       5 Hz


    Parameters
    ----------
    group : nap.TsGroup
        The group of Ts/Tsd for which the tuning curves will be computed
    dict_ep : dict
        Dictionary of IntervalSets

    Returns
    -------
    pandas.DataFrame
        Table of firing rate for each neuron and each IntervalSet

    Raises
    ------
    RuntimeError
        If group is not a TsGroup object.
    """
    assert isinstance(group, nap.TsGroup), "group should be a TsGroup."
    assert isinstance(dict_ep, dict), "dict_ep should be a dictionary of IntervalSet"
    idx = np.sort(list(dict_ep.keys()))
    for k in idx:
        assert isinstance(
            dict_ep[k], nap.IntervalSet
        ), "dict_ep argument should contain only IntervalSet. Key {} in dict_ep is not an IntervalSet".format(
            k
        )

    tuning_curves = pd.DataFrame(index=idx, columns=list(group.keys()), data=0.0)

    for k in dict_ep.keys():
        for n in group.keys():
            tuning_curves.loc[k, n] = float(len(group[n].restrict(dict_ep[k])))

        tuning_curves.loc[k] = tuning_curves.loc[k] / dict_ep[k].tot_length("s")

    return tuning_curves

compute_1d_tuning_curves

compute_1d_tuning_curves(
    group, feature, nb_bins, ep=None, minmax=None
)

Computes 1-dimensional tuning curves relative to a 1d feature.

Parameters:

Name Type Description Default
group TsGroup

The group of Ts/Tsd for which the tuning curves will be computed

required
feature Tsd (or TsdFrame with 1 column only)

The 1-dimensional target feature (e.g. head-direction)

required
nb_bins int

Number of bins in the tuning curve

required
ep IntervalSet

The epoch on which tuning curves are computed. If None, the epoch is the time support of the feature.

None
minmax tuple or list

The min and max boundaries of the tuning curves. If None, the boundaries are inferred from the target feature

None

Returns:

Type Description
DataFrame

DataFrame to hold the tuning curves

Raises:

Type Description
RuntimeError

If group is not a TsGroup object.

Source code in pynapple/process/tuning_curves.py
def compute_1d_tuning_curves(group, feature, nb_bins, ep=None, minmax=None):
    """
    Computes 1-dimensional tuning curves relative to a 1d feature.

    Parameters
    ----------
    group : TsGroup
        The group of Ts/Tsd for which the tuning curves will be computed
    feature : Tsd (or TsdFrame with 1 column only)
        The 1-dimensional target feature (e.g. head-direction)
    nb_bins : int
        Number of bins in the tuning curve
    ep : IntervalSet, optional
        The epoch on which tuning curves are computed.
        If None, the epoch is the time support of the feature.
    minmax : tuple or list, optional
        The min and max boundaries of the tuning curves.
        If None, the boundaries are inferred from the target feature

    Returns
    -------
    pandas.DataFrame
        DataFrame to hold the tuning curves

    Raises
    ------
    RuntimeError
        If group is not a TsGroup object.

    """
    assert isinstance(group, nap.TsGroup), "group should be a TsGroup."
    assert isinstance(
        feature, (nap.Tsd, nap.TsdFrame)
    ), "feature should be a Tsd (or TsdFrame with 1 column only)"
    if isinstance(feature, nap.TsdFrame):
        assert (
            feature.shape[1] == 1
        ), "feature should be a Tsd (or TsdFrame with 1 column only)"
    assert isinstance(nb_bins, int)

    if ep is None:
        ep = feature.time_support
    else:
        assert isinstance(ep, nap.IntervalSet), "ep should be an IntervalSet"

    if minmax is None:
        bins = np.linspace(np.min(feature), np.max(feature), nb_bins + 1)
    else:
        assert isinstance(minmax, tuple), "minmax should be a tuple of boundaries"
        bins = np.linspace(minmax[0], minmax[1], nb_bins + 1)

    idx = bins[0:-1] + np.diff(bins) / 2

    tuning_curves = pd.DataFrame(index=idx, columns=list(group.keys()))

    if isinstance(ep, nap.IntervalSet):
        group_value = group.value_from(feature, ep)
        occupancy, _ = np.histogram(feature.restrict(ep).values, bins)
    else:
        group_value = group.value_from(feature)
        occupancy, _ = np.histogram(feature.values, bins)

    for k in group_value:
        count, _ = np.histogram(group_value[k].values, bins)
        count = count / occupancy
        count[np.isnan(count)] = 0.0
        tuning_curves[k] = count
        tuning_curves[k] = count * feature.rate

    return tuning_curves

compute_2d_tuning_curves

compute_2d_tuning_curves(
    group, features, nb_bins, ep=None, minmax=None
)

Computes 2-dimensional tuning curves relative to a 2d features

Parameters:

Name Type Description Default
group TsGroup

The group of Ts/Tsd for which the tuning curves will be computed

required
features TsdFrame

The 2d features (i.e. 2 columns features).

required
nb_bins int

Number of bins in the tuning curves

required
ep IntervalSet

The epoch on which tuning curves are computed. If None, the epoch is the time support of the feature.

None
minmax tuple or list

The min and max boundaries of the tuning curves given as: (minx, maxx, miny, maxy) If None, the boundaries are inferred from the target variable

None

Returns:

Type Description
tuple

A tuple containing:

tc (dict): Dictionary of the tuning curves with dimensions (nb_bins, nb_bins).

xy (list): List of bins center in the two dimensions

Raises:

Type Description
RuntimeError

If group is not a TsGroup object or if features is not 2 columns only.

Source code in pynapple/process/tuning_curves.py
def compute_2d_tuning_curves(group, features, nb_bins, ep=None, minmax=None):
    """
    Computes 2-dimensional tuning curves relative to a 2d features

    Parameters
    ----------
    group : TsGroup
        The group of Ts/Tsd for which the tuning curves will be computed
    features : TsdFrame
        The 2d features (i.e. 2 columns features).
    nb_bins : int
        Number of bins in the tuning curves
    ep : IntervalSet, optional
        The epoch on which tuning curves are computed.
        If None, the epoch is the time support of the feature.
    minmax : tuple or list, optional
        The min and max boundaries of the tuning curves given as:
        (minx, maxx, miny, maxy)
        If None, the boundaries are inferred from the target variable

    Returns
    -------
    tuple
        A tuple containing: \n
        tc (dict): Dictionary of the tuning curves with dimensions (nb_bins, nb_bins).\n
        xy (list): List of bins center in the two dimensions

    Raises
    ------
    RuntimeError
        If group is not a TsGroup object or if features is not 2 columns only.

    """
    assert isinstance(group, nap.TsGroup), "group should be a TsGroup."
    assert isinstance(
        features, nap.TsdFrame
    ), "features should be a TsdFrame with 2 columns"
    if isinstance(features, nap.TsdFrame):
        assert features.shape[1] == 2, "features should have 2 columns only."
    assert isinstance(nb_bins, int)

    if ep is None:
        ep = features.time_support
    else:
        assert isinstance(ep, nap.IntervalSet), "ep should be an IntervalSet"
        features = features.restrict(ep)

    cols = list(features.columns)
    groups_value = {}
    binsxy = {}

    for i, c in enumerate(cols):
        groups_value[c] = group.value_from(features.loc[c], ep)
        if minmax is None:
            bins = np.linspace(
                np.min(features.loc[c]), np.max(features.loc[c]), nb_bins + 1
            )
        else:
            assert isinstance(minmax, tuple), "minmax should be a tuple of 4 elements"
            bins = np.linspace(minmax[i + i % 2], minmax[i + 1 + i % 2], nb_bins + 1)
        binsxy[c] = bins

    occupancy, _, _ = np.histogram2d(
        features.loc[cols[0]].values.flatten(),
        features.loc[cols[1]].values.flatten(),
        [binsxy[cols[0]], binsxy[cols[1]]],
    )

    tc = {}
    for n in group.keys():
        count, _, _ = np.histogram2d(
            groups_value[cols[0]][n].values.flatten(),
            groups_value[cols[1]][n].values.flatten(),
            [binsxy[cols[0]], binsxy[cols[1]]],
        )
        count = count / occupancy
        # count[np.isnan(count)] = 0.0
        tc[n] = count * features.rate

    xy = [binsxy[c][0:-1] + np.diff(binsxy[c]) / 2 for c in binsxy.keys()]

    return tc, xy

compute_1d_mutual_info

compute_1d_mutual_info(
    tc, feature, ep=None, minmax=None, bitssec=False
)

Mutual information as defined in

Skaggs, W. E., McNaughton, B. L., & Gothard, K. M. (1993). An information-theoretic approach to deciphering the hippocampal code. In Advances in neural information processing systems (pp. 1030-1037).

Parameters:

Name Type Description Default
tc DataFrame or ndarray

Tuning curves in columns

required
feature Tsd (or TsdFrame with 1 column only)

The 1-dimensional target feature (e.g. head-direction)

required
ep IntervalSet

The epoch over which the tuning curves were computed If None, the epoch is the time support of the feature.

None
minmax tuple or list

The min and max boundaries of the tuning curves. If None, the boundaries are inferred from the target feature

None
bitssec bool

By default, the function return bits per spikes. Set to true for bits per seconds

False

Returns:

Type Description
DataFrame

Spatial Information (default is bits/spikes)

Source code in pynapple/process/tuning_curves.py
def compute_1d_mutual_info(tc, feature, ep=None, minmax=None, bitssec=False):
    """
    Mutual information as defined in

    Skaggs, W. E., McNaughton, B. L., & Gothard, K. M. (1993).
    An information-theoretic approach to deciphering the hippocampal code.
    In Advances in neural information processing systems (pp. 1030-1037).

    Parameters
    ----------
    tc : pandas.DataFrame or numpy.ndarray
        Tuning curves in columns
    feature : Tsd (or TsdFrame with 1 column only)
        The 1-dimensional target feature (e.g. head-direction)
    ep : IntervalSet, optional
        The epoch over which the tuning curves were computed
        If None, the epoch is the time support of the feature.
    minmax : tuple or list, optional
        The min and max boundaries of the tuning curves.
        If None, the boundaries are inferred from the target feature
    bitssec : bool, optional
        By default, the function return bits per spikes.
        Set to true for bits per seconds

    Returns
    -------
    pandas.DataFrame
        Spatial Information (default is bits/spikes)
    """
    if isinstance(tc, pd.DataFrame):
        columns = tc.columns.values
        fx = np.atleast_2d(tc.values)
    elif isinstance(tc, np.ndarray):
        fx = np.atleast_2d(tc)
        columns = np.arange(tc.shape[1])

    assert isinstance(
        feature, (nap.Tsd, nap.TsdFrame)
    ), "feature should be a Tsd (or TsdFrame with 1 column only)"
    if isinstance(feature, nap.TsdFrame):
        assert (
            feature.shape[1] == 1
        ), "feature should be a Tsd (or TsdFrame with 1 column only)"

    nb_bins = tc.shape[0] + 1
    if minmax is None:
        bins = np.linspace(np.min(feature), np.max(feature), nb_bins)
    else:
        bins = np.linspace(minmax[0], minmax[1], nb_bins)

    if isinstance(ep, nap.IntervalSet):
        occupancy, _ = np.histogram(feature.restrict(ep).values, bins)
    else:
        occupancy, _ = np.histogram(feature.values, bins)
    occupancy = occupancy / occupancy.sum()
    occupancy = occupancy[:, np.newaxis]

    fr = np.sum(fx * occupancy, 0)
    fxfr = fx / fr
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        logfx = np.log2(fxfr)
    logfx[np.isinf(logfx)] = 0.0
    SI = np.sum(occupancy * fx * logfx, 0)

    if bitssec:
        SI = pd.DataFrame(index=columns, columns=["SI"], data=SI)
        return SI
    else:
        SI = SI / fr
        SI = pd.DataFrame(index=columns, columns=["SI"], data=SI)
        return SI

compute_2d_mutual_info

compute_2d_mutual_info(
    tc, features, ep=None, minmax=None, bitssec=False
)

Mutual information as defined in

Skaggs, W. E., McNaughton, B. L., & Gothard, K. M. (1993). An information-theoretic approach to deciphering the hippocampal code. In Advances in neural information processing systems (pp. 1030-1037).

Parameters:

Name Type Description Default
tc dict or ndarray

If array, first dimension should be the neuron

required
features TsdFrame

The 2 columns features that were used to compute the tuning curves

required
ep IntervalSet

The epoch over which the tuning curves were computed If None, the epoch is the time support of the feature.

None
minmax tuple or list

The min and max boundaries of the tuning curves. If None, the boundaries are inferred from the target features

None
bitssec bool

By default, the function return bits per spikes. Set to true for bits per seconds

False

Returns:

Type Description
DataFrame

Spatial Information (default is bits/spikes)

Source code in pynapple/process/tuning_curves.py
def compute_2d_mutual_info(tc, features, ep=None, minmax=None, bitssec=False):
    """
    Mutual information as defined in

    Skaggs, W. E., McNaughton, B. L., & Gothard, K. M. (1993).
    An information-theoretic approach to deciphering the hippocampal code.
    In Advances in neural information processing systems (pp. 1030-1037).

    Parameters
    ----------
    tc : dict or numpy.ndarray
        If array, first dimension should be the neuron
    features : TsdFrame
        The 2 columns features that were used to compute the tuning curves
    ep : IntervalSet, optional
        The epoch over which the tuning curves were computed
        If None, the epoch is the time support of the feature.
    minmax : tuple or list, optional
        The min and max boundaries of the tuning curves.
        If None, the boundaries are inferred from the target features
    bitssec : bool, optional
        By default, the function return bits per spikes.
        Set to true for bits per seconds

    Returns
    -------
    pandas.DataFrame
        Spatial Information (default is bits/spikes)
    """
    # A bit tedious here
    if type(tc) is dict:
        fx = np.array([tc[i] for i in tc.keys()])
        idx = list(tc.keys())
    elif type(tc) is np.ndarray:
        fx = tc
        idx = np.arange(len(tc))

    assert isinstance(
        features, nap.TsdFrame
    ), "features should be a TsdFrame with 2 columns"
    if isinstance(features, nap.TsdFrame):
        assert features.shape[1] == 2, "features should have 2 columns only."

    nb_bins = (fx.shape[1] + 1, fx.shape[2] + 1)

    cols = features.columns

    bins = []
    for i, c in enumerate(cols):
        if minmax is None:
            bins.append(
                np.linspace(
                    np.min(features.loc[c]), np.max(features.loc[c]), nb_bins[i]
                )
            )
        else:
            bins.append(
                np.linspace(minmax[i + i % 2], minmax[i + 1 + i % 2], nb_bins[i])
            )

    if isinstance(ep, nap.IntervalSet):
        features = features.restrict(ep)

    occupancy, _, _ = np.histogram2d(
        features.loc[cols[0]].values.flatten(),
        features.loc[cols[1]].values.flatten(),
        [bins[0], bins[1]],
    )
    occupancy = occupancy / occupancy.sum()

    fr = np.nansum(fx * occupancy, (1, 2))
    fr = fr[:, np.newaxis, np.newaxis]
    fxfr = fx / fr
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        logfx = np.log2(fxfr)
    logfx[np.isinf(logfx)] = 0.0
    SI = np.nansum(occupancy * fx * logfx, (1, 2))

    if bitssec:
        SI = pd.DataFrame(index=idx, columns=["SI"], data=SI)
        return SI
    else:
        SI = SI / fr[:, 0, 0]
        SI = pd.DataFrame(index=idx, columns=["SI"], data=SI)
        return SI

compute_1d_tuning_curves_continuous

compute_1d_tuning_curves_continuous(
    tsdframe, feature, nb_bins, ep=None, minmax=None
)

Computes 1-dimensional tuning curves relative to a feature with continous data.

Parameters:

Name Type Description Default
tsdframe Tsd or TsdFrame

Input data (e.g. continus calcium data where each column is the calcium activity of one neuron)

required
feature Tsd (or TsdFrame with 1 column only)

The 1-dimensional target feature (e.g. head-direction)

required
nb_bins int

Number of bins in the tuning curves

required
ep IntervalSet

The epoch on which tuning curves are computed. If None, the epoch is the time support of the feature.

None
minmax tuple or list

The min and max boundaries of the tuning curves. If None, the boundaries are inferred from the target feature

None

Returns:

Type Description
DataFrame

DataFrame to hold the tuning curves

Raises:

Type Description
RuntimeError

If tsdframe is not a Tsd or a TsdFrame object.

Source code in pynapple/process/tuning_curves.py
def compute_1d_tuning_curves_continuous(
    tsdframe, feature, nb_bins, ep=None, minmax=None
):
    """
    Computes 1-dimensional tuning curves relative to a feature with continous data.

    Parameters
    ----------
    tsdframe : Tsd or TsdFrame
        Input data (e.g. continus calcium data
        where each column is the calcium activity of one neuron)
    feature : Tsd (or TsdFrame with 1 column only)
        The 1-dimensional target feature (e.g. head-direction)
    nb_bins : int
        Number of bins in the tuning curves
    ep : IntervalSet, optional
        The epoch on which tuning curves are computed.
        If None, the epoch is the time support of the feature.
    minmax : tuple or list, optional
        The min and max boundaries of the tuning curves.
        If None, the boundaries are inferred from the target feature

    Returns
    -------
    pandas.DataFrame
        DataFrame to hold the tuning curves

    Raises
    ------
    RuntimeError
        If tsdframe is not a Tsd or a TsdFrame object.

    """
    if not isinstance(tsdframe, (nap.Tsd, nap.TsdFrame)):
        raise RuntimeError("Unknown format for tsdframe.")
    elif isinstance(tsdframe, nap.Tsd):
        tsdframe = tsdframe[:, np.newaxis]

    assert isinstance(
        feature, (nap.Tsd, nap.TsdFrame)
    ), "feature should be a Tsd (or TsdFrame with 1 column only)"
    if isinstance(feature, nap.TsdFrame):
        assert (
            feature.shape[1] == 1
        ), "feature should be a Tsd (or TsdFrame with 1 column only)"
        feature = np.squeeze(feature)

    if isinstance(ep, nap.IntervalSet):
        feature = feature.restrict(ep)
        tsdframe = tsdframe.restrict(ep)
    else:
        tsdframe = tsdframe.restrict(feature.time_support)

    if minmax is None:
        bins = np.linspace(np.min(feature), np.max(feature), nb_bins + 1)
    else:
        bins = np.linspace(minmax[0], minmax[1], nb_bins + 1)

    align_times = tsdframe.value_from(feature)
    idx = np.digitize(align_times.values, bins) - 1
    tmp = tsdframe.as_dataframe().groupby(idx).mean()
    tmp = tmp.reindex(np.arange(0, len(bins) - 1))
    tmp.index = pd.Index(bins[0:-1] + np.diff(bins) / 2)

    tmp = tmp.fillna(0)

    return pd.DataFrame(tmp)

compute_2d_tuning_curves_continuous

compute_2d_tuning_curves_continuous(
    tsdframe, features, nb_bins, ep=None, minmax=None
)

Computes 2-dimensional tuning curves relative to a 2d feature with continous data.

Parameters:

Name Type Description Default
tsdframe Tsd or TsdFrame

Input data (e.g. continuous calcium data where each column is the calcium activity of one neuron)

required
features TsdFrame

The 2d feature (two columns)

required
nb_bins int or tuple

Number of bins in the tuning curves (separate for 2 feature dimensions if tuple provided)

required
ep IntervalSet

The epoch on which tuning curves are computed. If None, the epoch is the time support of the feature.

None
minmax tuple or list

The min and max boundaries of the tuning curves. Should be a tuple of minx, maxx, miny, maxy If None, the boundaries are inferred from the target feature

None

Returns:

Type Description
tuple

A tuple containing:

tc (dict): Dictionary of the tuning curves with dimensions (nb_bins, nb_bins).

xy (list): List of bins center in the two dimensions

Raises:

Type Description
RuntimeError

If tsdframe is not a Tsd/TsdFrame or if features is not 2 columns

Source code in pynapple/process/tuning_curves.py
def compute_2d_tuning_curves_continuous(
    tsdframe, features, nb_bins, ep=None, minmax=None
):
    """
    Computes 2-dimensional tuning curves relative to a 2d feature with continous data.

    Parameters
    ----------
    tsdframe : Tsd or TsdFrame
        Input data (e.g. continuous calcium data
        where each column is the calcium activity of one neuron)
    features : TsdFrame
        The 2d feature (two columns)
    nb_bins : int or tuple
        Number of bins in the tuning curves (separate for 2 feature dimensions if tuple provided)
    ep : IntervalSet, optional
        The epoch on which tuning curves are computed.
        If None, the epoch is the time support of the feature.
    minmax : tuple or list, optional
        The min and max boundaries of the tuning curves.
        Should be a tuple of minx, maxx, miny, maxy
        If None, the boundaries are inferred from the target feature

    Returns
    -------
    tuple
        A tuple containing: \n
        tc (dict): Dictionary of the tuning curves with dimensions (nb_bins, nb_bins).\n
        xy (list): List of bins center in the two dimensions

    Raises
    ------
    RuntimeError
        If tsdframe is not a Tsd/TsdFrame or if features is not 2 columns

    """
    if not isinstance(tsdframe, (nap.Tsd, nap.TsdFrame)):
        raise RuntimeError("Unknown format for tsdframe.")
    elif isinstance(tsdframe, nap.Tsd):
        tsdframe = tsdframe[:, np.newaxis]

    assert isinstance(
        features, nap.TsdFrame
    ), "features should be a TsdFrame with 2 columns"
    if isinstance(features, nap.TsdFrame):
        assert features.shape[1] == 2, "features should have 2 columns only."

    if isinstance(ep, nap.IntervalSet):
        features = features.restrict(ep)
        tsdframe = tsdframe.restrict(ep)
    else:
        tsdframe = tsdframe.restrict(features.time_support)

    if isinstance(nb_bins, int):
        nb_bins = (nb_bins, nb_bins)
    elif len(nb_bins) != 2:
        raise RuntimeError("nb_bins should be int or tuple of 2 ints")

    cols = list(features.columns)

    binsxy = {}
    idxs = {}

    for i, c in enumerate(cols):
        if minmax is None:
            bins = np.linspace(
                np.min(features.loc[c]), np.max(features.loc[c]), nb_bins[i] + 1
            )
        else:
            bins = np.linspace(minmax[i + i % 2], minmax[i + 1 + i % 2], nb_bins[i] + 1)

        align_times = tsdframe.value_from(features.loc[c], ep)
        idxs[c] = np.digitize(align_times.values.flatten(), bins) - 1
        binsxy[c] = bins

    idxs = pd.DataFrame(idxs)

    tc_np = np.zeros((tsdframe.shape[1], nb_bins[0], nb_bins[1])) * np.nan

    for k, tmp in idxs.groupby(cols):
        if (0 <= k[0] < nb_bins[0]) and (0 <= k[1] < nb_bins[1]):
            tc_np[:, k[0], k[1]] = np.mean(tsdframe[tmp.index.values].values, 0)

    tc_np[np.isnan(tc_np)] = 0.0

    xy = [binsxy[c][0:-1] + np.diff(binsxy[c]) / 2 for c in binsxy.keys()]

    tc = {c: tc_np[i] for i, c in enumerate(tsdframe.columns)}

    return tc, xy