def load_driftbif(n, l, m=2, classification=True, kappa_3=0.3, seed=False):
    """
    Simulates n time-series with l time steps each for the m-dimensional velocity of a dissipative soliton

    classification=True:
    target 0 means tau<=1/0.3, Dissipative Soliton with Brownian motion (purely noise driven)
    target 1 means tau> 1/0.3, Dissipative Soliton with Active Brownian motion (intrinsiv velocity with overlaid noise)

    classification=False:
    target is bifurcation parameter tau

    :param n: number of samples 
    :type n: int
    :param l: length of the time series
    :type l: int
    :param m: number of spatial dimensions (default m=2) the dissipative soliton is propagating in
    :type m: int
    :param classification: distinguish between classification (default True) and regression target
    :type classification: bool
    :param kappa_3: inverse bifurcation parameter (default 0.3)
    :type kappa_3: float
    :param seed: random seed (default False)
    :type seed: float
    :return: X, y. Time series container and target vector
    :rtype X: pandas.DataFrame
    :rtype y: pandas.DataFrame
    """

    # todo: add ratio of classes

    if m > 2:
        logging.warning("You set the dimension parameter for the dissipative soliton to m={}, however it is only"
                        "properly defined for m=1 or m=2.".format(m))

    id = np.repeat(range(n), l * m)
    dimensions = list(np.repeat(range(m), l)) * n

    labels = list()
    values = list()

    ls_tau = sample_tau(n, kappa_3=kappa_3)

    for i, tau in enumerate(ls_tau):
        ds = velocity(tau=tau, kappa_3=kappa_3, seed=seed)
        if classification:
            labels.append(ds.label)
        else:
            labels.append(ds.tau)
        values.append(ds.simulate(l, v0=np.zeros(m)).transpose().flatten())
    time = np.stack([ds.delta_t * np.arange(l)] * n * m).flatten()

    df = pd.DataFrame({'id': id, "time": time, "value": np.stack(values).flatten(), "dimension": dimensions})
    y = pd.Series(labels)
    y.index = range(n)

    return df, y