hillclimber 0.1.0a2__py3-none-any.whl → 0.1.0a3__py3-none-any.whl

hillclimber/__init__.py

@@ -1,4 +1,5 @@
 from hillclimber.actions import PrintAction
+from hillclimber.analysis import sum_hills, read_colvar, plot_cv_time_series
 from hillclimber.biases import RestraintBias, UpperWallBias, LowerWallBias
 from hillclimber.cvs import DistanceCV, AngleCV, CoordinationNumberCV, TorsionCV, RadiusOfGyrationCV
 from hillclimber.metadynamics import MetadBias, MetaDynamicsConfig, MetaDynamicsModel
@@ -26,4 +27,7 @@ __all__ = [
     "RestraintBias",
     "UpperWallBias",
     "LowerWallBias",
+    "sum_hills",
+    "read_colvar",
+    "plot_cv_time_series",
 ]

hillclimber/analysis.py

@@ -0,0 +1,636 @@
+"""Analysis utilities for metadynamics simulations.
+
+This module provides tools for analyzing metadynamics simulations,
+including free energy surface reconstruction and other post-processing tasks.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import typing as t
+from pathlib import Path
+
+import numpy as np
+
+
+def _validate_multi_cv_params(
+    min_bounds: float | list[float] | None = None,
+    max_bounds: float | list[float] | None = None,
+    bin: int | list[int] | None = None,
+    spacing: float | list[float] | None = None,
+    sigma: float | list[float] | None = None,
+    idw: str | list[str] | None = None,
+) -> None:
+    """Validate that multi-CV parameters have consistent dimensions.
+
+    Parameters
+    ----------
+    min_bounds, max_bounds, bin, spacing, sigma, idw
+        Parameters from sum_hills that can be lists for multi-CV cases.
+
+    Raises
+    ------
+    ValueError
+        If list parameters have inconsistent lengths.
+    """
+    # Collect all list parameters and their lengths
+    list_params: dict[str, int] = {}
+
+    params_to_check = {
+        "min_bounds": min_bounds,
+        "max_bounds": max_bounds,
+        "bin": bin,
+        "spacing": spacing,
+        "sigma": sigma,
+        "idw": idw,
+    }
+
+    for name, value in params_to_check.items():
+        if isinstance(value, (list, tuple)):
+            list_params[name] = len(value)
+
+    # If no list parameters, nothing to validate (single CV case)
+    if not list_params:
+        return
+
+    # Check that all list parameters have the same length
+    lengths = set(list_params.values())
+    if len(lengths) > 1:
+        # Build a detailed error message
+        param_details = ", ".join(
+            f"{name}={length}" for name, length in list_params.items()
+        )
+        raise ValueError(
+            f"Inconsistent number of CVs in parameters. "
+            f"All list parameters must have the same length. "
+            f"Got: {param_details}"
+        )
+
+
+def sum_hills(
+    hills_file: str | Path,
+    plumed_bin_path: str | Path | None = None,
+    # Boolean flags
+    negbias: bool = False,
+    nohistory: bool = False,
+    mintozero: bool = False,
+    # File/histogram options
+    histo: str | Path | None = None,
+    # Grid parameters
+    stride: int | None = None,
+    min_bounds: float | list[float] | None = None,
+    max_bounds: float | list[float] | None = None,
+    bin: int | list[int] | None = None,
+    spacing: float | list[float] | None = None,
+    # Variable selection
+    idw: str | list[str] | None = None,
+    # Output options
+    outfile: str | Path | None = None,
+    outhisto: str | Path | None = None,
+    # Integration parameters
+    kt: float | None = None,
+    sigma: float | list[float] | None = None,
+    # Format
+    fmt: str | None = None,
+    # Additional options
+    verbose: bool = True,
+    check: bool = True,
+) -> subprocess.CompletedProcess:
+    """Run PLUMED sum_hills to reconstruct free energy surfaces from metadynamics.
+
+    This function wraps the PLUMED ``sum_hills`` command-line tool, which analyzes
+    HILLS files from metadynamics simulations to reconstruct the free energy surface.
+
+    Parameters
+    ----------
+    hills_file : str or Path
+        Path to the HILLS file to analyze. This file is generated during
+        metadynamics simulations and contains the deposited Gaussian hills.
+    plumed_bin_path : str or Path, optional
+        Path to the PLUMED installation directory (containing ``bin/`` and ``lib/``
+        subdirectories). If None, searches for ``plumed`` in the system PATH.
+        When a full installation path is provided, the function will properly set
+        LD_LIBRARY_PATH to include the PLUMED libraries.
+    negbias : bool, default=False
+        Print the negative bias instead of the free energy.
+    nohistory : bool, default=False
+        To be used with ``stride``: splits the bias/histogram without previous history.
+    mintozero : bool, default=False
+        Translate all minimum values in bias/histogram to zero.
+    histo : str or Path, optional
+        Name of the file for histogram (a COLVAR/HILLS file is good).
+    stride : int, optional
+        Stride for integrating hills file. Default is 0 (never integrate).
+    min_bounds : float or list[float], optional
+        Lower bounds for the grid. For multi-dimensional CVs, provide a list with
+        one value per CV (e.g., ``[-3.14, -3.14]`` for two torsion angles).
+    max_bounds : float or list[float], optional
+        Upper bounds for the grid. For multi-dimensional CVs, provide a list with
+        one value per CV (e.g., ``[3.14, 3.14]`` for two torsion angles).
+    bin : int or list[int], optional
+        Number of bins for the grid. For multi-dimensional CVs, provide a list with
+        one value per CV (e.g., ``[250, 250]`` for two CVs with 250 bins each).
+    spacing : float or list[float], optional
+        Grid spacing, alternative to the number of bins. For multi-dimensional CVs,
+        provide a list with one value per CV.
+    idw : str or list[str], optional
+        Variables to be used for the free-energy/histogram. For multi-dimensional CVs,
+        provide a list with one variable name per CV (e.g., ``['phi', 'psi']``).
+    outfile : str or Path, optional
+        Output file for sum_hills. Default is ``fes.dat``.
+    outhisto : str or Path, optional
+        Output file for the histogram.
+    kt : float, optional
+        Temperature in energy units (kJ/mol) for integrating out variables.
+    sigma : float or list[float], optional
+        Sigma for binning (only needed when doing histogram). For multi-dimensional CVs,
+        provide a list with one value per CV.
+    fmt : str, optional
+        Output format specification.
+    verbose : bool, default=True
+        Print command output to stdout/stderr.
+    check : bool, default=True
+        Raise exception if command fails.
+
+    Returns
+    -------
+    subprocess.CompletedProcess
+        The completed process object from subprocess.run.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the HILLS file, PLUMED executable, or PLUMED installation directory
+        cannot be found.
+    ValueError
+        If list-based parameters (``bin``, ``min_bounds``, ``max_bounds``, etc.)
+        have inconsistent lengths when using multiple CVs.
+    subprocess.CalledProcessError
+        If the PLUMED command fails and ``check=True``.
+
+    Examples
+    --------
+    Basic usage to reconstruct a 1D free energy surface:
+
+    >>> import hillclimber as hc
+    >>> hc.sum_hills("HILLS")
+
+    With custom grid resolution and output file:
+
+    >>> hc.sum_hills(
+    ...     "HILLS",
+    ...     bin=1000,
+    ...     outfile="custom_fes.dat"
+    ... )
+
+    For a 2D free energy surface with explicit bounds:
+
+    >>> hc.sum_hills(
+    ...     "HILLS",
+    ...     bin=[100, 100],
+    ...     min_bounds=[0.0, 0.0],
+    ...     max_bounds=[10.0, 10.0],
+    ...     outfile="fes_2d.dat"
+    ... )
+
+    For protein backbone torsion angles (phi and psi):
+
+    >>> hc.sum_hills(
+    ...     "HILLS",
+    ...     bin=[250, 250],
+    ...     min_bounds=[-3.14, -3.14],
+    ...     max_bounds=[3.14, 3.14],
+    ...     idw=["phi", "psi"],
+    ...     outfile="ramachandran.dat"
+    ... )
+
+    Resources
+    ---------
+    - https://www.plumed.org/doc-master/user-doc/html/sum_hills.html
+
+    Notes
+    -----
+    The HILLS file is automatically generated during metadynamics simulations
+    when using the METAD action. Each line in the file represents a deposited
+    Gaussian hill with its position, width (sigma), and height.
+
+    The free energy surface is reconstructed by summing all deposited hills:
+    F(s) = -V(s) where V(s) is the bias potential.
+
+    **Multi-CV Consistency:**
+    When using multiple collective variables (CVs), all list-based parameters
+    must have the same length. For example, if analyzing two CVs (phi and psi),
+    then ``bin``, ``min_bounds``, ``max_bounds``, and ``idw`` (if provided as lists)
+    must all have exactly 2 elements. The function will raise a ``ValueError``
+    if inconsistent list lengths are detected.
+    """
+    # Convert to Path object
+    hills_file = Path(hills_file)
+
+    # Verify HILLS file exists
+    if not hills_file.exists():
+        raise FileNotFoundError(f"HILLS file not found: {hills_file}")
+
+    # Find PLUMED executable and set up environment
+    env = os.environ.copy()
+
+    if plumed_bin_path is None:
+        # Try to find plumed in system PATH
+        plumed_exec = shutil.which("plumed")
+        if plumed_exec is None:
+            raise FileNotFoundError(
+                "PLUMED executable not found in system PATH. "
+                "Please install PLUMED or specify the installation path with plumed_bin_path="
+            )
+    else:
+        # Use provided PLUMED installation path
+        plumed_bin_path = Path(plumed_bin_path)
+        plumed_exec = plumed_bin_path / "bin" / "plumed"
+        lib_path = plumed_bin_path / "lib"
+
+        # Verify paths exist
+        if not plumed_exec.exists():
+            raise FileNotFoundError(
+                f"PLUMED executable not found at: {plumed_exec}\n"
+                f"Make sure plumed_bin_path points to the PLUMED installation directory "
+                f"containing bin/ and lib/ subdirectories."
+            )
+        if not lib_path.exists():
+            raise FileNotFoundError(f"PLUMED lib directory not found: {lib_path}")
+
+        # Set LD_LIBRARY_PATH for PLUMED libraries
+        current_ld_path = env.get("LD_LIBRARY_PATH", "")
+        if current_ld_path:
+            env["LD_LIBRARY_PATH"] = f"{lib_path}:{current_ld_path}"
+        else:
+            env["LD_LIBRARY_PATH"] = str(lib_path)
+
+        plumed_exec = str(plumed_exec)
+
+    # Validate multi-CV parameter consistency
+    _validate_multi_cv_params(
+        min_bounds=min_bounds,
+        max_bounds=max_bounds,
+        bin=bin,
+        spacing=spacing,
+        sigma=sigma,
+        idw=idw,
+    )
+
+    # Build command
+    cmd_parts = [plumed_exec, "sum_hills"]
+
+    # Add hills file
+    cmd_parts.extend(["--hills", str(hills_file)])
+
+    # Add boolean flags
+    if negbias:
+        cmd_parts.append("--negbias")
+    if nohistory:
+        cmd_parts.append("--nohistory")
+    if mintozero:
+        cmd_parts.append("--mintozero")
+
+    # Helper function to format list parameters
+    def format_param(value: t.Any) -> str:
+        if isinstance(value, (list, tuple)):
+            return ",".join(str(v) for v in value)
+        return str(value)
+
+    # Add optional parameters
+    if histo is not None:
+        cmd_parts.extend(["--histo", str(histo)])
+    if stride is not None:
+        cmd_parts.extend(["--stride", str(stride)])
+    if min_bounds is not None:
+        cmd_parts.extend(["--min", format_param(min_bounds)])
+    if max_bounds is not None:
+        cmd_parts.extend(["--max", format_param(max_bounds)])
+    if bin is not None:
+        cmd_parts.extend(["--bin", format_param(bin)])
+    if spacing is not None:
+        cmd_parts.extend(["--spacing", format_param(spacing)])
+    if idw is not None:
+        cmd_parts.extend(["--idw", format_param(idw)])
+    if outfile is not None:
+        cmd_parts.extend(["--outfile", str(outfile)])
+    if outhisto is not None:
+        cmd_parts.extend(["--outhisto", str(outhisto)])
+    if kt is not None:
+        cmd_parts.extend(["--kt", str(kt)])
+    if sigma is not None:
+        cmd_parts.extend(["--sigma", format_param(sigma)])
+    if fmt is not None:
+        cmd_parts.extend(["--fmt", str(fmt)])
+
+    # Run command
+    if verbose:
+        print(f"Running: {' '.join(cmd_parts)}")
+
+    result = subprocess.run(
+        cmd_parts,
+        env=env,
+        capture_output=not verbose,
+        text=True,
+        check=check,
+    )
+
+    if verbose and result.returncode == 0:
+        print("sum_hills completed successfully")
+
+    return result
+
+
+def read_colvar(
+    colvar_file: str | Path,
+) -> dict[str, np.ndarray]:
+    """Read a PLUMED COLVAR file and parse its contents.
+
+    This function reads a COLVAR file produced by PLUMED, extracts the field names
+    from the header (which starts with ``#! FIELDS``), and returns the data as a
+    dictionary mapping field names to numpy arrays.
+
+    Parameters
+    ----------
+    colvar_file : str or Path
+        Path to the COLVAR file to read.
+
+    Returns
+    -------
+    dict[str, np.ndarray]
+        Dictionary mapping field names to 1D numpy arrays containing the data.
+        Keys correspond to the fields specified in the COLVAR header.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the COLVAR file does not exist.
+    ValueError
+        If the COLVAR file does not contain a valid ``#! FIELDS`` header.
+
+    Examples
+    --------
+    >>> import hillclimber as hc
+    >>> data = hc.read_colvar("COLVAR")
+    >>> print(data.keys())
+    dict_keys(['time', 'phi', 'psi'])
+    >>> print(data['time'][:5])
+    [0. 1. 2. 3. 4.]
+
+    Notes
+    -----
+    The COLVAR file format from PLUMED starts with a header line:
+    ``#! FIELDS time cv1 cv2 ...``
+
+    All subsequent lines starting with ``#`` are treated as comments and ignored.
+    Data lines are parsed as whitespace-separated numeric values.
+
+    Resources
+    ---------
+    - https://www.plumed.org/doc-master/user-doc/html/colvar.html
+    """
+    colvar_file = Path(colvar_file)
+
+    if not colvar_file.exists():
+        raise FileNotFoundError(f"COLVAR file not found: {colvar_file}")
+
+    # Read the file
+    with open(colvar_file, "r") as f:
+        lines = f.readlines()
+
+    # Find and parse the header
+    field_names: list[str] | None = None
+    for line in lines:
+        if line.startswith("#! FIELDS"):
+            # Extract field names from the header
+            # Format: "#! FIELDS time phi psi ..."
+            fields_match = re.match(r"#!\s*FIELDS\s+(.+)", line)
+            if fields_match:
+                field_names = fields_match.group(1).split()
+                break
+
+    if field_names is None:
+        raise ValueError(
+            f"COLVAR file {colvar_file} does not contain a valid '#! FIELDS' header"
+        )
+
+    # Parse data lines (skip comments)
+    data_lines = []
+    for line in lines:
+        # Skip comments and empty lines
+        if line.startswith("#") or not line.strip():
+            continue
+        # Parse numeric data
+        values = line.split()
+        if len(values) == len(field_names):
+            data_lines.append([float(v) for v in values])
+
+    # Convert to numpy array
+    data_array = np.array(data_lines)
+
+    # Create dictionary mapping field names to columns
+    result = {name: data_array[:, i] for i, name in enumerate(field_names)}
+
+    return result
+
+
+def plot_cv_time_series(
+    colvar_file: str | Path,
+    cv_names: list[str] | None = None,
+    time_unit: str = "ps",
+    exclude_patterns: list[str] | None = None,
+    figsize: tuple[float, float] = (8, 5),
+    kde_width: str = "25%",
+    colors: list[str] | None = None,
+    alpha: float = 0.5,
+    marker: str = "x",
+    marker_size: float = 10,
+) -> tuple[t.Any, t.Any]:
+    """Plot collective variables over time with KDE distributions.
+
+    This function creates a visualization showing CV evolution over time as scatter
+    plots, with kernel density estimation (KDE) plots displayed on the right side
+    to show the distribution of each CV.
+
+    Parameters
+    ----------
+    colvar_file : str or Path
+        Path to the COLVAR file to plot.
+    cv_names : list[str], optional
+        List of CV names to plot. If None, automatically detects CVs by excluding
+        common non-CV fields like 'time', 'sigma_*', 'height', 'biasf'.
+    time_unit : str, default='ps'
+        Unit label for the time axis.
+    exclude_patterns : list[str], optional
+        Additional regex patterns for field names to exclude from auto-detection.
+        Default excludes: 'time', 'sigma_.*', 'height', 'biasf'.
+    figsize : tuple[float, float], default=(8, 5)
+        Figure size in inches (width, height).
+    kde_width : str, default='25%'
+        Width of the KDE subplot as a percentage of the main plot width.
+    colors : list[str], optional
+        List of colors to use for each CV. If None, uses default color cycle.
+    alpha : float, default=0.5
+        Transparency for scatter points.
+    marker : str, default='x'
+        Marker style for scatter points.
+    marker_size : float, default=10
+        Size of scatter markers.
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+        The matplotlib figure object.
+    axes : tuple
+        Tuple of (main_axis, kde_axis) matplotlib axes objects.
+
+    Raises
+    ------
+    ImportError
+        If matplotlib or seaborn is not installed.
+    FileNotFoundError
+        If the COLVAR file does not exist.
+
+    Examples
+    --------
+    Basic usage with auto-detected CVs:
+
+    >>> import hillclimber as hc
+    >>> fig, axes = hc.plot_cv_time_series("COLVAR")
+
+    Plot specific CVs:
+
+    >>> fig, axes = hc.plot_cv_time_series("COLVAR", cv_names=["phi", "psi"])
+
+    Customize appearance:
+
+    >>> fig, axes = hc.plot_cv_time_series(
+    ...     "COLVAR",
+    ...     figsize=(10, 6),
+    ...     colors=["blue", "red"],
+    ...     alpha=0.7
+    ... )
+
+    Notes
+    -----
+    This function requires matplotlib and seaborn to be installed.
+
+    The function automatically detects CVs by excluding common metadata fields
+    such as 'time', 'sigma_*', 'height', and 'biasf'. You can specify additional
+    exclusion patterns or explicitly provide the CV names to plot.
+
+    Resources
+    ---------
+    - https://www.plumed.org/doc-master/user-doc/html/colvar.html
+    """
+    try:
+        import matplotlib.pyplot as plt
+        import seaborn as sns
+        from mpl_toolkits.axes_grid1 import make_axes_locatable
+    except ImportError as e:
+        raise ImportError(
+            "matplotlib and seaborn are required for plotting. "
+            "Install them with: pip install matplotlib seaborn"
+        ) from e
+
+    # Read the COLVAR file
+    data = read_colvar(colvar_file)
+
+    # Auto-detect CVs if not specified
+    if cv_names is None:
+        # Default exclusion patterns
+        default_exclude = [
+            r"^time$",
+            r"^sigma_.*$",
+            r"^height$",
+            r"^biasf$",
+        ]
+        if exclude_patterns is not None:
+            default_exclude.extend(exclude_patterns)
+
+        # Filter field names
+        detected_cvs: list[str] = []
+        for field in data.keys():
+            # Check if field matches any exclusion pattern
+            exclude = False
+            for pattern in default_exclude:
+                if re.match(pattern, field):
+                    exclude = True
+                    break
+            if not exclude:
+                detected_cvs.append(field)
+
+        if not detected_cvs:
+            raise ValueError(
+                "No CVs detected in COLVAR file. "
+                "All fields were excluded by the exclusion patterns."
+            )
+        cv_names = detected_cvs
+
+    # Verify that all requested CVs exist
+    missing_cvs = [cv for cv in cv_names if cv not in data]
+    if missing_cvs:
+        raise ValueError(
+            f"CVs not found in COLVAR file: {missing_cvs}. "
+            f"Available fields: {list(data.keys())}"
+        )
+
+    # Get time data
+    if "time" not in data:
+        raise ValueError("COLVAR file must contain a 'time' field")
+    time = data["time"]
+
+    # Default colors if not provided
+    if colors is None:
+        colors = plt.cm.tab10.colors  # type: ignore
+
+    # Set seaborn style
+    sns.set(style="whitegrid")
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=figsize)
+
+    # Plot each CV
+    for i, cv_name in enumerate(cv_names):
+        color = colors[i % len(colors)]
+        cv_data = data[cv_name]
+        ax.scatter(
+            time,
+            cv_data,
+            c=[color],
+            label=cv_name,
+            marker=marker,
+            s=marker_size,
+            alpha=alpha,
+        )
+
+    ax.set_xlabel(f"Time / {time_unit}")
+    ax.set_ylabel("CV value")
+    ax.legend()
+
+    # Create KDE subplot on the right
+    divider = make_axes_locatable(ax)
+    ax_kde = divider.append_axes("right", size=kde_width, pad=0.1, sharey=ax)
+
+    # Plot KDE for each CV
+    for i, cv_name in enumerate(cv_names):
+        color = colors[i % len(colors)]
+        cv_data = data[cv_name]
+        sns.kdeplot(
+            y=cv_data,
+            ax=ax_kde,
+            color=color,
+            fill=True,
+            alpha=0.3,
+            linewidth=1.5,
+            label=cv_name,
+        )
+
+    # Clean up KDE axis
+    ax_kde.set_xlabel("Density")
+    ax_kde.yaxis.set_tick_params(labelleft=False)
+
+    plt.tight_layout()
+
+    return fig, (ax, ax_kde)

hillclimber/biases.py

@@ -29,17 +29,17 @@ class RestraintBias(BiasProtocol):
     cv : CollectiveVariable
         The collective variable to restrain.
     kappa : float
-        The force constant of the restraint in kJ/(mol·unit^2), where unit
-        depends on the CV (e.g., Å for distances, radians for angles).
+        The force constant of the restraint in eV/unit^2, where unit
+        depends on the CV (e.g., eV/Ų for distances, eV/rad² for angles).
     at : float
-        The center/target value of the restraint.
+        The center/target value of the restraint in CV units (e.g., Å for distances).
     label : str, optional
         A custom label for this restraint. If not provided, uses cv.prefix + "_restraint".
 
     Examples
     --------
     >>> import hillclimber as hc
-    >>> # Restrain a distance around 2.5 Å
+    >>> # Restrain a distance around 2.5 Šwith force constant 200 eV/Ų
     >>> distance_cv = hc.DistanceCV(...)
     >>> restraint = hc.RestraintBias(cv=distance_cv, kappa=200.0, at=2.5)
 
@@ -49,10 +49,10 @@ class RestraintBias(BiasProtocol):
 
     Notes
     -----
-    The force constant kappa is in kJ/(mol·unit^2). For typical CV units:
-    - Distances (Å): kappa in kJ/(mol·Å^2)
-    - Angles (radians): kappa in kJ/(mol·rad^2)
-    - Dimensionless CVs: kappa in kJ/mol
+    Due to the UNITS line, kappa is in eV/unit^2 (ASE energy units). For typical CVs:
+    - Distances (Å): kappa in eV/Ų
+    - Angles (radians): kappa in eV/rad²
+    - Dimensionless CVs: kappa in eV
 
     The restraint creates a bias force: F = -kappa * (s - at)
     """
@@ -109,9 +109,9 @@ class UpperWallBias(BiasProtocol):
     cv : CollectiveVariable
         The collective variable to apply the wall to.
     at : float
-        The position of the wall (threshold value).
+        The position of the wall (threshold value) in CV units.
     kappa : float
-        The force constant of the wall in kJ/mol.
+        The force constant of the wall in eV.
     exp : int, optional
         The exponent of the wall potential. Default is 2 (harmonic).
         Higher values create steeper walls.
@@ -125,7 +125,7 @@ class UpperWallBias(BiasProtocol):
     Examples
     --------
     >>> import hillclimber as hc
-    >>> # Prevent distance from exceeding 3.0 Å
+    >>> # Prevent distance from exceeding 3.0 Å with force constant 100 eV
     >>> distance_cv = hc.DistanceCV(...)
     >>> upper_wall = hc.UpperWallBias(cv=distance_cv, at=3.0, kappa=100.0, exp=2)
 
@@ -209,9 +209,9 @@ class LowerWallBias(BiasProtocol):
     cv : CollectiveVariable
         The collective variable to apply the wall to.
     at : float
-        The position of the wall (threshold value).
+        The position of the wall (threshold value) in CV units.
     kappa : float
-        The force constant of the wall in kJ/mol.
+        The force constant of the wall in eV.
     exp : int, optional
         The exponent of the wall potential. Default is 2 (harmonic).
         Higher values create steeper walls.
@@ -225,7 +225,7 @@ class LowerWallBias(BiasProtocol):
     Examples
     --------
     >>> import hillclimber as hc
-    >>> # Prevent distance from going below 1.0 Å
+    >>> # Prevent distance from going below 1.0 Å with force constant 100 eV
     >>> distance_cv = hc.DistanceCV(...)
     >>> lower_wall = hc.LowerWallBias(cv=distance_cv, at=1.0, kappa=100.0, exp=2)
 

hillclimber/cvs.py

@@ -21,7 +21,6 @@ from hillclimber.virtual_atoms import VirtualAtom
 GroupReductionStrategyType = Literal[
     "com", "cog", "first", "all", "com_per_group", "cog_per_group"
 ]
-MultiGroupStrategyType = Literal["first", "all_pairs", "corresponding", "first_to_all"]
 SiteIdentifier = Union[str, List[int]]
 ColorTuple = Tuple[float, float, float]
 AtomHighlightMap = Dict[int, ColorTuple]
@@ -132,22 +131,6 @@ class _BasePlumedCV(CollectiveVariable):
             if cv_keyword in cmd and cmd.strip().startswith((prefix, f"{prefix}_"))
         ]
 
