mdinterface 1.0.0__tar.gz → 1.1.0__tar.gz

{mdinterface-1.0.0/mdinterface.egg-info → mdinterface-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mdinterface
-Version: 1.0.0
+Version: 1.1.0
 Summary: mdinterface: A package for building interface systems in Molecular Dynamics simulations.
 Home-page: https://gitlab.com/roncofaber/mdinterface
 License: Apache-2.0
@@ -16,10 +16,11 @@ Requires-Dist: mdanalysis
 Requires-Dist: ase
 Requires-Dist: numpy
 Requires-Dist: networkx
+Requires-Dist: libarvo
 
-# mdinterface: build interface systems for Molecular Dynamics simulations
+# mdinterface: Build Interface Systems for Molecular Dynamics Simulations
 
-`mdinterface` is a Python package for building systems to use in Molecular Dynamics (MD) simulations. The package was primarly developed to help construct electrolyte/electrode interfaces, but is well suited to generate suitable MD boxes of liquids, electrolyte systems and polymer networks.
+`mdinterface` is a Python package designed to build systems for Molecular Dynamics (MD) simulations. Initially developed to construct electrolyte/electrode interfaces, it is also well-suited for generating MD boxes of liquids, electrolyte systems, and polymer networks.
 
 ## Features
 
@@ -34,6 +35,12 @@ Requires-Dist: networkx
 
 Check the file [requirements.txt](requirements.txt) to see which packages are needed. Installing the package using `pip` should already take care of all dependencies.
 
+Additionaly, you need the `packmol` utility installed to generate MD boxes. You can follow the instructions at [https://m3g.github.io/packmol/](https://m3g.github.io/packmol/) to install it. Alternatively, you can install it using `conda`:
+
+```bash
+conda install -c conda-forge packmol
+```
+
 ## Installation
 
 ### Install using `pip`
@@ -46,7 +53,7 @@ pip install mdinterface
 
 ### Install directly the source code
 
-Alternatively you can obtain `mdinterface` directly from the repository by following those steps:
+Alternatively you can obtain `mdinterface` directly from the repository by following these steps:
 
 Clone the repository in the desired location:
 
@@ -74,3 +81,7 @@ If you plan of making changes, clone the package and install the requirements bu
 ```bash
 pip install --no-build-isolation --no-deps -e .
 ```
+
+## Usage
+
+Check the files in [examples](mdinterface/examples/) to learn how to use the package.

{mdinterface-1.0.0 → mdinterface-1.1.0}/README.md

@@ -1,6 +1,6 @@
-# mdinterface: build interface systems for Molecular Dynamics simulations
+# mdinterface: Build Interface Systems for Molecular Dynamics Simulations
 
-`mdinterface` is a Python package for building systems to use in Molecular Dynamics (MD) simulations. The package was primarly developed to help construct electrolyte/electrode interfaces, but is well suited to generate suitable MD boxes of liquids, electrolyte systems and polymer networks.
+`mdinterface` is a Python package designed to build systems for Molecular Dynamics (MD) simulations. Initially developed to construct electrolyte/electrode interfaces, it is also well-suited for generating MD boxes of liquids, electrolyte systems, and polymer networks.
 
 ## Features
 
@@ -15,6 +15,12 @@
 
 Check the file [requirements.txt](requirements.txt) to see which packages are needed. Installing the package using `pip` should already take care of all dependencies.
 
+Additionaly, you need the `packmol` utility installed to generate MD boxes. You can follow the instructions at [https://m3g.github.io/packmol/](https://m3g.github.io/packmol/) to install it. Alternatively, you can install it using `conda`:
+
+```bash
+conda install -c conda-forge packmol
+```
+
 ## Installation
 
 ### Install using `pip`
@@ -27,7 +33,7 @@ pip install mdinterface
 
 ### Install directly the source code
 
-Alternatively you can obtain `mdinterface` directly from the repository by following those steps:
+Alternatively you can obtain `mdinterface` directly from the repository by following these steps:
 
 Clone the repository in the desired location:
 
@@ -55,3 +61,7 @@ If you plan of making changes, clone the package and install the requirements bu
 ```bash
 pip install --no-build-isolation --no-deps -e .
 ```
+
+## Usage
+
+Check the files in [examples](mdinterface/examples/) to learn how to use the package.

mdinterface-1.1.0/mdinterface/__init__.py

@@ -0,0 +1,15 @@
+"""
+mdinterface: Build Interface Systems for Molecular Dynamics Simulations
+
+`mdinterface` is a Python package designed to build systems for Molecular Dynamics (MD) simulations.
+Initially developed to construct electrolyte/electrode interfaces, it is also well-suited for generating MD boxes of liquids,
+electrolyte systems, and polymer networks.
+
+"""
+
+__version__ = '1.1.0'
+__date__ = '14 Jan. 2025'
+__author__ = 'Fabrice Roncoroni'
+__all__ = ['SimulationBox']
+
+from .simulationbox import SimulationBox

mdinterface-1.1.0/mdinterface/build/__init__.py

@@ -0,0 +1,3 @@
+from .polymer import *
+from .box import *
+from .continuum2sim import *

mdinterface-1.1.0/mdinterface/build/box.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jan 14 10:23:57 2025
+
+@author: roncofaber
+"""
+
+from mdinterface.io.packmol import header, box_place, fix_place
+from mdinterface.build.continuum2sim import discretize_concentration
+
+import MDAnalysis as mda
+from ase import units
+
+import numpy as np
+
+import subprocess
+
+#%%
+
+def make_solvent_box(species, solvent, ions, volume, density, nions, concentration,
+                     conmodel, ion_pos):
+    
+    # make sure info is sound
+    assert not( nions is not None and concentration is not None),\
+        "'nions' and 'concentration' cannot both be not None"
+    
+    # convert concentration to number of ions
+    if concentration is not None:
+        nions = int(concentration*np.prod(volume)*units.mol/((units.m/10)**3))
+    
+    # define instructions for packmol
+    instructions = []
+     
+    # populate ions
+    if (conmodel is not None) or (nions is not None and ions is not None):
+        ion_instr = populate_with_ions(ions, nions, volume, ion_pos=ion_pos,
+                                       conmodel=conmodel)
+        instructions.extend(ion_instr)
+    
+    # add solvent
+    if solvent is not None:
+        solvent_volume   = 1e-24*np.prod(volume)
+        mass = solvent.atoms.masses.sum()
+
+        # number of solvent molecules
+        nummols = int(units.mol*density*(1.0/mass)*solvent_volume)
+        
+        instructions.append([solvent, nummols, "box"])
+    
+    # generate universe file
+    universe = populate_box(volume, instructions)
+    
+    if universe is None:
+        return None
+    
+    # Create a dictionary for quick lookup of species by residue name
+    species_dict = {specie.residues.resnames[0]: specie for specie in species}
+    
+    alist = []
+    for res in universe.residues:
+        resname = res.resname
+        if resname in species_dict:
+            nmol = species_dict[resname].copy()
+            nmol.atoms.positions = res.atoms.positions
+            alist.append(nmol.atoms)
+    
+    solution = mda.Merge(*alist)
+    solution.dimensions = volume + [90,90,90]
+    
+    return solution
+    
+# populate a box with solvent and ions
+def populate_box(volume, instructions, input_file="input_packmol.in",
+                 output_file="system.pdb"):
+
+    if not instructions:
+        return None
+
+    # check volume
+    assert len(volume) == 3, "Check volume!"
+    
+    # generate box boundaries with 1 AA padding
+    box = np.concatenate(([1,1,1], np.asarray(volume)-1)).tolist()
+    
+    tmp_files = ["packmol.log", "input_packmol.in", "system.pdb"]
+    with open(input_file, "w") as fout:
+        
+        fout.write(header.format(output_file, np.random.randint(100000)))
+        
+        for cc, instruction in enumerate(instructions):
+            
+            # unpack instructions
+            mol = instruction[0]
+            rep = instruction[1]
+            typ = instruction[2]
+            
+            if isinstance(rep, int):
+                if not rep:
+                    continue
+            
+            if typ == "box": # normal add
+                fout.write(box_place.format(cc, rep, " ".join(map(str, box))))
+            
+            elif typ == "fixed": # coordinate -> fixed point
+                fout.write(fix_place.format(cc, *rep))
+                
+            elif typ == "zfixed": # small bin to use in CM
+                tbox = box.copy()
+                tbox[2] = tbox[2] - mol.estimate_specie_radius()
+                tbox[5] = tbox[5] + mol.estimate_specie_radius()
+                fout.write(box_place.format(cc, 1, " ".join(map(str, tbox))))
+                mol = mol.to_universe()
+            
+            else:
+                raise "Wrong instructions"
+            
+            # write tmp pdb file and store info
+            mol.atoms.write("mol_{}.pdb".format(cc))
+            tmp_files.append("mol_{}.pdb".format(cc))
+            
+    # run packmol
+    try:
+        subprocess.run(['packmol < {} > packmol.log'.format(input_file)],
+                       shell=True, check=True, text=True)
+
+    except:
+        print("WARNING: packmol might not have worked, check system.")
+    
+    try:
+        universe = mda.Universe(output_file)
+    except:
+        universe = None
+
+    # remove temp mol files and packmol files
+    subprocess.call(['rm'] + tmp_files)
+    
+    return universe
+
+# generate a slab from a unit cell
+def make_interface_slab(interface_uc, xsize, ysize, layers=1):
+    
+    if layers == 0 or interface_uc is None:
+        return None
+    
+    xrep = int(np.round(xsize/interface_uc.atoms.get_cell()[0][0]))
+    yrep = int(np.round(ysize/interface_uc.atoms.get_cell()[1][1]))
+    
+    slab = interface_uc.copy()
+    
+    if not np.isclose(np.dot(slab.atoms.cell[0], [1,0,0]), slab.atoms.cell[0][0]):
+        xrep +=1
+        print("WARNING: check interface if pattern matches")
+    
+    if not np.isclose(np.dot(slab.atoms.cell[1], [0,1,0]), slab.atoms.cell[1][1]):
+        yrep +=1
+        print("WARNING: check interface if pattern matches")
+        
+    slab.repeat((xrep, yrep, 1), make_cubic=True)
+    
+    if layers > 1: # helps with indexing
+        slab.repeat([1,1,layers])
+    
+    slab.atoms.center()
+    # slab.atoms.rattle()
+    
+    return slab
+
+#THANKS CHATGPT (but mostly me tbh)
+def populate_with_ions(ions, nions, volume, ion_pos=False, conmodel=None):
+    def place_ion(ion, volume, ion_coords, ion_radii, zpos=None, max_attempts=100):
+        ion_radius = ion.estimate_specie_radius()
+        for _ in range(max_attempts):
+            new_coord = ion_radius + 1 + np.random.rand(3) * (volume - 2 * (ion_radius + 1))
+            if zpos is not None:
+                new_coord[2] = zpos
+                
+            if not ion_coords or np.all(np.linalg.norm(ion_coords - new_coord, axis=1) >= np.array(ion_radii) + ion_radius + 1):
+                return new_coord
+        print(f"Warning: Failed to place ion {ion} after {max_attempts} attempts")
+        return None
+
+    def place_ions_conmodel(ions, conmodel, volume, max_attempts=100):
+        instructions = []
+        ion_coords = []
+        ion_radii = []
+        for cc, ion in enumerate(ions):
+            z_coords, conc_profile = conmodel[cc]
+            z_positions = discretize_concentration(ion, conc_profile, z_coords, volume)
+            for zpos in z_positions:
+                new_coord = place_ion(ion, volume, ion_coords, ion_radii, zpos=zpos,
+                                      max_attempts=max_attempts)
+                if new_coord is not None:
+                    ion_coords.append(new_coord)
+                    ion_radii.append(ion.estimate_specie_radius())
+                    instructions.append((ion.to_universe(), new_coord, "fixed"))
+        return instructions
+
+    def place_ions_random(ions, nions, volume, to_center, max_attempts=100):
+        instructions = []
+        ion_coords = []
+        ion_radii = []
+        for cc, ion in enumerate(ions):
+            nrep = nions if isinstance(nions, int) else nions[cc]
+            for _ in range(nrep):
+                new_coord = volume / 2 if to_center else place_ion(ion, volume,
+                                                                   ion_coords,
+                                                                   ion_radii,
+                                                                   max_attempts=max_attempts)
+                if new_coord is not None:
+                    ion_coords.append(new_coord)
+                    ion_radii.append(ion.estimate_specie_radius())
+                    instructions.append((ion.to_universe(), new_coord, "fixed"))
+        return instructions
+
+    max_attempts = 100  # Limit placement attempts to avoid infinite loop
+    volume = np.array(volume)
+
+    if conmodel is not None:
+        assert len(conmodel) == len(ions), "Need one profile per specie"
+        return place_ions_conmodel(ions, conmodel, volume, max_attempts=max_attempts)
+
+    if ion_pos == "box":
+        return [(ion.to_universe(), nions if isinstance(nions, int) else nions[cc], "box") for cc, ion in enumerate(ions)]
+
+    to_center = ion_pos == "center"
+    if ion_pos == "left":
+        volume[2] /= 2
+
+    return place_ions_random(ions, nions, volume, to_center, max_attempts=max_attempts)

mdinterface-1.1.0/mdinterface/build/continuum2sim.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jan 14 10:34:26 2025
+
+@author: roncofaber
+"""
+
+from ase import units
+import numpy as np
+from scipy import integrate
+
+#%%
+# return a discrete concentration profile given a "continuum" conc. profile
+# for a specie. Return positions of the bins where ion should be.
+def discretize_concentration(specie, conc_profile, z_coords, volume):
+    
+    xsize, ysize, zsize = volume
+
+    conv = units.mol/1e27
+    area = xsize*ysize
+
+    # integrate conc. prof. over area
+    cumsum = integrate.cumulative_trapezoid(conc_profile, z_coords, initial=0, axis=0)
+    cumsum_conv = cumsum*conv*area
+
+    # generate bins (1 atom in each one) for K
+    Nions = 0
+    bins = []
+    for ii, con in enumerate(cumsum_conv):
+        if con > np.maximum(cumsum_conv.max()/100, Nions):
+            Nions += 1
+            bins.append(z_coords[ii])        
+    
+    # now find middle point of bins
+    z_pos = []
+    for ii, pos in enumerate(bins[:-1]):
+        z_pos.append((bins[ii] + bins[ii+1])/2)
+        
+    # add one last ion
+    if cumsum_conv.max() % 1 > 0.5:
+        z_pos.append((z_coords.max()+bins[-1])/2)
+        Nions += 1
+    
+    return z_pos

mdinterface-1.1.0/mdinterface/build/polymer.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Oct 22 17:17:30 2024
+
+@author: roncofaber
+"""
+
+import numpy as np
+import ase
+import ase.build
+
+#%%
+
+def build_polymer(system, substitute, nrep, target_distance=1.600):
+    """
+    Build a polymer by replicating a monomer structure and replacing 'X' atoms with a substitute.
+
+    Parameters:
+    - system (ase.Atoms): The monomer structure as an ASE Atoms object.
+    - substitute (str): Chemical symbol to replace 'X' with after replication.
+    - nrep (int): Number of times to replicate the monomer.
+    - target_distance (float, optional): Desired bond distance at the joining points (in angstroms). 
+      If None, the original distance between 'X' atoms is used.
+
+    Returns:
+    - sout (ase.Atoms): The replicated and modified polymer structure.
+    """
+    
+    system = system.copy()
+    
+    # Check if nrep is at least 1
+    if nrep < 1:
+        raise ValueError("nrep must be at least 1")
+
+    # Find the indices of the 'X' atoms
+    x_idxs = np.where(np.array(system.get_chemical_symbols()) == "X")[0]
+    if len(x_idxs) != 2:
+        raise ValueError("The monomer should contain exactly two 'X' atoms.")
+
+    # Find atoms connected to X
+    ini_idx = ase.build.connected_indices(system, x_idxs[0])[1]
+    end_idx = ase.build.connected_indices(system, x_idxs[1])[1]
+
+    bnd_vec = system.get_distance(end_idx, x_idxs[1], vector=True)
+    bnd_vec = target_distance * bnd_vec / np.linalg.norm(bnd_vec)
+
+    ini_pos = system.get_positions()[ini_idx]
+    end_pos = system.get_positions()[end_idx] + bnd_vec
+
+    # Get the vector between the two 'X' atoms
+    X_vec = end_pos - ini_pos
+    
+    # remember connecting points
+    is_connected = np.array(len(system)*[False])
+    is_connected[ini_idx] = True
+    is_connected[end_idx] = True
+    system.new_array("is_connected", is_connected)
+    
+    # Start with a copy of the system
+    sout = system.copy()
+    sout.new_array("mon_id", np.array(len(sout)*[0]))
+    
+    # Replicate the monomer
+    if nrep > 1:
+        del sout[x_idxs[1]]  # Remove the second 'X' atom in the first monomer
+
+    for ii in range(nrep - 1):
+        sadd = system.copy()
+
+        if ii < nrep - 2:
+            del sadd[x_idxs]  # Remove both 'X' atoms in the intermediate monomers
+        else:
+            del sadd[x_idxs[0]]  # Remove the first 'X' atom in the last monomer
+
+        sadd.translate((ii + 1) * X_vec)
+        sadd.set_array("mon_id", np.array(len(sadd)*[ii+1]))
+        sout += sadd
+
+    # Replace 'X' with the substitute
+    symbols = np.array(sout.get_chemical_symbols())
+    symbols[symbols == "X"] = substitute
+    sout.set_chemical_symbols(symbols)
+
+    return sout#ase.build.sort(sout)

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface/core/specie.py

@@ -9,15 +9,15 @@ Created on Fri Apr 19 13:58:43 2024
 import ase
 import ase.build
 import ase.visualize
+from ase.data import vdw_radii
 from ase.data.colors import jmol_colors
 import MDAnalysis as mda
 
-from mdinterface.utils.auxiliary import as_list, find_smallest_missing, atoms_to_indexes
-    
-from mdinterface.core.topology import Atom
+import mdinterface.utils.map as pmap
 import mdinterface.utils.auxiliary as aux
+from mdinterface.core.topology import Atom
 from mdinterface.io.read import read_lammps_data_file
-import mdinterface.utils.map as pmap
+from mdinterface.utils.auxiliary import as_list, find_smallest_missing
 
 import copy
 import numpy as np
@@ -387,30 +387,25 @@ class Specie(object):
         
         return atom_types
     
-    def estimate_sphere_radius(self):
-        """
-        Estimate the radius of the sphere containing the given points.
-
-        Parameters:
-        points (numpy.ndarray): A 2D array of shape (n, 3) where n is the number of points.
-
-        Returns:
-        float: The estimated radius of the sphere.
-        """
-        
-        points = self.atoms.get_positions()
+    # method to estimate the volume of the specie
+    def estimate_specie_volume(self, probe_radius=0):
         
-        # Calculate the centroid of the points
-        centroid = np.mean(points, axis=0)
+        try:
+            from libarvo import molecular_vs
+        except:
+            print("libarvo NOT found. Install it.")
 
-        # Calculate the distances from the centroid to each point
-        distances = np.linalg.norm(points - centroid, axis=1)
+        centers = self.atoms.get_positions()
+        radii = [vdw_radii[ii] for ii in self.atoms.get_atomic_numbers()]
 
-        # The radius of the sphere is the maximum distance from the centroid to any point
-        radius = np.max(distances)
+        volume, surface = molecular_vs(centers, radii, probe_radius)
 
-        return radius
+        return volume
     
+    # method to estimate the radius of the specie if it were a sphere
+    def estimate_specie_radius(self, probe_radius=0):
+        volume = self.estimate_specie_volume(probe_radius=probe_radius)
+        return (3 * volume / (4 * np.pi)) ** (1/3)
     
     def view(self):
         ase.visualize.view(self.atoms)

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface/io/packmol.py

@@ -14,7 +14,7 @@ nloop     100
 seed      {}
 
 filetype  pdb
-# movebadrandom
+movebadrandom
         """
 
 box_place = """

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface/simulationbox.py

@@ -8,15 +8,13 @@ Created on Tue Oct 24 15:14:41 2023
 
 from mdinterface.utils.auxiliary import label_to_element, as_list, find_smallest_missing
 from mdinterface.io.lammpswriter import DATAWriter
-from mdinterface.io.packmol import header, box_place, fix_place
+from mdinterface.build.box import make_interface_slab, make_solvent_box
 
+import ase
 import MDAnalysis as mda
 
-import ase
-from ase import units
 import numpy as np
 
-import subprocess
 import shutil
 
 import warnings
@@ -40,7 +38,6 @@ class SimulationBox():
         
         return
     
-    
     def _setup_species(self, solvent, solute, interface, enderface):
         
         self._solvent   = None
@@ -72,7 +69,6 @@ class SimulationBox():
                 
         return
                     
-    
     def _update_topology_indexes(self):
         
         nitems = {
@@ -105,214 +101,6 @@ class SimulationBox():
         
         return
     
-
-    # populate a box with solvent and ions
-    @staticmethod
-    def populate_box(volume, instructions, input_file="input_packmol.in",
-                     output_file="system.pdb"):
-
-        if not instructions:
-            return None
-
-        # check volume
-        assert len(volume) == 3, "Check volume!"
-        
-        # generate box boundaries with 1 AA padding
-        box = np.concatenate(([1,1,1], np.asarray(volume)-1)).tolist()
-        
-        tmp_files = ["packmol.log", "input_packmol.in", "system.pdb"]
-        with open(input_file, "w") as fout:
-            
-            fout.write(header.format(output_file, np.random.randint(100000)))
-            
-            for cc, instruction in enumerate(instructions):
-                
-                # unpack instructions
-                mol = instruction[0]
-                rep = instruction[1]
-                typ = instruction[2]
-                
-                if isinstance(rep, int):
-                    if not rep:
-                        continue
-                
-                if typ == "box": # normal add
-                    fout.write(box_place.format(cc, rep, " ".join(map(str, box))))
-                
-                elif typ == "fixed": # coordinate -> fixed point
-                    
-                    fout.write(fix_place.format(cc, *rep))
-                    # make temp box to fill
-                    # tbox     = box.copy()
-                    # tbox[2]  = rep - 1
-                    # tbox[-1] = rep + 1
-                
-                    # fout.write(box_place.format(cc, 1, " ".join(map(str, tbox))))
-                
-                else:
-                    raise "Wrong instructions"
-                
-                # write tmp pdb file and store info
-                mol.atoms.write("mol_{}.pdb".format(cc))
-                tmp_files.append("mol_{}.pdb".format(cc))
-                
-        # run packmol
-        try:
-            subprocess.run(['packmol < {} > packmol.log'.format(input_file)],
-                           shell=True, check=True, text=True)
-
-        except:
-            print("WARNING: packmol might not have worked, check system.")
-        
-        try:
-            universe = mda.Universe(output_file)
-        except:
-            universe = None
-
-        # remove temp mol files and packmol files
-        subprocess.call(['rm'] + tmp_files)
-        
-        return universe
-
-    # generate a slab from a unit cell
-    @staticmethod
-    def make_interface_slab(interface_uc, xsize, ysize, layers=1):
-        
-        if layers == 0 or interface_uc is None:
-            return None
-        
-        xrep = int(np.round(xsize/interface_uc.atoms.get_cell()[0][0]))
-        yrep = int(np.round(ysize/interface_uc.atoms.get_cell()[1][1]))
-        
-        slab = interface_uc.copy()
-        
-        if not np.isclose(np.dot(slab.atoms.cell[0], [1,0,0]), slab.atoms.cell[0][0]):
-            xrep +=1
-            print("WARNING: check interface if pattern matches")
-        
-        if not np.isclose(np.dot(slab.atoms.cell[1], [0,1,0]), slab.atoms.cell[1][1]):
-            yrep +=1
-            print("WARNING: check interface if pattern matches")
-            
-        slab.repeat((xrep, yrep, 1), make_cubic=True)
-        
-        if layers > 1: # helps with indexing
-            slab.repeat([1,1,layers])
-        
-        slab.atoms.center()
-        # slab.atoms.rattle()
-        
-        return slab
-    
-    @staticmethod #THANKS CHATGPT
-    def populate_with_ions(ions, nions, volume, ion_pos=False):
-        volume = np.array(volume)
-        ion_coords = []
-        instructions = []
-    
-        to_center = False
-        
-        if ion_pos == "left":
-            volume[2] /= 2
-        elif ion_pos == "center":
-            if not isinstance(nions, int) and len(nions) != 1:
-                raise ValueError("Center positioning can only be used with a single ion")
-            to_center = True
-        elif ion_pos == "box":
-            for cc, ion in enumerate(ions):
-                nrep = nions if isinstance(nions, int) else nions[cc]
-                instructions.append((ion.to_universe(), nrep, "box"))
-            return instructions
-    
-        for cc, ion in enumerate(ions):
-            ion_radius = ion.estimate_sphere_radius()
-            nrep = nions[cc] if isinstance(nions, list) else nions
-    
-            for _ in range(nrep):
-                max_attempts = 100  # Limit placement attempts to avoid infinite loop
-                for _ in range(max_attempts):
-                    if to_center:
-                        new_coord = volume / 2
-                    else:
-                        new_coord = ion_radius + 1 + np.random.rand(3) * (volume - 2 * (ion_radius + 1))
-    
-                    if ion_coords:
-                        distances = np.linalg.norm(ion_coords - new_coord, axis=1)
-                        if np.all(distances > 3):
-                            break
-                    else:
-                        break
-                else:
-                    print(f"Warning: Failed to place ion {ion} after {max_attempts} attempts")
-    
-                ion_coords.append(new_coord)
-                instructions.append((ion.to_universe(), new_coord, "fixed"))
-    
-        return instructions
-
-    
-    def make_solvent_box(self, solvent, ions, volume, density, nions, concentration,
-                         conmodel, ion_pos):
-        
-        # make sure info is sound
-        assert not( nions is not None and concentration is not None),\
-            "'nions' and 'concentration' cannot both be not None"
-        
-        # convert concentration to number of ions
-        if concentration is not None:
-            nions = int(concentration*np.prod(volume)*units.mol/((units.m/10)**3))
-        
-        # define instructions for packmol
-        instructions = []
-        
-        # populate according to continuum model
-        if conmodel is not None:
-            z_positions = conmodel.discretize_profile(volume)
-            
-            for cc, ion in enumerate(ions):
-                for z_pos in z_positions[cc]:
-                    
-                    # radius = conmodel.species[cc].radius
-                    instructions.append([ion, z_pos, "fixed"])
-        
-        # populate according to fixed number of ions
-        elif nions is not None and ions is not None:
-            
-            ion_instr = self.populate_with_ions(ions, nions, volume, ion_pos=ion_pos)
-            instructions.extend(ion_instr)
-        
-        # add solvent
-        if solvent is not None:
-            solvent_volume   = 1e-24*np.prod(volume)
-            mass = solvent.atoms.masses.sum()
-    
-            # number of solvent molecules
-            nummols = int(units.mol*density*(1.0/mass)*solvent_volume)
-            
-            instructions.append([solvent, nummols, "box"])
-        
-        # generate universe file
-        universe = self.populate_box(volume, instructions)
-        
-        if universe is None:
-            return None
-        
-        # Create a dictionary for quick lookup of species by residue name
-        species_dict = {specie.residues.resnames[0]: specie for specie in self.species}
-        
-        alist = []
-        for res in universe.residues:
-            resname = res.resname
-            if resname in species_dict:
-                nmol = species_dict[resname].copy()
-                nmol.atoms.positions = res.atoms.positions
-                alist.append(nmol.atoms)
-        
-        solution = mda.Merge(*alist)
-        solution.dimensions = volume + [90,90,90]
-        
-        return solution
-    
     @staticmethod
     def _get_size_from_slab(slab):
         
@@ -320,9 +108,9 @@ class SimulationBox():
         ysize = [0,1,0]@slab.atoms.cell@[0,1,0]
         slab_depth = [0,0,1]@slab.atoms.cell@[0,0,1]
         
-        
         return xsize, ysize, slab_depth
     
+    # main driver to generate a simulation box given instructions
     def make_simulation_box(self, solvent_vol, solvent_rho, nions=None,
                             concentration=None, conmodel=None, layers=1,
                             padding=1.5, to_ase=False, mirror=False,
@@ -334,8 +122,8 @@ class SimulationBox():
         xsize, ysize, zsize = solvent_vol
         
         # make slab
-        islab = self.make_interface_slab(self._interface, xsize, ysize, layers=layers)
-        eslab = self.make_interface_slab(self._enderface, xsize, ysize, layers=layers)
+        islab = make_interface_slab(self._interface, xsize, ysize, layers=layers)
+        eslab = make_interface_slab(self._enderface, xsize, ysize, layers=layers)
         
         xi, yi, sdi, xe, ye, sde = 0, 0, 0, 0, 0, 0
         # update the volume with multiples of UC
@@ -358,9 +146,9 @@ class SimulationBox():
             ysize = np.maximum(yi, ye)
         
         # make solvent box
-        solvent = self.make_solvent_box(self.solvent, self._solute,
-                                        [xsize, ysize, zsize], solvent_rho,
-                                        nions, concentration, conmodel, ion_pos)
+        solvent = make_solvent_box(self.species, self.solvent, self._solute,
+                                   [xsize, ysize, zsize], solvent_rho,
+                                   nions, concentration, conmodel, ion_pos)
         
         # now build system
         system = None
@@ -393,7 +181,6 @@ class SimulationBox():
                     system = mda.Merge(system.atoms, eslab.atoms)
                     zdim   += sde + padding
                 
-        
         system.dimensions = [xsize, ysize, zdim] + [90, 90, 90] #TODO not like this
         
         if vacuum is not None:
@@ -593,7 +380,6 @@ class SimulationBox():
     
     @property
     def _species(self):
-        
         return np.concatenate((as_list(self._solvent), as_list(self._solute),
                                       as_list(self._interface), as_list(self._enderface)))
     

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface/utils/__init__.py

@@ -6,3 +6,4 @@ utils: Utility functions and helpers.
 
 from .auxiliary import *
 from .database import *
+from .map import *

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface/utils/database.py

@@ -13,7 +13,7 @@ from mdinterface.core.specie import Specie
 from mdinterface.core.topology import Bond, Angle, Atom, Dihedral, Improper
 
 import ase.build
-
+from ase.build import fcc111
 #%%
 
 # graphene https://onlinelibrary.wiley.com/doi/10.1002/adma.201705791
@@ -109,3 +109,39 @@ class Perchlorate(Specie):
 
         super().__init__(atoms=pclo, lj=lj, bonds=[b1, b2], angles=a1, cutoff=1.5, **kwargs)
         return
+
+#metal parameters from https://pubs.acs.org/doi/full/10.1021/jp801931d
+class Metal111(Specie):
+    
+    def __init__(self, metal, **kwargs):
+        
+        slab = fcc111(metal, size=(1,2,3), orthogonal=True, periodic=True)
+        
+        # those are in kcal/mol and r0, so it should be divided by 2**1/6
+        metal_params = {
+            "Ag" : [4.56, 2.955],
+            "Al" : [4.02, 2.925],
+            "Au" : [5.29, 2.951],
+            "Cu" : [4.72, 2.616],
+            "Ni" : [5.65, 2.552],
+            "Pb" : [2.93, 3.565],
+            "Pd" : [6.15, 2.819],
+            "Pt" : [7.80, 2.845],
+            "Ac" : [6.51, 3.843],
+            "Ca" : [3.36, 4.025],
+            "Ce" : [6.38, 3.734],
+            "Es" : [2.88, 4.133],
+            "Ir" : [9.20, 2.785],
+            "Fe" : [6.00, 2.590],
+            "Rh" : [7.84, 2.757],
+            "Sr" : [3.40, 4.379],
+            "Th" : [8.47, 3.683],
+            "Yb" : [2.71, 3.942]
+        }
+        
+        lj = metal_params[metal]
+        lj_copy = [lj[0], round(lj[1] / np.power(2, 1/6), 5)]
+        
+        super().__init__(atoms=slab, lj=lj_copy, **kwargs)
+        
+        return

{mdinterface-1.0.0 → mdinterface-1.1.0/mdinterface.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mdinterface
-Version: 1.0.0
+Version: 1.1.0
 Summary: mdinterface: A package for building interface systems in Molecular Dynamics simulations.
 Home-page: https://gitlab.com/roncofaber/mdinterface
 License: Apache-2.0
@@ -16,10 +16,11 @@ Requires-Dist: mdanalysis
 Requires-Dist: ase
 Requires-Dist: numpy
 Requires-Dist: networkx
+Requires-Dist: libarvo
 
-# mdinterface: build interface systems for Molecular Dynamics simulations
+# mdinterface: Build Interface Systems for Molecular Dynamics Simulations
 
-`mdinterface` is a Python package for building systems to use in Molecular Dynamics (MD) simulations. The package was primarly developed to help construct electrolyte/electrode interfaces, but is well suited to generate suitable MD boxes of liquids, electrolyte systems and polymer networks.
+`mdinterface` is a Python package designed to build systems for Molecular Dynamics (MD) simulations. Initially developed to construct electrolyte/electrode interfaces, it is also well-suited for generating MD boxes of liquids, electrolyte systems, and polymer networks.
 
 ## Features
 
@@ -34,6 +35,12 @@ Requires-Dist: networkx
 
 Check the file [requirements.txt](requirements.txt) to see which packages are needed. Installing the package using `pip` should already take care of all dependencies.
 
+Additionaly, you need the `packmol` utility installed to generate MD boxes. You can follow the instructions at [https://m3g.github.io/packmol/](https://m3g.github.io/packmol/) to install it. Alternatively, you can install it using `conda`:
+
+```bash
+conda install -c conda-forge packmol
+```
+
 ## Installation
 
 ### Install using `pip`
@@ -46,7 +53,7 @@ pip install mdinterface
 
 ### Install directly the source code
 
-Alternatively you can obtain `mdinterface` directly from the repository by following those steps:
+Alternatively you can obtain `mdinterface` directly from the repository by following these steps:
 
 Clone the repository in the desired location:
 
@@ -74,3 +81,7 @@ If you plan of making changes, clone the package and install the requirements bu
 ```bash
 pip install --no-build-isolation --no-deps -e .
 ```
+
+## Usage
+
+Check the files in [examples](mdinterface/examples/) to learn how to use the package.

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface.egg-info/SOURCES.txt

@@ -12,6 +12,10 @@ mdinterface.egg-info/SOURCES.txt
 mdinterface.egg-info/dependency_links.txt
 mdinterface.egg-info/requires.txt
 mdinterface.egg-info/top_level.txt
+mdinterface/build/__init__.py
+mdinterface/build/box.py
+mdinterface/build/continuum2sim.py
+mdinterface/build/polymer.py
 mdinterface/core/__init__.py
 mdinterface/core/specie.py
 mdinterface/core/topology.py

{mdinterface-1.0.0 → mdinterface-1.1.0}/mdinterface.egg-info/requires.txt

@@ -2,3 +2,4 @@ mdanalysis
 ase
 numpy
 networkx
+libarvo

{mdinterface-1.0.0 → mdinterface-1.1.0}/requirements.txt

@@ -2,3 +2,4 @@ mdanalysis
 ase
 numpy
 networkx
+libarvo

mdinterface-1.0.0/mdinterface/__init__.py

@@ -1,10 +0,0 @@
-"""
-mdinterface is a package to setup molecular dynamics systems.
-"""
-
-__version__ = '1.0.0'
-__date__ = '16 Dec. 2024'
-__author__ = 'Fabrice Roncoroni'
-__all__ = ['SimulationBox']
-
-from .simulationbox import SimulationBox