BUCToolkit 1.0b0__py3-none-any.whl

BUCToolkit/utils/index_ops.py

@@ -0,0 +1,432 @@
+""" Indexed operations with given batch_indices """
+#  Copyright (c) 2026.1.22, BUCToolkit.
+#  Authors: Pu Pengxin, Song Xin
+#  Version: 0.9a
+#  File: index_ops.py
+#  Environment: Python 3.12
+
+import warnings
+
+import numpy as np
+import torch as th
+from typing import Optional, Literal, Callable, Tuple, Dict
+
+
+def scatter_reduce(
+        src: th.Tensor,
+        batch_indices: th.Tensor,
+        dim: int = -1,
+        ops: Literal['sum', 'prod', 'mean', 'amin', 'amax'] = 'sum',
+        init_value: float|int|bool = 0.
+) -> th.Tensor:
+    """
+    scatter_reduce method that reduces element in `src` with the same indices in `batch_indices` by `ops`.
+    Args:
+        src: source tensor
+        batch_indices: indices tensor
+        dim: reduce dimension
+        ops: reduce operation
+        init_value: default value of the output tensor that reduced values filled in.
+
+    Returns:
+
+    """
+    # manage batch_indices
+    _batch_indices = batch_indices.clone().to(th.int64)
+    if dim < 0:
+        dim = src.dim() + dim
+    if _batch_indices.dim() == 1:
+        for _ in range(0, dim): _batch_indices.unsqueeze_(0)
+    for _ in range(_batch_indices.dim(), src.dim()): _batch_indices.unsqueeze_(-1)
+    _batch_indices = _batch_indices.expand(src.shape)
+    # main
+    src_shape = list(src.shape)
+    src_shape[dim] = th.max(_batch_indices).item() + 1
+    out = th.full(src_shape, init_value, device=src.device)
+    out.scatter_reduce_(
+        dim,
+        _batch_indices,
+        src,
+        ops
+    )
+
+    return out
+
+def index_reduce(
+        src: th.Tensor,
+        batch_indices: th.Tensor,
+        dim: int = 0,
+        ops: Literal['prod', 'mean', 'amin', 'amax', 'sum'] = 'sum',
+        init_value: float = 0.,
+        out_size: int|None = None,
+        include_self: bool = True,
+        out: th.Tensor|None = None
+):
+    """
+    scatter_reduce method that reduces element in `src` with the same indices in `batch_indices` by `ops`.
+    Args:
+        src: source tensor
+        batch_indices: indices tensor of 1D
+        dim: reduce dimension
+        ops: reduce operation
+        init_value: default value of the output tensor that reduced values filled in.
+        out_size: size of the output tensor at the given dim. if None, it is equal to `batch_indices.max().item() + 1`
+        include_self: whether to let `init_value` really participate in the reduction.
+        out: the output tensor. If None, a new one will be returned.
+
+    Returns:
+
+    """
+    assert batch_indices.dim() == 1, f'Invalid dimension of batch indices: {batch_indices.shape}. It must be 1D.'
+    dim = dim if dim >= 0 else src.dim() + dim
+    output_size = list(src.shape)
+    output_size[dim] = (batch_indices.max().item() + 1) if out_size is None else out_size
+
+    out = th.full(output_size, init_value, device=src.device, dtype=src.dtype) if out is None else out.fill_(init_value)
+    if ops == 'sum' and include_self:
+        out.index_add_(dim, batch_indices, src)
+    else:
+        out.index_reduce_(dim, batch_indices, src, ops, include_self=include_self)
+    return out
+
+def index_inner_product(
+        u: th.Tensor,
+        v: th.Tensor,
+        dim: int,
+        batch_indices: th.Tensor,
+        out_size = None,
+):
+    """
+    Calculate the inner product of two tensors with given batch_indices .
+    Args:
+        u: tensor 1, in the dual space.
+        v: tensor 2, in the linear space.
+        dim: reduce dimension
+        batch_indices: indices tensor of 1D
+        out_size: size of the output tensor. If None, it is equal to `batch_indices.max().item() + 1`
+
+    Returns: u @ v with shape (u.shape[: `dim`], batch_number, u.shape[`dim` + 1: ])
+
+    """
+    w = u * v
+    w = index_reduce(w, batch_indices, dim, ops='sum', init_value=0., out_size=out_size)
+    return w
+
+def indices_pairwise_dist(
+        X: th.Tensor,            # [N, M]
+        Y: th.Tensor,
+        Qx: th.Tensor,            # [N]，continuous sample indices in the batch X, 0,0,...,1,1,...,B-1
+        Qy: th.Tensor | None = None,
+        thres: float | None = None,
+        metric: Literal['euclidean', 'dot', 'cosine']|Callable[[th.Tensor, th.Tensor, ...], th.Tensor] = "euclidean",  # 'euclidean' | 'dot' | 'cosine'
+        metric_kwargs: Dict|None = None,
+        relation: Literal['lt', 'gt'] = "gt",
+        exclude_diag: bool = True,
+        is_symmetric: bool = False,
+        return_values: bool = True,
+        is_coalesce: bool = True,
+        eps: float = 1e-12,
+):
+    """
+    Compute pairwise distance between two tensors on only the same indices in Qx and Qy.
+    Args:
+        X: input tensor 1.
+        Y: input tensor 2.
+        Qx: Tensor[int64], indices tensor of X.
+        Qy: Tensor[int64], indices tensor of Y.
+        thres: if not None, only distance greater/less (depends on `relation`) than `thres` will be output. Otherwise, all dist will be output.
+        metric: distance calculation method.
+        metric_kwargs: the keyword arguments passed to `metric` if `metric` is Callable.
+        relation: check `thres` greater (gt) or less (lt) than `thres`.
+        exclude_diag: whether to exclude diagonals.
+        is_symmetric: whether the distance between `X` and `Y` is symmetric. If True, only lower triangular of dist. mat. will be computed.
+        return_values: whether to return both indices and distance or only indices of distance < `thres`.
+        is_coalesce: whether to coalesce/resort indices and distance before output.
+        eps: epsilon for numerical stability.
+
+    Returns:
+        Tuple[indices: Tensor[int64], batch_tensor of dist: Tensor[int64]] |
+        Tuple[indices: Tensor[int64], distance: Tensor, batch_tensor of dist: Tensor[int64]]
+
+    """
+    # check
+    assert relation in ("lt", "gt")
+    assert X.device == Y.device, f'X and Y must be on the same device, but got {X.device} and {Y.device}.'
+    assert X.dtype == Y.dtype, f'X and Y must be on the same dtype, but got {X.dtype} and {Y.dtype}.'
+    # initialize
+    if metric_kwargs is None:
+        metric_kwargs = dict()
+    if is_symmetric:
+        assert X.shape == Y.shape, f'For symmetric metric, X and Y must have the same shape.'
+    if Qy is None:
+        Qy = Qx.clone()
+    device = X.device
+    if thres is None:
+        thres = th.inf if relation == "lt" else -th.inf
+    # sort & rearrange X, Y, Qx, Qy
+    Qx_sorted, Qx_sort_indx = th.sort(Qx)
+    Qy_sorted, Qy_sort_indx = th.sort(Qy)
+    Xs, Ys = X[Qx_sort_indx], Y[Qy_sort_indx]
+
+    # calc. indices
+    def _starts_sizes(Qs):
+        N = Qs.numel()
+        ch = th.ones(N, dtype=th.bool, device=Qs.device)
+        ch[1:] = (Qs[1:] != Qs[:-1])
+        st = th.nonzero(ch, as_tuple=True)[0]
+        en = th.cat([st[1:], th.tensor([N], device=Qs.device)])
+        sz = (en - st).to(th.long)
+        labs = Qs[st]
+        return st, sz, labs
+
+    ptr_x, nx, labs_x = _starts_sizes(Qx_sorted)
+    ptr_y, ny, labs_y = _starts_sizes(Qy_sorted)
+
+    # align two indices
+    ix = th.searchsorted(labs_x, labs_y)
+    # screen into the intersection (labs_y[pos] == labs_x)
+    valid = (ix < labs_x.numel()) & (labs_x[ix] == labs_y)
+    labs_y = labs_y[valid]
+    ptr_y, ny = ptr_y[valid], ny[valid]
+    ix = ix[valid]
+    ptr_x, nx = ptr_x[ix], nx[ix]  # ptr_x that aligned with y
+    if labs_y.numel() == 0:
+        empty = th.empty(2, 0, dtype=th.long, device=device)
+        Qe = th.empty(0, dtype=Qx.dtype, device=device)
+        return (empty, th.empty(0, device=device), Qe) if return_values else (empty, Qe)
+
+    # vectorized enumerate pairwise nx_i * ny_i, and mapping to Xs and Ys
+    pairs_per_img = nx * ny  # [B]
+    total_pairs = int(pairs_per_img.sum().item())
+
+    pair_ptr = th.cumsum(pairs_per_img, 0) - pairs_per_img  # [B]
+    pair_off_ex = th.repeat_interleave(pair_ptr, pairs_per_img)  # [∑ nx_i*ny_i]
+    ny_ex = th.repeat_interleave(ny, pairs_per_img)  # [∑ nx_i*ny_i]
+    k = th.arange(total_pairs, device=device) - pair_off_ex
+
+    i_loc = th.div(k, ny_ex, rounding_mode="floor")  # [∑ nx_i*ny_i]
+    j_loc = (k % ny_ex)
+
+    xs_ex = th.repeat_interleave(ptr_x, pairs_per_img)  # [∑ nx_i*ny_i]
+    ys_ex = th.repeat_interleave(ptr_y, pairs_per_img)
+
+    row_s = xs_ex + i_loc  # indices of Xs
+    col_s = ys_ex + j_loc  # indices of Ys
+    Qe_s = th.repeat_interleave(labs_y, pairs_per_img)  # indices of pairwise-dist, i.e., the edge.
+
+    # Symmetric reduce
+    if is_symmetric:
+        if not th.all(nx == ny):
+            raise ValueError(f"Symmetric requires Qx, Qy have the same shape in each sample, but got {nx} and {ny}")
+        mask = th.ones(total_pairs, dtype=th.bool, device=device)
+        mask &= (i_loc <= j_loc)  # select only lower triangular parts.
+        if exclude_diag:
+            mask &= (i_loc != j_loc)  # remove diag.
+        row_s = row_s[mask]
+        col_s = col_s[mask]
+        Qe_s = Qe_s[mask]
+
+    if row_s.numel() == 0:
+        empty = th.empty(2, 0, dtype=th.long, device=device)
+        Qe = th.empty(0, dtype=Qx.dtype, device=device)
+        return (empty, th.empty(0, device=device), Qe) if return_values else (empty, Qe)
+
+    # Main Calc. Dist.
+    xr, yc = Xs[row_s], Ys[col_s]  # [E, M], x_row, y_column
+
+    if isinstance(metric, Callable):
+        val = metric(xr, yc, **metric_kwargs)
+    elif metric == "euclidean":
+        n2x = th.linalg.vecdot(Xs, Xs)
+        n2y = th.linalg.vecdot(Ys, Ys)
+        dot = th.linalg.vecdot(xr, yc)
+        val = n2x[row_s] + n2y[col_s] - 2.0 * dot  # [E]
+        thres **= 2 if th.isfinite(th.tensor(thres)) else 1
+    elif metric == "dot":
+        val = th.linalg.vecdot(xr, yc)
+    elif metric == "cosine":
+        val = th.linalg.vecdot(xr, yc) / (th.linalg.vector_norm(xr, dim=-1) * th.linalg.vector_norm(yc, dim=-1) + eps)
+    else:
+        raise ValueError(f"Unknown metric {metric}.")
+
+    is_selected = (th.abs(val) < thres) if relation == "lt" else (th.abs(val) > thres)
+    row_s, col_s, Qe = row_s[is_selected], col_s[is_selected], Qe_s[is_selected]
+
+    # remapping to unsorted original X, Y
+    row = Qx_sort_indx[row_s]
+    col = Qy_sort_indx[col_s]
+    indices = th.stack([row, col], dim=0)
+    if return_values:
+        out_vals: th.Tensor = val[is_selected].clone()
+        if metric == "euclidean": out_vals.add_(eps**2).sqrt_()
+    else:
+        out_vals = val  # only a placeholder
+    if is_symmetric:  # appending upper diagonal part
+        nd_mask = (row != col)  # non-diagonal
+        if th.any(nd_mask):
+            upper_diag = th.stack([col[nd_mask], row[nd_mask]], dim=0)
+            indices = th.cat([indices, upper_diag], dim=1)
+            if return_values:
+                out_vals = th.cat([out_vals, out_vals[nd_mask]], dim=0)
+            Qe = th.cat([Qe, Qe[nd_mask]], dim=0)
+
+    # coalesce & rearrange indices
+    if is_coalesce:
+        coalesce_indx = th.argsort(indices[0], dim=0)
+        indices = indices[:, coalesce_indx]
+        Qe = Qe[coalesce_indx]
+        out_vals = out_vals[coalesce_indx] if return_values else out_vals
+
+    if return_values:
+        return indices, out_vals, Qe
+    return indices, Qe
+
+
+def inner_product_for_halfspace(u: th.Tensor, v: th.Tensor, volumes: th.Tensor|float = 1.) -> th.Tensor:
+    """
+
+    Args:
+        u:
+        v:
+        volumes:
+
+    Returns:
+
+    """
+    u0 = u[:, 0]  # (B,)
+    v0 = v[:, 0]
+    u_tail = u[:, 1:]  # (B, nG-1)
+    v_tail = v[:, 1:]  # (B, nG-1)
+
+    p = th.baddbmm(
+        th.empty_like(u[:,0]).unsqueeze(-1).unsqueeze(-1),
+        u_tail.conj().unsqueeze(1).contiguous(),  # (B, 1, n)
+        v_tail.unsqueeze(-1).contiguous(),  # (B, n, 1)
+        beta=0.0,
+        alpha=2.0,
+    ).squeeze(-2, -1)  # (B,)
+
+    # adding gamma point
+    p.add_(u0.conj() * v0)  # (B,)
+    p = p.real
+    if isinstance(volumes, th.Tensor) or volumes != 1.0:
+        p.mul_(volumes)
+
+    return p
+
+
+def standardize_cell(cell: th.Tensor) -> Tuple[th.Tensor, th.Tensor]:
+    """
+    Rotation a cell vector matrix into a standardized form where ay = az = 0, bz = 0, cz > 0.
+    Args:
+        cell: Tensor[B, 3, 3], batch of cell vectors.
+
+    Returns:
+        L: Tensor[B, 3, 3], standardized cell vector matrix with lower triangular forms.
+        Q: Tensor[B, 3, 3], the corresponding rotation transform
+
+    """
+    # determined the cell is a right-hand system
+    _cell_std = cell.clone()
+    vol = th.linalg.det(_cell_std).unsqueeze(-1)  # (B, 1)
+    _cell_std[:, 2, :] = th.where(vol < 0., - cell[:, 2, :], cell[:, 2, :])
+    ill_mask = th.abs(vol) < 1e-5
+    if ill_mask.any():
+        warnings.warn(f'A cell very close to low-dimensional system was detected in [{th.argwhere(ill_mask)}]-th samples.')
+    # QR factorization
+    Q, R = th.linalg.qr(_cell_std.mT.contiguous())
+    _cell_std = R.mT.contiguous()
+    _rot_op = Q.mT.contiguous()
+    # put diag of R.mT positive
+    cell_diag = th.diagonal(_cell_std, dim1=-2, dim2=-1)  # (B, 3)
+    neg_diag_mask = (cell_diag < 0.)  # (B, 3)
+    _rot_op = th.where(neg_diag_mask.unsqueeze(-1), -_rot_op, _rot_op)  # D Q^T
+    _cell_std = th.where(neg_diag_mask.unsqueeze(-2), -_cell_std, _cell_std)  # R^T D
+
+    return _cell_std, _rot_op
+
+def generate_half_space_grids(n_grids: Tuple[int, int, int], device: str = 'cpu') -> th.Tensor:
+    """
+    Generate a half space grid of given `n_grids`. where： h > 0 or (h = 0 and k > 0) or ((h=0 and k=0) or l>=0)
+      * Conventionally, position 0 is set to the gamma point [0, 0, 0] *
+    Args:
+        n_grids: the number of grids at directions x, y, z.
+        device: the device on which the grid is to be generated.
+
+    Returns: (N_grids, 3), grids
+
+    """
+    N = [abs(int(_)) + (_ + 1) % 2 for _ in n_grids]  # to ensure an odd positive integer grid number.
+
+    # check the longest axis
+    cut_axis = max(range(3), key=lambda i: N[i])
+    perm = [cut_axis] + [i for i in range(3) if i != cut_axis]
+    N_h, N_k, N_l = (N[perm[0]], N[perm[1]], N[perm[2]])
+
+    # centered int indices [-Nh//2, ..., 0, ..., -Nh//2+Nh-1]
+    h_vals = th.arange(0, -(N_h // 2) + N_h, device=device, dtype=th.int64)
+    k_vals = th.arange(-(N_k // 2), -(N_k // 2) + N_k, device=device, dtype=th.int64)
+    l_vals = th.arange(-(N_l // 2), -(N_l // 2) + N_l, device=device, dtype=th.int64)
+
+    idx_parts = []
+
+    # ---------- 1) h > 0, k,l \in Z ----------
+    h_pos = h_vals[1:]
+    if h_pos.numel() > 0:
+        N_h_pos = h_pos.numel()
+        N_k_all, N_l_all = N_k, N_l
+
+        hh1 = h_pos.view(-1, 1, 1).expand(-1, N_k_all, N_l_all)
+        kk1 = k_vals.view(1, -1, 1).expand(N_h_pos, -1, N_l_all)
+        ll1 = l_vals.view(1, 1, -1).expand(N_h_pos, N_k_all, -1)
+
+        idx1 = th.empty((N_h_pos * N_k_all * N_l_all, 3), device=device, dtype=th.int64)
+        idx1[:, 0] = hh1.reshape(-1)
+        idx1[:, 1] = kk1.reshape(-1)
+        idx1[:, 2] = ll1.reshape(-1)
+        idx_parts.append(idx1)
+
+    # ---------- 2) h = 0, k > 0, l \in Z ----------
+    k_pos = k_vals[k_vals > 0]
+    if k_pos.numel() > 0:
+        N_k_pos = k_pos.numel()
+        N_l_all = N_l
+
+        hh2 = th.zeros((N_k_pos, N_l_all), device=device, dtype=th.int64)
+        kk2 = k_pos.view(-1, 1).expand(-1, N_l_all)
+        ll2 = l_vals.view(1, -1).expand(N_k_pos, -1)
+
+        idx2 = th.empty((N_k_pos * N_l_all, 3), device=device, dtype=th.int64)
+        idx2[:, 0] = hh2.reshape(-1)
+        idx2[:, 1] = kk2.reshape(-1)
+        idx2[:, 2] = ll2.reshape(-1)
+        idx_parts.append(idx2)
+
+    # ---------- 3) h = 0, k = 0, l > 0 ----------
+    l_pos = l_vals[l_vals > 0]
+    if l_pos.numel() > 0:
+        idx3 = th.empty((l_pos.numel(), 3), device=device, dtype=th.int64)
+        idx3[:, 0] = 0
+        idx3[:, 1] = 0
+        idx3[:, 2] = l_pos
+        idx_parts.append(idx3)
+
+    # all non-zero (h,k,l)
+    if len(idx_parts) > 0:
+        indices_pos = th.cat(idx_parts, dim=0)  # (nG_half, 3)
+    else:
+        # only G=0
+        indices_pos = th.empty((0, 3), device=device, dtype=th.int64)
+
+    # re-permute to original order
+    n_pos = indices_pos.shape[0]
+    indices_orig = th.empty_like(indices_pos)
+    indices_orig[:, perm[0]] = indices_pos[:, 0]
+    indices_orig[:, perm[1]] = indices_pos[:, 1]
+    indices_orig[:, perm[2]] = indices_pos[:, 2]
+    # manually set the 1st element to [0,0,0]
+    G_indices = th.empty((n_pos + 1, 3), device=device, dtype=th.int64)
+    G_indices[0, :] = 0.0
+    G_indices[1:, :] = indices_orig
+
+    return G_indices

BUCToolkit/utils/setup_loggers.py

@@ -0,0 +1,137 @@
+""" Setup logger for all modules """
+#  Copyright (c) 2026.3.26, BUCToolkit.
+#  Authors: Pu Pengxin, Song Xin
+#  Version: 0.9a
+#  File: setup_loggers.py
+#  Environment: Python 3.12
+
+import logging
+import sys
+import warnings
+import os
+from typing import Any
+
+from BUCToolkit.BatchStructures.StructuresIO import structures_io_dumper
+
+
+def clear_all_handlers(logger: logging.Logger):
+    """
+    Clear all handlers of this current logger and its all ancestors until one does not propagate.
+
+    Args:
+        logger: the input logger instance. If it is not a logging.Logger, nothing is done.
+    Returns:
+        the logger instance
+    """
+    current = logger
+    while current:
+        for _hdl in list(current.handlers):
+            current.removeHandler(_hdl)
+            try:
+                _hdl.close()
+            except Exception as ehdl:
+                warnings.warn(f'Failed to close handler {_hdl}: {ehdl}', RuntimeWarning)
+        # if propagate=False，stop checking
+        if not current.propagate:
+            break
+        current = current.parent
+
+def has_any_handler(logger: logging.Logger) -> bool:
+    """
+    Check whether the current logger and its all ancestor loggers have any handlers.
+    Args:
+        logger: the input logger instance. If it is not a logging.Logger, False is returned.
+
+    Returns: bool, the logger has any handlers.
+
+    """
+    if not isinstance(logger, logging.Logger):
+        return False
+    has_handler = False
+    current = logger
+    while current:
+        if current.handlers:
+            has_handler = True
+            break
+        # if propagate=False，stop checking
+        if not current.propagate:
+            break
+        current = current.parent
+
+    return has_handler
+
+
+class BaseIO:
+    """
+    Base class for logs of all classes.
+    """
+
+    def __init__(self, output_file: str|None = None) -> None:
+        self.logger = None
+        self.log_handler = None
+        self.output_file = str(output_file) if output_file is not None else None
+        self.dumper = structures_io_dumper(
+            path=self.output_file,
+            mode='x',
+        )
+
+    def init_logger(self, logger_name: str):
+        # logging
+        if self.logger is None:
+            # cut off propagation
+            supreme_name = logger_name.split('.')[0]
+            top_logger = logging.getLogger(supreme_name)
+            top_logger.propagate = False
+            # set true logger
+            self.logger = logging.getLogger(logger_name)
+            self.logger.setLevel(logging.INFO)
+            formatter = logging.Formatter('%(message)s')
+            if not has_any_handler(self.logger):
+                self.log_handler = logging.StreamHandler(sys.stdout)
+                self.log_handler.setLevel(logging.INFO)
+                self.log_handler.setFormatter(formatter)
+                top_logger.addHandler(self.log_handler)
+        else:
+            warnings.warn('Logger has already initialized. Nothing will be done.', RuntimeWarning)
+
+    def reset_logger_handler(self, handler: str|logging.StreamHandler|logging.FileHandler):
+        """
+        Clear all logging handlers including current logger and its ancestors, and reset one.
+        Args:
+            handler: the new handler.
+
+        Returns:
+
+        """
+        clear_all_handlers(self.logger)
+        # redirect to supreme logger
+        top_logger = self.logger
+        while top_logger.parent and top_logger.propagate:
+            top_logger = top_logger.parent
+
+        formatter = logging.Formatter('%(message)s')
+        if isinstance(handler, logging.Handler):
+            self.log_handler = handler
+        elif isinstance(handler, str):
+            output_path = os.path.dirname(handler)
+            # check whether path exists
+            if not os.path.isdir(output_path): os.makedirs(output_path)
+            # set log handler
+            self.log_handler = logging.FileHandler(handler, 'w', delay=True)
+        else:
+            raise TypeError("handler must be a string path or a logging.Handler instance")
+
+        self.log_handler.setLevel(logging.INFO)
+        self.log_handler.setFormatter(formatter)
+        top_logger.addHandler(self.log_handler)
+
+    def reset_dumper(self, dumper: Any) -> None:
+        if self.output_file is not None:
+            self.dumper.close()
+            del self.dumper
+            self.dumper = dumper
+        else:
+            self.logger.error(
+                "ERROR: No output file specified. Hence, resetting dumper is meaningless.\n"
+                "'reset_dumper': Operation REFUSED."
+            )

buctoolkit-1.0b0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: BUCToolkit
+Version: 1.0b0
+Summary: Batch-upscaled Catalysis Toolkit (BUCToolkit), which can apply PyTorch-based deep-learning model to perform training, predictions, batched structure optimization, batched molecular dynamics with/without constraints, and batched Monte Carlo simulations. Various tools for handling catalyst structure files are also included.
+Home-page: https://github.com/TrinitroCat/BUCToolkit
+Author: Pu Pengxin, Song xin
+Author-email: 
+License: MIT
+Requires-Python: >= 3.11
+License-File: LICENSE
+Requires-Dist: joblib>=1.4.2
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: torch>=2.4.1
+Provides-Extra: dgl
+Requires-Dist: dgl; extra == "dgl"
+Provides-Extra: pyg
+Requires-Dist: torch_geometric>=2.6.1; extra == "pyg"
+Provides-Extra: prompt-toolkit
+Requires-Dist: prompt-toolkit>=3.0.43; extra == "prompt-toolkit"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

buctoolkit-1.0b0.dist-info/RECORD

@@ -0,0 +1,88 @@
+BUCToolkit/StandardTemplate.py,sha256=kk0-8lELWLeXbBeSPoqgUzhSTG3GetDTjjjWae8s18A,14028
+BUCToolkit/__init__.py,sha256=TJoGfkDSSLhT82miEG7lZmjeDDIdluu4XzJVquJmz-0,969
+BUCToolkit/_version.py,sha256=4CEfQ0nGY9ug2lulGd9iwNCj3y4F3T8spLR6bilyNAY,159
+BUCToolkit/io.py,sha256=rlQpRBX5NmyYyETioOzqa2fEnil_EA_EZqbjReddzH4,810
+BUCToolkit/BatchGenerate/CheckStructures.py,sha256=kvjWipwJ33owshUUKmW0lKXTolsiyh9vARs4Epm_trE,8427
+BUCToolkit/BatchGenerate/__init__.py,sha256=jSXI-67YFF7iu545d6IbC1agnYIJeCQ6sEarL7-sxfo,144
+BUCToolkit/BatchGenerate/coords_interp.py,sha256=fQHsQfJEd4J73sscp3LiddgcmbhvgrXWtu4Nz66r4Mw,5183
+BUCToolkit/BatchGenerate/initial_ads_structures.py,sha256=QYdt3O0oU6bfZE1yombqq2NALt-4wEV_aGPtM_QbN_0,14415
+BUCToolkit/BatchGenerate/random_replace.py,sha256=5_oeVLrdbkm_vXWs1HTPNrNxkcLx5357eLy-XUY6v1c,3497
+BUCToolkit/BatchMC/MetropolisMC.py,sha256=B48hKYNYCucSGwJhBexFdl9Wu8RT2Gsrr7Pj-6bw-30,8170
+BUCToolkit/BatchMC/_BaseMC.py,sha256=-9izjbTi30hWEQ4aLGcAIa5AuBmwlnG2lxsBTr-6WqM,38495
+BUCToolkit/BatchMC/__init__.py,sha256=MN9NTbJz-K7lT6xpRJ1W583kxiwFRz7iLUzbC0ti4RA,187
+BUCToolkit/BatchMD/BiasedMD.py,sha256=-9i3XN9CEFyUZa6JNl9mxVj2bVb-_PJ6eO6GBTPwkUU,10050
+BUCToolkit/BatchMD/NVE.py,sha256=tjZrLFOmKUhkDFYmUaCqP0qYyy8kTbdAscHCK8QvR_8,3445
+BUCToolkit/BatchMD/NVT.py,sha256=49uETm96AA1b4T_JymBMJmK4qoSTgXbikX69AY8dAts,21166
+BUCToolkit/BatchMD/_BaseMD.py,sha256=ZOzePJmbC484XsBxTPCSuqzxIE-sGy9dYKqucng3YRU,56911
+BUCToolkit/BatchMD/__init__.py,sha256=iVpmxNuIbd-tBYZe13DtjYTIevOy_Q0nDI817eXVjO4,377
+BUCToolkit/BatchMD/constrained_md/BiasedMD.py,sha256=qgktB1Z_a7AEjQtPJn1GGeB9hDzsZe08UtHqr4FbatM,9955
+BUCToolkit/BatchMD/constrained_md/ConstrNVE.py,sha256=szKte1SPFUZBZRmvlFlHFclEQRlhAhTbowOliag_eoY,6964
+BUCToolkit/BatchMD/constrained_md/ConstrNVT.py,sha256=MV6B9gy3ai3Hbrs0qvP9ZgGxXUwOFEAdElwXx6aBAWA,19494
+BUCToolkit/BatchMD/constrained_md/NVE.py,sha256=o6QBhAAVx-3wOUI5dOmQz2kKnhAQhwxM9UuqAfnmAQ8,3087
+BUCToolkit/BatchMD/constrained_md/NVT.py,sha256=9n6VEy4mjHNMLrKLvaJiqIfx5xAC-8MSRRHC-_4qN34,15160
+BUCToolkit/BatchMD/constrained_md/_BaseMD.py,sha256=Ibu5YbPRgEcNKBKYfKN9icblNrI_m8eie1wk0xiEX1A,20665
+BUCToolkit/BatchMD/constrained_md/_ConstrBaseMD.py,sha256=mlLsrezk4u8ImgzTCF1EeX-Pq-b5586MyaGhKGcMf-c,27592
+BUCToolkit/BatchMD/constrained_md/__init__.py,sha256=--wBxaTL2jeFodU2WVFfYD7P2XQOYJtTxmV93CTi1O4,402
+BUCToolkit/BatchOptim/_BaseOpt.py,sha256=saO1uicOX5cHrV1m5-6m5xb8vjnmEhifLjaeT59tFbY,34694
+BUCToolkit/BatchOptim/__init__.py,sha256=CCSaaM3yYx2TP0QnOlQT4fubtV9Zb0Vbcskgxk1eupQ,529
+BUCToolkit/BatchOptim/frequency.py,sha256=dzgD2-bt4vUKY8fTn1yiSXyZNsifm2Hp9JtHLFlWqAY,19376
+BUCToolkit/BatchOptim/TS/CI_NEB.py,sha256=xIpVZBX0VmrvTCyzHVAFOX2DuLCpjU5Yo68duvRemUo,11994
+BUCToolkit/BatchOptim/TS/Dimer.py,sha256=c_eSXVJaD6enWpfZyEPLe0w85XZ3mFnUidujr8OEAGU,42754
+BUCToolkit/BatchOptim/TS/__init__.py,sha256=JgrkjZOnd30e8cunMAQYWKIygY0PWUeUMwfn8HF-8tQ,195
+BUCToolkit/BatchOptim/_utils/__init__.py,sha256=jSXI-67YFF7iu545d6IbC1agnYIJeCQ6sEarL7-sxfo,144
+BUCToolkit/BatchOptim/_utils/_line_search.py,sha256=dMvsU7UmxYY5HfbGqbxJOhFx2zWOqiT4u-lgXhc46Ro,39295
+BUCToolkit/BatchOptim/_utils/_warnings.py,sha256=1Z-y3LbElwFF1mEQ75R8RWDQz5lTBlug_eDf7jzvzuc,261
+BUCToolkit/BatchOptim/minimize/CG.py,sha256=-70KyQroR6rHujNrigWujNbKW5Jq_i13M-lmxjF8Mc0,8876
+BUCToolkit/BatchOptim/minimize/FIRE.py,sha256=l8jyhP58G0Q5G1XHtRuphKtsVx9X9zIQuBI_r4h8Yvs,13070
+BUCToolkit/BatchOptim/minimize/QN.py,sha256=GkmIU7Wvs_zjS4n24ISamjSXq3uIx_WP48TosazB6NQ,8309
+BUCToolkit/BatchOptim/minimize/__init__.py,sha256=39lqioP-wQpBkpOZV0ZckyvwGzZ3C-jIkbYwAYZgcBM,325
+BUCToolkit/BatchStructures/BatchStructuresBase.py,sha256=iN6bJzgYY64ShL4H4ou8V6capvUJ19phvqQUJF8kwuA,105716
+BUCToolkit/BatchStructures/StructuresIO.py,sha256=JLCntgMC6te_g76caJBAGZzueoB0wXJxayck_r9E7hY,58804
+BUCToolkit/BatchStructures/__init__.py,sha256=cBRJ7r7n2oqp6T91bGt9PkuMgX6L1QNUmsUaHN-Jqjs,397
+BUCToolkit/Preprocessing/__init__.py,sha256=_8paUhW8u-B1PwNXyM5eniBu2KamjYTDHWK_MNmopcc,145
+BUCToolkit/Preprocessing/load_files.py,sha256=kqPxa9Q4nLugNkymQ2HNmN0-iirOShZydC-jus2IzmI,77101
+BUCToolkit/Preprocessing/preprocessing.py,sha256=wsB9ehxIGgKVn0NFgfQOSc3_ldS3b0tiia4vBXP3kJw,39534
+BUCToolkit/Preprocessing/sampling.py,sha256=2eEAYJP2j_Yf5YVLWJ8H0LlDsyxsPbodfsvt-x5SnPs,11836
+BUCToolkit/Preprocessing/supercells.py,sha256=86cfN9VLBM6AgAq_r8nlfuujs2rR_fN2JcbQdlt32_o,6006
+BUCToolkit/Preprocessing/write_files.py,sha256=7XduHCBFGe6KuDo9WPNE2fWaREumemqWd9QWkeKlKFo,23012
+BUCToolkit/api/ConstrainedMolecularDynamics.py,sha256=IW7N6tI30U_Xj7MkpilqIJwCN74xCDnGjxcoHWAaN4o,16618
+BUCToolkit/api/DataLoaders.py,sha256=dLkdgih8RLVMJ0kpYbk-KZWJm6718Ux3_i-FcglYh_M,13057
+BUCToolkit/api/Losses.py,sha256=qoofPFwe_lpc1hLaDbpAlX-v8x2r94g6azJGsq6lv3Y,5813
+BUCToolkit/api/Metrics.py,sha256=NStR94teQfWQNPEbEwD43Ov91Uj55V2OL_MKIdkxGw0,2565
+BUCToolkit/api/ModelOptims.py,sha256=4U1fYIm8LkjY6ti6kdRTnqhQ-M7_4EO6HU6jUG1NPQw,12442
+BUCToolkit/api/MolecularDynamics.py,sha256=NN-h9UTJyShW3nvDjfCldQqOTRl185G-MT-MLe2PmE4,12787
+BUCToolkit/api/MonteCarlo.py,sha256=CgnpNwLCwWQ_vp3h1cjj8CABTKnW_zm81B1cZOseRYM,12805
+BUCToolkit/api/NEB.py,sha256=PHl0qbJl_iKKO5q2MqAaH1e_H3yd7WwdnisSKjqKGiE,15325
+BUCToolkit/api/Predictor.py,sha256=skEoPLnGPOeDREBYjRzNy9ZLZQUVtGUuydJT6p5z9Fw,11836
+BUCToolkit/api/StructureOptimization.py,sha256=kcxcJrHbuIF068oKxvRKfoCtxP0ZoslUK8_f497ZTYk,25131
+BUCToolkit/api/Trainer.py,sha256=dxWUnGEZ-imdJTw0hV6ATASbU5q3T_F7pDaHVZEigBE,35442
+BUCToolkit/api/VibrationAnalysis.py,sha256=o2t_TEyQB4CmPNFvSWMzniKE1NIUQDx-z_jrLQITtPs,13438
+BUCToolkit/api/__init__.py,sha256=IE9cVu0Qf4sN1wckSoRo2JbxBPTXY8xQv3eHFwTIbiY,1006
+BUCToolkit/api/_io.py,sha256=FMwaAh5ObYE9PlpTSP1f1UtiW9GLifg0g74PCCs4uJA,41158
+BUCToolkit/cli/__init__.py,sha256=sy9uD5-x74DG21f7EEzWjJbWxN8vcqCIZ6WYF_a7nFU,425
+BUCToolkit/cli/cli.py,sha256=9azg2EJKeKCmTTaU61iDXSfJgZjFz7I874SEm28s-OI,40523
+BUCToolkit/cli/input_stub.py,sha256=p8PJFKfyvyB0r9jXkWLim3x0Y1noUyA5TFJQeEM9qic,9333
+BUCToolkit/cli/main.py,sha256=xP3OKaxwfw76n2V_AWXwb4Y8TTPDrJqOTsHJOGjvTig,13948
+BUCToolkit/cli/print_logo.py,sha256=TmMfeRtvIRDqrUQcxZe1FMpUlExKfUfsR6VhDqM982Q,4046
+BUCToolkit/cli/template_model.py,sha256=x8PwATqv1VkeTwzOa5HYowJMLIx142t0GVZeBN07Axw,207
+BUCToolkit/utils/AtomSelector.py,sha256=O8aLqCHy3tKNXsjSOYM9noIw0fAakug8LnrYL_KGxmc,2422
+BUCToolkit/utils/AtomicNumber2Properties.py,sha256=T3LqXfw8TMdnqFu-9rgL1_4x5HsSeutgTq_pLkxzwI0,1031
+BUCToolkit/utils/ElemListReduce.py,sha256=m3ZyulRtLRjMyb5RHrUUFT7_gVfqpun63Smq1EJXU4c,1715
+BUCToolkit/utils/Ewald.py,sha256=DAWBJprknpCdOSZ-g72DwxXrGCER5Y3huilbusrzT88,9371
+BUCToolkit/utils/IrregularTensorReformat.py,sha256=sgQAPI98NeGNVajojD1BWDQnYDQGtd9YrVDzEQWtDiI,1989
+BUCToolkit/utils/_CheckModules.py,sha256=5i-GiY9qFmVvPl1QzDTMBVP-NvzZM7Ivlq3ll1ea_cI,968
+BUCToolkit/utils/_Element_info.py,sha256=7bLGi7EA0Hn1OTz1iV_ZFTasOuebbgbFEuVhQsMtU4E,8086
+BUCToolkit/utils/__init__.py,sha256=39qYNYXTbkva4oGb5vsCI6Squ-WX9o0NitJzrhdFXD0,741
+BUCToolkit/utils/_para_flatt_list.py,sha256=vyQaqd1ghbo1oAW2Cq1Nuv5ceUYYiwaPbukeBBDLqSk,3503
+BUCToolkit/utils/_print_formatter.py,sha256=dxG-yhyQPnpl6xa2OmniBXKfbYn5lci589YZYhGy6Bo,1507
+BUCToolkit/utils/check_structures.py,sha256=0h4MpQsbANdRR2whLyk1GNi1KDoef_tisHWBxbU0UDk,9242
+BUCToolkit/utils/function_utils.py,sha256=u8f5S8_odS0UPKCQK_4pniaY0lyenQFpYC6UrQTShFA,4530
+BUCToolkit/utils/grad_functions.py,sha256=TAuaT6tIkjiS412_jknLiR9wb9uWSKl_FCKKs_hhmuw,2302
+BUCToolkit/utils/index_ops.py,sha256=BlYo9UdN9GjLsEflI5KYqwmEjrkpl3MNWpLFLZuVn9Y,16292
+BUCToolkit/utils/setup_loggers.py,sha256=F0Y-vPBFNw3ShHbeX0wb2Cmy-TcSfghBNutfOVwy_54,4579
+buctoolkit-1.0b0.dist-info/licenses/LICENSE,sha256=Fy5D7kAV4b5O6_mK1bBg6dIvljsl1k5gHhRldMxKIRw,1082
+buctoolkit-1.0b0.dist-info/METADATA,sha256=QzsUkmLqzfpVbbmDZZWdn4LbrcilTADSv4oJWScESK4,1047
+buctoolkit-1.0b0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+buctoolkit-1.0b0.dist-info/entry_points.txt,sha256=PAZckBYiDWzv10IyRazgc957czw2Ww0SgDO9z__mN0Q,154
+buctoolkit-1.0b0.dist-info/top_level.txt,sha256=dL0flE_C5sul1HwYQO_iR7mH9TlH5UgH9mGL9ns_yas,11
+buctoolkit-1.0b0.dist-info/RECORD,,