nonbond 0.1.0__py3-none-any.whl

nonbond/__init__.py

@@ -0,0 +1,13 @@
+"""
+Nonbond - ASE Calculator for Lennard-Jones + Point Charge interactions
+"""
+
+from .calculator import Nonbond
+from .coul import CoulombCalculator
+from .lj import LJCalculator
+
+__all__ = [
+    'Nonbond',
+    'CoulombCalculator',
+    'LJCalculator'
+]

nonbond/calculator.py

@@ -0,0 +1,190 @@
+import numpy as np
+from ase.calculators.calculator import Calculator, all_changes
+from ase.units import mol, kcal, eV
+
+import torch
+from vesin.torch import NeighborList
+
+from .lj import LJCalculator
+from .coul import CoulombCalculator
+
+# Coulomb constant in eV*Å/e²
+COULOMB_CONSTANT = 14.399644853
+
+
+class Nonbond(Calculator):
+    """
+    ASE Calculator for Lennard-Jones + Coulomb interactions
+
+    The total potential energy is:
+    E_total = E_LJ + E_coulomb
+
+    Where:
+    E_LJ = sum_i<j 4*epsilon_ij * [(sigma_ij/r_ij)^12 - (sigma_ij/r_ij)^6]
+    E_coulomb = sum_i<j k * q_i * q_j / r_ij
+
+    Mixing rules (Lorentz-Berthelot):
+    epsilon_ij = sqrt(epsilon_i * epsilon_j)
+    sigma_ij = (sigma_i + sigma_j) / 2
+
+    Parameters:
+    -----------
+    sigma : dict
+        LJ sigma parameters by atom type (Å)
+        Format: {'H': 2.51, 'O': 3.12}
+
+    epsilon : dict  
+        LJ epsilon parameters by atom type (kcal/mol)
+        Format: {'H': 0.044, 'O': 0.126}
+
+    rc : float, optional
+        Cutoff distance for both LJ and Coulomb interactions (Å)
+        Default: 3 * max(sigma) or 10.0 Å
+
+    charge_method : str, optional
+        Method for Coulomb interaction calculation ('direct', 'ewald', 'pme', 'p3m')
+        Default: None
+
+    accuracy : float, optional
+        Accuracy for Long-Range Coulomb Interaction
+        Default: 1e-5
+
+    device : str, optional
+        Device for calculations ('cpu' or 'cuda')
+        Default: 'cpu'
+    """
+
+    implemented_properties = [
+        "energy",
+        "energies",
+    ]
+
+    def __init__(
+        self,
+        epsilon: dict,
+        sigma: dict,
+        rc: float = 10.0,
+        charge_method: str = None,
+        accuracy: float = 1e-5,
+        device: str = 'cpu',
+    ):
+
+        kwargs = {
+            'epsilon': epsilon,
+            'sigma': sigma,
+            'rc': rc,
+            'charge_method': charge_method,
+            'accuracy': accuracy,
+            'device': device,
+            'dtype': torch.float64,
+        }
+        Calculator.__init__(self, **kwargs)
+
+        # Initialize neighbor lists
+        self.neighbor_indices, self.neighbor_distances = None, None
+
+        # Cache for parameters
+        self.atom_types = None
+        self.sigmas = None
+        self.epsilons = None
+        self.charges = None
+        self.atoms = None
+        self.positions = None
+        self.cell = None
+
+    def calculate(self,
+                  atoms=None,
+                  properties=None,
+                  system_changes=all_changes):
+        """Calculate energy"""
+
+        if properties is None:
+            properties = self.implemented_properties
+
+        Calculator.calculate(self, atoms, properties, system_changes)
+
+        # ro = self.parameters.ro
+        # smooth = self.parameters.smooth
+
+        # Get atom types, 用以分配LJ参数
+
+        self.atoms = atoms
+        self._update_parameters()
+
+        self._update_neighbor_list()
+
+        energy, energies = self._calculate_energy()
+
+        self.results['energy'] = energy
+        self.results['energies'] = energies
+
+    # 构建邻接列表
+    def _update_neighbor_list(self):
+        nl = NeighborList(cutoff=self.parameters.rc, full_list=False)
+        self.neighbor_indices, self.neighbor_distances = nl.compute(
+            points=self.positions,
+            box=self.cell,
+            periodic=True,
+            quantities="Pd")
+
+    def _calculate_energy(self):
+
+        energy = 0.0
+        energy_lj = 0.0
+        energy_coulomb = 0.0
+
+        # Calculate LJ interactions (always calculated)
+        lj_calc = LJCalculator(cutoff=self.parameters.rc, )
+        energy_lj, energies_lj = lj_calc.get_lj_energy(self.neighbor_indices,
+                                                       self.neighbor_distances,
+                                                       self.epsilons, self.sigmas)
+
+        # Calculate Coulomb interactions (if charges are provided)
+        if self.parameters.charge_method is not None:
+            coulomb_calc = CoulombCalculator(
+                method=self.parameters.charge_method,
+                cutoff=self.parameters.rc,
+                accuracy=self.parameters.accuracy,
+                device=self.parameters.device,
+                dtype=self.parameters.dtype)
+            energy_coulomb, energies_coulomb = coulomb_calc.get_coul_energy(
+                self.neighbor_indices, self.neighbor_distances, self.positions, self.cell, self.charges)
+        else:
+            energy_coulomb = 0.0
+            energies_coulomb = torch.zeros_like(energies_lj)
+
+        energy = energy_lj + energy_coulomb
+        energies = energies_lj + energies_coulomb
+
+        return energy, energies
+
+    def _update_parameters(self):
+        """Update cached parameters for current system"""
+
+        # atom types
+        try:
+            self.atom_types = self.atoms.get_array('type')
+        except KeyError:
+            self.atom_types = self.atoms.get_chemical_symbols()
+
+        # Convert energy units from kcal/mol to eV
+        convert_factor = kcal / mol / eV
+        atom_types = self.atom_types
+        self.sigmas = np.array(
+            [self.parameters.sigma[atom_type] for atom_type in atom_types])
+        self.epsilons = np.array([
+            self.parameters.epsilon[atom_type] * convert_factor
+            for atom_type in atom_types
+        ])
+
+        dtype = self.parameters.dtype
+        device = self.parameters.device
+        self.positions = torch.tensor(self.atoms.positions,
+                                      dtype=dtype,
+                                      device=device,
+                                      requires_grad=True)
+        self.cell = torch.tensor(self.atoms.cell.array,
+                                 dtype=dtype,
+                                 device=device)
+        self.charges = torch.tensor(
+            self.atoms.get_initial_charges(), dtype=dtype, device=device).unsqueeze(1)

