def METHOD_NAME(
    self, callable: Callable, total_size: int, natoms: int, *args, **kwargs
) -> Tuple[np.ndarray]:
    """Excuate a method with all given data.
    Parameters
    ----------
    callable : Callable
        The method should accept *args and **kwargs as input and return the similiar array.
    total_size : int
        Total size
    natoms : int
        The number of atoms
    *args
        Variable length argument list.
    **kwargs
        If 2D np.ndarray, assume the first axis is batch; otherwise do nothing.
    """
    def execute_with_batch_size(
        batch_size: int, start_index: int
    ) -> Tuple[int, Tuple[np.ndarray]]:
        end_index = start_index + batch_size
        end_index = min(end_index, total_size)
        return (end_index - start_index), callable(
            *[
                (
                    vv[start_index:end_index]
                    if isinstance(vv, np.ndarray) and vv.ndim > 1
                    else vv
                )
                for vv in args
            ],
            **{
                kk: (
                    vv[start_index:end_index]
                    if isinstance(vv, np.ndarray) and vv.ndim > 1
                    else vv
                )
                for kk, vv in kwargs.items()
            },
        )
    index = 0
    results = []
    while index < total_size:
        n_batch, result = self.execute(execute_with_batch_size, index, natoms)
        if not isinstance(result, tuple):
            result = (result,)
        index += n_batch
        if n_batch:
            for rr in result:
                rr.reshape((n_batch, -1))
            results.append(result)
    r = tuple([np.concatenate(r, axis=0) for r in zip(*results)])
    if len(r) == 1:
        # avoid returning tuple if callable doesn't return tuple
        r = r[0]
    return r