-    @staticmethod
-    def _get_index_pairs(
-        len1: int, len2: int, strategy: MultiGroupStrategyType
-    ) -> List[Tuple[int, int]]:
-        """Determines pairs of group indices based on the multi-group strategy."""
-        if strategy == "first":
-            return [(0, 0)] if len1 > 0 and len2 > 0 else []
-        if strategy == "all_pairs":
-            return [(i, j) for i in range(len1) for j in range(len2)]
-        if strategy == "corresponding":
-            n = min(len1, len2)
-            return [(i, i) for i in range(n)]
-        if strategy == "first_to_all":
-            return [(0, j) for j in range(len2)] if len1 > 0 else []
-        raise ValueError(f"Unknown multi-group strategy: {strategy}")
-
     @staticmethod
     def _create_virtual_site_command(
         group: List[int], strategy: Literal["com", "cog"], label: str
@@ -901,18 +884,25 @@ class TorsionCV(_BasePlumedCV):
     Calculates the torsional (dihedral) angle defined by four atoms. Each group
     provided by the selector must contain exactly four atoms.
 
-    Attributes:
-        atoms: Selector for one or more groups of 4 atoms.
-        prefix: Label prefix for the generated PLUMED commands.
-        multi_group: Strategy for handling multiple groups from the selector.
+    Parameters
+    ----------
+    atoms : AtomSelector
+        Selector for one or more groups of 4 atoms. Each group must contain exactly 4 atoms.
+    prefix : str
+        Label prefix for the generated PLUMED commands.
+    strategy : {"first", "all"}, default="first"
+        Strategy for handling multiple groups from the selector:
+        - "first": Process only the first group (creates 1 CV)
+        - "all": Process all groups independently (creates N CVs)
 
-    Resources:
-        - https://www.plumed.org/doc-master/user-doc/html/TORSION
+    Resources
+    ---------
+    - https://www.plumed.org/doc-master/user-doc/html/TORSION
     """
 
     atoms: AtomSelector
     prefix: str
-    multi_group: MultiGroupStrategyType = "first"
+    strategy: Literal["first", "all"] = "first"
 
     def _get_atom_highlights(
         self, atoms: Atoms, **kwargs
@@ -955,10 +945,10 @@ class TorsionCV(_BasePlumedCV):
 
     def _generate_commands(self, groups: List[List[int]]) -> List[str]:
         """Generates all necessary PLUMED commands."""
-        # For torsions, 'multi_group' determines how many groups to process.
-        if self.multi_group in ["first", "first_to_all"] and groups:
+        # Determine which groups to process based on strategy
+        if self.strategy == "first" and groups:
             indices_to_process = [0]
-        else:  # "all_pairs" and "corresponding" imply processing all independent groups.
+        else:  # "all" - process all groups independently
             indices_to_process = list(range(len(groups)))
 
         commands = []
@@ -978,19 +968,33 @@ class RadiusOfGyrationCV(_BasePlumedCV):
     Calculates the radius of gyration of a group of atoms. The radius of gyration
     is a measure of the size of a molecular system.
 
-    Attributes:
-        atoms: Selector for the atoms to include in the gyration calculation.
-        prefix: Label prefix for the generated PLUMED commands.
-        multi_group: Strategy for handling multiple groups from the selector.
-        type: The type of gyration tensor to use ("RADIUS" for scalar Rg, "GTPC_1", etc.)
+    Parameters
+    ----------
+    atoms : AtomSelector
+        Selector for the atoms to include in the gyration calculation.
+    prefix : str
+        Label prefix for the generated PLUMED commands.
+    flatten : bool, default=False
+        How to handle multiple groups from the selector:
+        - True: Combine all groups into one and calculate single Rg (creates 1 CV)
+        - False: Keep groups separate, use strategy to determine which to process
+    strategy : {"first", "all"}, default="first"
+        Strategy for handling multiple groups when flatten=False:
+        - "first": Process only the first group (creates 1 CV)
+        - "all": Process all groups independently (creates N CVs)
+    type : str, default="RADIUS"
+        The type of gyration tensor to use.
+        Options: "RADIUS", "GTPC_1", "GTPC_2", "GTPC_3", "ASPHERICITY", "ACYLINDRICITY", "KAPPA2", etc.
 
-    Resources:
-        - https://www.plumed.org/doc-master/user-doc/html/GYRATION/
+    Resources
+    ---------
+    - https://www.plumed.org/doc-master/user-doc/html/GYRATION/
     """
 
     atoms: AtomSelector
     prefix: str
-    multi_group: MultiGroupStrategyType = "first"
+    flatten: bool = False
+    strategy: Literal["first", "all"] = "first"
     type: str = "RADIUS"  # Options: RADIUS, GTPC_1, GTPC_2, GTPC_3, ASPHERICITY, ACYLINDRICITY, KAPPA2, etc.
 
     def _get_atom_highlights(
@@ -1021,18 +1025,29 @@ class RadiusOfGyrationCV(_BasePlumedCV):
 
     def _generate_commands(self, groups: List[List[int]]) -> List[str]:
         """Generates all necessary PLUMED commands."""
-        # For gyration, 'multi_group' determines how many groups to process.
-        if self.multi_group in ["first", "first_to_all"] and groups:
-            indices_to_process = [0]
-        else:  # "all_pairs" and "corresponding" imply processing all independent groups.
-            indices_to_process = list(range(len(groups)))
-
         commands = []
-        for i in indices_to_process:
-            label = self.prefix if len(indices_to_process) == 1 else f"{self.prefix}_{i}"
-            atom_list = ",".join(str(idx + 1) for idx in groups[i])
-            command = f"{label}: GYRATION ATOMS={atom_list}"
+
+        if self.flatten:
+            # Combine all groups into single atom list
+            flat_atoms = [idx for group in groups for idx in group]
+            atom_list = ",".join(str(idx + 1) for idx in flat_atoms)
+            command = f"{self.prefix}: GYRATION ATOMS={atom_list}"
             if self.type != "RADIUS":
                 command += f" TYPE={self.type}"
             commands.append(command)
+        else:
+            # Keep groups separate and use strategy to determine which to process
+            if self.strategy == "first" and groups:
+                indices_to_process = [0]
+            else:  # "all" - process all groups independently
+                indices_to_process = list(range(len(groups)))
+
+            for i in indices_to_process:
+                label = self.prefix if len(indices_to_process) == 1 else f"{self.prefix}_{i}"
+                atom_list = ",".join(str(idx + 1) for idx in groups[i])
+                command = f"{label}: GYRATION ATOMS={atom_list}"
+                if self.type != "RADIUS":
+                    command += f" TYPE={self.type}"
+                commands.append(command)
+
         return commands

hillclimber/metadynamics.py

@@ -1,4 +1,5 @@
 import dataclasses
+import typing as t
 from pathlib import Path
 
 import ase.units
@@ -21,11 +22,14 @@ class MetadBias:
     cv : CollectiveVariable
         The collective variable to bias.
     sigma : float, optional
-        The width of the Gaussian potential, by default None.
+        The width of the Gaussian potential in the same units as the CV
+        (e.g., Å for distances, radians for angles), by default None.
     grid_min : float | str, optional
-        The minimum value of the grid, by default None.
+        The minimum value of the grid in CV units (or PLUMED expression like "-pi"),
+        by default None.
     grid_max : float | str, optional
-        The maximum value of the grid, by default None.
+        The maximum value of the grid in CV units (or PLUMED expression like "pi"),
+        by default None.
     grid_bin : int, optional
         The number of bins in the grid, by default None.
 
@@ -47,22 +51,32 @@ class MetaDynamicsConfig:
 
     This contains only the global parameters that apply to all CVs.
 
+    Units
+    -----
+    hillclimber uses ASE units throughout. The UNITS line in the PLUMED input tells
+    PLUMED to interpret all values in ASE units:
+    - Distances: Ångström (Å)
+    - Energies: electronvolt (eV) - including HEIGHT, SIGMA for energy-based CVs, etc.
+    - Time: femtoseconds (fs)
+    - Temperature: Kelvin (K)
+
     Parameters
     ----------
     height : float, optional
-        The height of the Gaussian potential in kJ/mol, by default 1.0.
+        The height of the Gaussian potential in eV, by default 1.0.
     pace : int, optional
-        The frequency of Gaussian deposition, by default 500.
+        The frequency of Gaussian deposition in MD steps, by default 500.
     biasfactor : float, optional
         The bias factor for well-tempered metadynamics, by default None.
     temp : float, optional
         The temperature of the system in Kelvin, by default 300.0.
     file : str, optional
         The name of the hills file, by default "HILLS".
-    adaptive : str, optional
-        The adaptive scheme to use, by default "NONE".
+    adaptive : t.Literal["GEOM", "DIFF"] | None, optional
+        The adaptive scheme to use, by default None.
+        If None, no ADAPTIVE parameter is written to PLUMED.
     flush : int | None
-        The frequency of flushing the output files. 
+        The frequency of flushing the output files in MD steps.
         If None, uses the plumed default.
 
     Resources
@@ -76,7 +90,7 @@ class MetaDynamicsConfig:
     biasfactor: float | None = None
     temp: float = 300.0
     file: str = "HILLS"
-    adaptive: str = "NONE"  # NONE, DIFF, GEOM
+    adaptive: t.Literal["GEOM", "DIFF"] | None = None
     flush: int | None = None
 
 
@@ -187,8 +201,13 @@ class MetaDynamicsModel(zntrack.Node, NodeWithCalculator):
 
         sigmas, grid_mins, grid_maxs, grid_bins = [], [], [], []
 
+        # PLUMED UNITS line specifies conversion factors from ASE units to PLUMED's native units:
+        # - LENGTH=A: ASE uses Ångström (A), PLUMED native is nm → A is a valid PLUMED unit
+        # - TIME: ASE uses fs, PLUMED native is ps → 1 fs = 0.001 ps
+        # - ENERGY: ASE uses eV, PLUMED native is kJ/mol → 1 eV = 96.485 kJ/mol
+        # See: https://www.plumed.org/doc-master/user-doc/html/ (MD engine integration docs)
         plumed_lines.append(
-            f"UNITS LENGTH=A TIME={1 / (1000 * ase.units.fs)} ENERGY={ase.units.mol / ase.units.kJ}"
+            f"UNITS LENGTH=A TIME={1/1000} ENERGY={ase.units.mol / ase.units.kJ}"
         )
 
         for bias_cv in self.bias_cvs:
@@ -196,17 +215,20 @@ class MetaDynamicsModel(zntrack.Node, NodeWithCalculator):
             plumed_lines.extend(cv_str)
             all_labels.extend(labels)
 
-            # Collect per-CV parameters for later
-            sigmas.append(str(bias_cv.sigma) if bias_cv.sigma is not None else None)
-            grid_mins.append(
-                str(bias_cv.grid_min) if bias_cv.grid_min is not None else None
-            )
-            grid_maxs.append(
-                str(bias_cv.grid_max) if bias_cv.grid_max is not None else None
-            )
-            grid_bins.append(
-                str(bias_cv.grid_bin) if bias_cv.grid_bin is not None else None
-            )
+            # Collect per-CV parameters for later - repeat for each label
+            # PLUMED requires one parameter value per ARG, so if a CV generates
+            # multiple labels, we need to repeat the parameter values
+            for _ in labels:
+                sigmas.append(str(bias_cv.sigma) if bias_cv.sigma is not None else None)
+                grid_mins.append(
+                    str(bias_cv.grid_min) if bias_cv.grid_min is not None else None
+                )
+                grid_maxs.append(
+                    str(bias_cv.grid_max) if bias_cv.grid_max is not None else None
+                )
+                grid_bins.append(
+                    str(bias_cv.grid_bin) if bias_cv.grid_bin is not None else None
+                )
 
         metad_parts = [
             "METAD",
@@ -215,16 +237,31 @@ class MetaDynamicsModel(zntrack.Node, NodeWithCalculator):
             f"PACE={self.config.pace}",
             f"TEMP={self.config.temp}",
             f"FILE={self.config.file}",
-            f"ADAPTIVE={self.config.adaptive}",
         ]
+        if self.config.adaptive is not None:
+            metad_parts.append(f"ADAPTIVE={self.config.adaptive}")
         if self.config.biasfactor is not None:
             metad_parts.append(f"BIASFACTOR={self.config.biasfactor}")
 
         # Add SIGMA, GRID_MIN, GRID_MAX, GRID_BIN only if any value is set
         if any(v is not None for v in sigmas):
-            metad_parts.append(
-                f"SIGMA={','.join(v if v is not None else '0.0' for v in sigmas)}"
-            )
+            # When using ADAPTIVE, PLUMED requires only one sigma value
+            if self.config.adaptive is not None:
+                # Validate that all sigma values are the same when adaptive is set
+                unique_sigmas = set(v for v in sigmas if v is not None)
+                if len(unique_sigmas) > 1:
+                    raise ValueError(
+                        f"When using ADAPTIVE={self.config.adaptive}, all CVs must have the same sigma value. "
+                        f"Found different sigma values: {unique_sigmas}"
+                    )
+                # Use the first non-None sigma value
+                sigma_value = next(v for v in sigmas if v is not None)
+                metad_parts.append(f"SIGMA={sigma_value}")
+            else:
+                # Standard mode: one sigma per CV
+                metad_parts.append(
+                    f"SIGMA={','.join(v if v is not None else '0.0' for v in sigmas)}"
+                )
         if any(v is not None for v in grid_mins):
             metad_parts.append(
                 f"GRID_MIN={','.join(v if v is not None else '0.0' for v in grid_mins)}"
@@ -240,10 +277,47 @@ class MetaDynamicsModel(zntrack.Node, NodeWithCalculator):
 
         plumed_lines.append(f"metad: {' '.join(metad_parts)}")
 
+        # Track defined commands to detect duplicates and conflicts
+        # Map label -> full command for labeled commands (e.g., "d: DISTANCE ...")
+        defined_commands = {}
+        for line in plumed_lines:
+            # Check if this is a labeled command (format: "label: ACTION ...")
+            if ": " in line:
+                label = line.split(": ", 1)[0]
+                defined_commands[label] = line
+
         # Add any additional actions (restraints, walls, print actions, etc.)
         for action in self.actions:
             action_lines = action.to_plumed(atoms)
-            plumed_lines.extend(action_lines)
+
+            # Filter out duplicate CV definitions, but detect conflicts
+            filtered_lines = []
+            for line in action_lines:
+                # Check if this is a labeled command
+                if ": " in line:
+                    label = line.split(": ", 1)[0]
+
+                    # Check if this label was already defined
+                    if label in defined_commands:
+                        # If the command is identical, skip (deduplication)
+                        if defined_commands[label] == line:
+                            continue
+                        # If the command is different, raise error (conflict)
+                        else:
+                            raise ValueError(
+                                f"Conflicting definitions for label '{label}':\n"
+                                f"  Already defined: {defined_commands[label]}\n"
+                                f"  New definition:  {line}"
+                            )
+                    else:
+                        # New labeled command, track it
+                        defined_commands[label] = line
+                        filtered_lines.append(line)
+                else:
+                    # Unlabeled command, always add
+                    filtered_lines.append(line)
+
+            plumed_lines.extend(filtered_lines)
 
         # Add FLUSH if configured
         if self.config.flush is not None:

hillclimber/opes.py

@@ -27,8 +27,9 @@ class OPESBias:
     cv : CollectiveVariable
         The collective variable to bias.
     sigma : float | str, optional
-        Initial kernel width. Use "ADAPTIVE" for automatic adaptation
-        (recommended). If numeric, specifies the initial width.
+        Initial kernel width in CV units (e.g., Å for distances, radians for angles).
+        Use "ADAPTIVE" for automatic adaptation (recommended).
+        If numeric, specifies the initial width.
         Default: "ADAPTIVE".
 
     Resources
@@ -53,10 +54,19 @@ class OPESConfig:
     OPES (On-the-fly Probability Enhanced Sampling) is a modern enhanced
     sampling method that samples well-tempered target distributions.
 
+    Units
+    -----
+    hillclimber uses ASE units throughout. The UNITS line in the PLUMED input tells
+    PLUMED to interpret all values in ASE units:
+    - Distances: Ångström (Å)
+    - Energies: electronvolt (eV) - including BARRIER, SIGMA_MIN, etc.
+    - Time: femtoseconds (fs)
+    - Temperature: Kelvin (K)
+
     Parameters
     ----------
     barrier : float
-        Highest free energy barrier to overcome (kJ/mol). This is the key
+        Highest free energy barrier to overcome (eV). This is the key
         parameter that determines sampling efficiency.
     pace : int, optional
         Frequency of kernel deposition in MD steps (default: 500).
@@ -75,9 +85,9 @@ class OPESConfig:
     file : str, optional
         File to store deposited kernels (default: "KERNELS").
     adaptive_sigma_stride : int, optional
-        Steps between adaptive sigma measurements. If not set, uses 10×PACE.
+        MD steps between adaptive sigma measurements. If not set, uses 10×PACE.
     sigma_min : float, optional
-        Minimum allowable sigma value for adaptive sigma.
+        Minimum allowable sigma value for adaptive sigma in CV units.
     state_wfile : str, optional
         State file for writing exact restart information.
     state_rfile : str, optional
@@ -89,7 +99,7 @@ class OPESConfig:
     calc_work : bool, optional
         Calculate and output accumulated work (default: False).
     flush : int, optional
-        Frequency of flushing output files.
+        Frequency of flushing output files in MD steps.
 
     Resources
     ---------
@@ -272,8 +282,13 @@ class OPESModel(zntrack.Node, NodeWithCalculator):
 
         sigmas = []
 
+        # PLUMED UNITS line specifies conversion factors from ASE units to PLUMED's native units:
+        # - LENGTH=A: ASE uses Ångström (A), PLUMED native is nm → A is a valid PLUMED unit
+        # - TIME: ASE uses fs, PLUMED native is ps → 1 fs = 0.001 ps
+        # - ENERGY: ASE uses eV, PLUMED native is kJ/mol → 1 eV = 96.485 kJ/mol
+        # See: https://www.plumed.org/doc-master/user-doc/html/ (MD engine integration docs)
         plumed_lines.append(
-            f"UNITS LENGTH=A TIME={1 / (1000 * ase.units.fs)} ENERGY={ase.units.mol / ase.units.kJ}"
+            f"UNITS LENGTH=A TIME={1/1000} ENERGY={ase.units.mol / ase.units.kJ}"
         )
 
         for bias_cv in self.bias_cvs:

{hillclimber-0.1.0a2.dist-info → hillclimber-0.1.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hillclimber
-Version: 0.1.0a2
+Version: 0.1.0a3
 Summary: Python interfaces for the plumed library with enhanced sampling.
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -124,6 +124,64 @@ with project:
 project.build()
 ```
 
+## Units
+
+hillclimber uses **ASE units** throughout the package:
+
+- **Distances**: Ångström (Å)
+- **Energies**: electronvolt (eV)
+- **Time**: femtoseconds (fs)
+- **Temperature**: Kelvin (K)
+- **Mass**: atomic mass units (amu)
+
+### Unit Conversion with PLUMED
+
+PLUMED internally uses different units (nm, kJ/mol, ps). hillclimber automatically handles the conversion by adding a `UNITS` line to the PLUMED input:
+
+```
+UNITS LENGTH=A TIME=0.001 ENERGY=96.48533288249877
+```
+
+This tells PLUMED to interpret all input parameters in ASE units:
+- `LENGTH=A`: Distances are in Ångström
+- `TIME=0.001`: Time values are in fs (1 fs = 0.001 ps)
+- `ENERGY=96.485`: Energies are in eV (1 eV = 96.485 kJ/mol)
+
+**All PLUMED parameters (HEIGHT, BARRIER, KAPPA, SIGMA, etc.) should be specified in ASE units (eV, Å, fs).** The UNITS line ensures PLUMED interprets them correctly.
+
+### Example with Units
+
+```python
+config = hc.MetaDynamicsConfig(
+    height=0.5,        # eV - Gaussian hill height
+    pace=150,          # MD steps - deposition frequency
+    biasfactor=10.0,   # Dimensionless - well-tempered factor
+    temp=300.0         # Kelvin - system temperature
+)
+
+bias = hc.MetadBias(
+    cv=distance_cv,
+    sigma=0.1,         # Å - Gaussian width for distance CV
+    grid_min=0.0,      # Å - minimum grid value
+    grid_max=5.0,      # Å - maximum grid value
+    grid_bin=100       # Number of bins
+)
+
+# Restraint example
+restraint = hc.RestraintBias(
+    cv=distance_cv,
+    kappa=200.0,       # eV/Ų - force constant
+    at=2.5             # Å - restraint center
+)
+
+metad_model = hc.MetaDynamicsModel(
+    config=config,
+    bias_cvs=[bias],
+    actions=[restraint],
+    timestep=0.5       # fs - MD timestep
+)
+```
+
 ## Collective Variables
 
 hillclimber supports multiple types of collective variables:

hillclimber-0.1.0a3.dist-info/RECORD

@@ -0,0 +1,17 @@
+hillclimber/__init__.py,sha256=OoxVZ1pPvRVHY1VVShDBaEGIF06O5fDFxCSGUNGW3m4,1041
+hillclimber/actions.py,sha256=7s78RWP-YnBbbxZyA65OwnyL60v8LnKHyNalui1ypAo,1514
+hillclimber/analysis.py,sha256=2KrlSVRNdajZBFCm8AZBjTixTeZczbu5ya4laLXEZP0,20674
+hillclimber/biases.py,sha256=TbEM19NUOuaTUchzEGNIM8M4TDmtlE5Ss8e9VBbHr5s,9448
+hillclimber/calc.py,sha256=dqanaBF6BJwP6lHQqFqEIng-3bTN_DcddRV-gceboKs,665
+hillclimber/cvs.py,sha256=AWC7Z3h0CyAO7_wq-WdLhNi3spH456Blik60_M99MDA,39934
+hillclimber/interfaces.py,sha256=H4HKN1HldhNJeooqtS-HpJLrCFqpMPr80aPER4SKiao,3807
+hillclimber/metadynamics.py,sha256=1Kn5VhlrGlcVY9g41dNCEbJX-7j5ZEStcM8UGgTkCfI,12636
+hillclimber/nodes.py,sha256=XL9uEXd2HdW2mlbwriG_fMCkZAaz4uZBOI5edO42YDA,145
+hillclimber/opes.py,sha256=F_1daa9xB-wsNyow6sIfxJG2nyOSyCc-vVRuP5ADWdE,13310
+hillclimber/selectors.py,sha256=VoWMvTnKU9vr0dphqxGk1OdhrabbDkzq4GQkeprd6RQ,7931
+hillclimber/virtual_atoms.py,sha256=GVXCJZlbx1cY_ST2G5NHQsGpdMkBLUz04aFm-cD--OA,12270
+hillclimber-0.1.0a3.dist-info/METADATA,sha256=UOw07yd2AJiq8CY2a3myuqS9Udy8y_1nb6gMcHNd0QA,12980
+hillclimber-0.1.0a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hillclimber-0.1.0a3.dist-info/entry_points.txt,sha256=RsCL3TDKfieatIWP9JHjmTzMtgWERqwpuuuDPdQ4t5g,124
+hillclimber-0.1.0a3.dist-info/licenses/LICENSE,sha256=FKf4VPZYbuyRVMVSrl6HO48bnw6ih8Uur5y-h_MJAcA,13576
+hillclimber-0.1.0a3.dist-info/RECORD,,

hillclimber-0.1.0a2.dist-info/RECORD

@@ -1,16 +0,0 @@
-hillclimber/__init__.py,sha256=MpTyTiou1ACRu6snlCe3Aja3_znqakX-YPV1notCdvA,901
-hillclimber/actions.py,sha256=7s78RWP-YnBbbxZyA65OwnyL60v8LnKHyNalui1ypAo,1514
-hillclimber/biases.py,sha256=OfqKdGNiN2Yk4tP03nzJ9vxBWLjLRvcjgJAS8gZeFHw,9317
-hillclimber/calc.py,sha256=dqanaBF6BJwP6lHQqFqEIng-3bTN_DcddRV-gceboKs,665
-hillclimber/cvs.py,sha256=ag1gr51D1-NJb7tkdeUQdjYfWy0WBfcMQKE1f-thFAQ,39548
-hillclimber/interfaces.py,sha256=H4HKN1HldhNJeooqtS-HpJLrCFqpMPr80aPER4SKiao,3807
-hillclimber/metadynamics.py,sha256=NwNG5THSjmJInBDLFuIKp3cB8P-kE8BAaftZdnSk9J0,8719
-hillclimber/nodes.py,sha256=XL9uEXd2HdW2mlbwriG_fMCkZAaz4uZBOI5edO42YDA,145
-hillclimber/opes.py,sha256=NYY2zcBtBxXrFcWQKplrIkthgnW03WTh4hi9MtDsXqo,12483
-hillclimber/selectors.py,sha256=VoWMvTnKU9vr0dphqxGk1OdhrabbDkzq4GQkeprd6RQ,7931
-hillclimber/virtual_atoms.py,sha256=GVXCJZlbx1cY_ST2G5NHQsGpdMkBLUz04aFm-cD--OA,12270
-hillclimber-0.1.0a2.dist-info/METADATA,sha256=JZgeoAZPviWVz59IgjQsoWYnNuFoXbzIg-vJJDOxcTU,11254
-hillclimber-0.1.0a2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hillclimber-0.1.0a2.dist-info/entry_points.txt,sha256=RsCL3TDKfieatIWP9JHjmTzMtgWERqwpuuuDPdQ4t5g,124
-hillclimber-0.1.0a2.dist-info/licenses/LICENSE,sha256=FKf4VPZYbuyRVMVSrl6HO48bnw6ih8Uur5y-h_MJAcA,13576
-hillclimber-0.1.0a2.dist-info/RECORD,,