nonbond/coul.py

@@ -0,0 +1,156 @@
+from torchpme.tuning import tune_ewald, tune_pme, tune_p3m
+import torchpme
+import torch
+from torchpme.prefactors import eV_A
+
+class CoulombCalculator:
+    """
+    Coulomb Calculator
+    """
+    
+    def __init__(self, 
+                 method: str = 'direct',
+                 cutoff: float = 10.0,
+                 accuracy: float = 1e-5,
+                 device: str = 'cpu',
+                 dtype: torch.dtype = torch.float64,
+                 ):
+
+        self.method = method.lower()
+        self.cutoff = cutoff
+        self.accuracy = accuracy
+        self.device = device
+        self.dtype = dtype
+
+        # 验证方法
+        valid_methods = ['direct', 'ewald', 'pme', 'p3m']
+        if self.method not in valid_methods:
+            raise ValueError(f"Unsupported method: {method}. Valid methods: {valid_methods}")
+
+        # 通用参数
+        self.neighbor_indices, self.neighbor_distances = None, None
+        self.positions = None
+        self.cell = None
+        self.charges = None
+        
+        #结果
+        self.energy = None
+        self.energies = None
+        # self.forces = None
+    
+    def get_coul_energy(self, 
+                        neighbor_indices: torch.Tensor, 
+                        neighbor_distances: torch.Tensor,
+                        positions: torch.Tensor,
+                        cell: torch.Tensor,
+                        charges: torch.Tensor,
+                        ) -> float:
+    
+        self.positions = positions
+        self.cell = cell
+        self.charges = charges
+
+        self.neighbor_indices, self.neighbor_distances = neighbor_indices, neighbor_distances
+        
+        if self.method == 'direct':
+            self._direct_coulomb()
+        else:
+            self._long_range_coulomb()
+           
+        return self.energy, self.energies
+    
+
+
+    def _optimize_params(self):
+        neighbor_indices, neighbor_distances = self.neighbor_indices, self.neighbor_distances
+        if self.method == 'ewald':
+            return tune_ewald(
+                charges=self.charges,
+                cell=self.cell,
+                positions=self.positions,
+                cutoff=self.cutoff,
+                accuracy=self.accuracy,
+                neighbor_indices=neighbor_indices,
+                neighbor_distances=neighbor_distances,
+            )
+        elif self.method == 'pme':
+            return tune_pme(
+                charges=self.charges,
+                cell=self.cell,
+                positions=self.positions,
+                cutoff=self.cutoff,
+                accuracy=self.accuracy,
+                neighbor_indices=neighbor_indices,
+                neighbor_distances=neighbor_distances,
+            )
+        elif self.method == 'p3m':
+            return tune_p3m(
+                charges=self.charges,
+                cell=self.cell,
+                positions=self.positions,
+                cutoff=self.cutoff,
+                accuracy=self.accuracy,
+                neighbor_indices=neighbor_indices,
+                neighbor_distances=neighbor_distances,
+            )
+        else:
+            raise RuntimeError("_optimize_params called for unsupported method")
+
+    
+    
+    def _long_range_coulomb(self) -> float:
+        """长程库伦相互作用计算 (带缓存)"""
+        smearing, params, _ = self._optimize_params()
+        prefactor = eV_A
+        if self.method == 'ewald':
+            base_calc = torchpme.EwaldCalculator(
+                potential=torchpme.CoulombPotential(smearing),
+                **params,
+                prefactor=prefactor
+            )
+        elif self.method == 'pme':
+            base_calc = torchpme.PMECalculator(
+                potential=torchpme.CoulombPotential(smearing),
+                **params,
+                prefactor=prefactor
+            )
+        elif self.method == 'p3m':
+            base_calc = torchpme.P3MCalculator(
+                potential=torchpme.CoulombPotential(smearing),
+                **params,
+                prefactor=prefactor
+            )
+        else:
+            raise RuntimeError("Unsupported method for long range")
+
+        calculator = base_calc
+        neighbor_indices, neighbor_distances = self.neighbor_indices, self.neighbor_distances
+        calculator.to(device=self.device, dtype=self.dtype)
+        potentials = calculator.forward(
+            self.charges, self.cell, self.positions, neighbor_indices, neighbor_distances
+        )
+        energies = self.charges * potentials
+        energy = torch.sum(energies)
+        # energy.backward()
+        # forces = -self.positions.grad
+        
+        self.energy = energy.item()
+        self.energies = energies
+        # self.forces = forces
+    
+    def _direct_coulomb(self):
+        COULOMB_CONSTANT = 14.399644853  # eV·Å/e²
+        neighbor_indices, neighbor_distances = self.neighbor_indices, self.neighbor_distances
+        qi = self.charges[neighbor_indices[:, 0]].flatten()
+        qj = self.charges[neighbor_indices[:, 1]].flatten()
+        rij = neighbor_distances.flatten()
+        # 避免除零
+        mask = rij > 1e-12
+        if not torch.all(mask):
+            qi = qi[mask]; qj = qj[mask]; rij = rij[mask]
+        energies = (COULOMB_CONSTANT * qi * qj / rij)
+        energy = energies.sum().item()
+        
+        self.energy = energy
+        self.energies = energies
+    

