def METHOD_NAME(data):
    # This function imitates the calculation flow of a single pixel for a very big dataset.
    # The partition and tile structure is given by the shape of data
    # data.shape[0]: partitions
    # data.shape[1]: tiles per partition
    # data.shape[2]: frames per tile
    # data.shape[3]: mock signal shape, can be 1
    # The test uses numba since this allows efficient calculations for small units
    # of data. Running it with JIT disabled is very, very slow!
    s = np.zeros(1, dtype=np.float32)
    varsum = np.zeros(1, dtype=np.float32)
    N = 0
    partitions = data.shape[0]
    tiles = data.shape[1]
    frames = data.shape[2]
    for partition in range(partitions):
        partition_sum = np.zeros(1, dtype=np.float32)
        partition_varsum = np.zeros(1, dtype=np.float32)
        partition_N = 0
        for tile in range(tiles):
            if partition_N == 0:
                partition_sum[:] = np.sum(data[partition, tile])
                partition_varsum[:] = np.var(data[partition, tile]) * frames
                partition_N = frames
            else:
                partition_N = process_tile(
                    tile=data[partition, tile],
                    n_0=partition_N,
                    sum_inout=partition_sum,
                    varsum_inout=partition_varsum
                )
        N = merge(
            dest_n=N,
            dest_sum=s,
            dest_varsum=varsum,
            src_n=partition_N,
            src_sum=partition_sum,
            src_varsum=partition_varsum,
            src_mean=partition_sum / partition_N,
        )
    return N, s, varsum