nonbond/lj.py

@@ -0,0 +1,38 @@
+
+import torch
+
+device = "cpu"
+dtype = torch.float64
+
+class LJCalculator:
+    def __init__(self, 
+                 cutoff: float = 10.0,
+                 ):
+        self.cutoff = cutoff
+
+    def get_lj_energy(self, neighbor_indices, neighbor_distances, epsilon, sigma):
+
+        if neighbor_indices.numel() == 0:
+            return 0.0
+
+        sigma_t = torch.as_tensor(sigma, device=device, dtype=dtype)
+        eps_t = torch.as_tensor(epsilon, device=device, dtype=dtype)
+
+        i_idx = neighbor_indices[:, 0].to(device=device)
+        j_idx = neighbor_indices[:, 1].to(device=device)
+        r = neighbor_distances.to(device=device, dtype=dtype)
+
+        sigma_ij = 0.5 * (sigma_t[i_idx] + sigma_t[j_idx])           
+        epsilon_ij = torch.sqrt(eps_t[i_idx] * eps_t[j_idx])         
+
+        # (sigma/r)^n 
+        inv_r = sigma_ij / r          # (sigma_ij / r)
+        inv_r2 = inv_r * inv_r
+        inv_r6 = inv_r2 * inv_r2 * inv_r2
+        inv_r12 = inv_r6 * inv_r6
+
+        pair_energy = 4.0 * epsilon_ij * (inv_r12 - inv_r6)  # (n_pairs,)
+        energies = pair_energy
+        energy = pair_energy.sum().item()
+
+        return energy, energies

nonbond-0.1.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: nonbond
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: ase>=3.26.0
+Requires-Dist: torch-pme>=0.3.2
+Requires-Dist: vesin-torch>=0.4.2
+
+# Nonbond
+
+**Nonbond** is an [ASE (Atomic Simulation Environment)](https://ase-lib.org/) calculator designed for computing **non-bonded interactions**.  
+Currently, it is primarily intended for use in specific contexts such as **GCMC simulations**, as it outputs only the **total energy** and **per-atom energies** (forces are not yet implemented).
+
+---
+
+## 🧩 Features
+
+- Lennard-Jones (LJ) potential energy calculations  
+- Efficient long-range Coulomb interaction algorithms  
+- Fast neighbor list construction using **PyTorch** and **vesin**  
+- **GPU acceleration** via PyTorch  
+
+---
+
+## 🧠 Requirements
+
+- Python ≥ 3.12  
+- ASE ≥ 3.26.0  
+- torch-pme ≥ 0.3.2  
+- vesin-torch ≥ 0.4.2  
+- PyTorch (latest stable version recommended)
+
+---
+
+## ⚙️ Installation
+
+Install via **pip**:
+
+```bash
+pip install nonbond
+```
+
+# 🚀 Example
+
+```python
+from ase import Atoms
+from nonbond import Nonbond
+import numpy as np
+
+# Define Lennard-Jones parameters for SPC/E water
+epsilon = {
+    'Ow': 0.15535,
+    'Hw': 0.0,
+}
+
+sigma = {
+    'Ow': 3.16600,
+    'Hw': 1.0,
+}
+
+# Create calculator
+calc = Nonbond(
+    epsilon=epsilon,
+    sigma=sigma,
+    rc=14.0,
+    charge_method='ewald',  # Options: 'direct', 'ewald', 'pme', 'p3m'
+    accuracy=1e-5
+)
+
+# Build an SPC/E water molecule
+atoms = Atoms(
+    'OH2',
+    positions=[
+        [0.00000, -0.06461, 0.00000],
+        [0.81649,  0.51275, 0.00000],
+        [-0.81649, 0.51275, 0.00000]
+    ],
+    cell=[40.0, 40.0, 40.0],
+    pbc=True
+)
+
+# Assign atom types and charges
+atoms.set_array('type', np.array(['Ow', 'Hw', 'Hw']))
+atoms.set_initial_charges([-0.8476, 0.4238, 0.4238])
+
+# Attach calculator and compute energy
+atoms.calc = calc
+energy = atoms.get_potential_energy()
+print(f"Potential energy: {energy:.6f} eV")
+```
+---
+
+# 📝 Notes
+
+- Only energy calculations are currently supported.
+- Force and stress tensor support will be added in future releases.
+

nonbond-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+nonbond/__init__.py,sha256=MZqV2Brs_6ohjkO8oBjASzz8Grx_NUfErJwI33tavL0,262
+nonbond/calculator.py,sha256=KX1iurQp11b0I5TE2JcX9Uvs9d3k_syuDH1vqBQ4J8I,6107
+nonbond/coul.py,sha256=c3liFeIw8jiRIxbtzhpd1YKEot4FI4AUykr_PmAn4g4,5503
+nonbond/lj.py,sha256=crth6CXB6EzMaKGNCCEITabqqt2fj3bk4SjcrGwNikw,1197
+nonbond-0.1.0.dist-info/METADATA,sha256=gqVAO4LLVuQ7QNJ4ZDTby16VHf0YtZZ6NuDYixV0BPE,2261
+nonbond-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nonbond-0.1.0.dist-info/top_level.txt,sha256=ZlwuJT3wNDOQLNA5qKQt5IroPCV_OOdeycss1Q0llAs,8
+nonbond-0.1.0.dist-info/RECORD,,

nonbond-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nonbond-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nonbond