mdinterface 1.0.0__py3-none-any.whl

mdinterface/utils/auxiliary.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Apr 12 14:04:43 2024
+
+@author: roncofaber
+"""
+
+import re
+import collections
+import numpy as np
+import networkx as nx
+
+import ase
+from ase import neighborlist
+#%%
+
+def label_to_element(atostr, atomss):
+    """
+    Attempts to determine the chemical element symbol corresponding to a given 
+    string and atomic mass.
+
+    Args:
+        atostr (str): A string potentially representing a chemical element.
+        atomss (float): The approximate atomic mass of the element.
+
+    Returns:
+        str: The inferred chemical element symbol.
+
+    Raises:
+        ValueError: If the function cannot determine a valid element from the input.
+    """
+
+
+    new_label = re.sub(r'[^A-Za-z]', '', atostr).capitalize()    # Clean up input
+    
+    # load ase info
+    atomic_masses = ase.data.atomic_masses
+    elements = ase.data.chemical_symbols
+    
+    # initialize variables
+    is_ready = False  # Flag to track if the element is found
+    tried_last_resort = False 
+
+    while not is_ready:
+        try:
+            try_atom = ase.Atom(new_label)  # Attempt to create an Atom object
+            existent = True
+        except:
+            existent = False
+
+        if existent and np.abs(try_atom.mass - atomss) < 1:  # Check mass match
+            is_ready = True
+
+        if not is_ready:
+            new_label = new_label[:-1]  # Shorten the label for the next attempt
+
+            if not new_label:  # If the label is empty, try a last-resort approach
+                
+                new_label = elements[np.argmin(np.abs(atomss - atomic_masses))]
+
+                if tried_last_resort:
+                    raise ValueError("{} is not a valid element".format(new_label))
+
+                tried_last_resort = True
+
+    return new_label
+
+
+# return copy of input as list if not one
+def as_list(inp):
+    if inp is None:
+        return []
+    elif isinstance(inp, int) or isinstance(inp, np.int64):
+        return [inp]
+    elif isinstance(inp, collections.abc.Iterable) and not isinstance(inp, str): 
+        # Handles lists, tuples, NumPy arrays, etc. (Excludes strings)
+        return list(inp)  
+    else:
+        return [inp] # prone to error?
+        # raise TypeError(f"Cannot convert type {type(inp)} to list")
+        
+
+def find_smallest_missing(data, start=0):
+    """Finds the next smallest integer that is not in the list.
+  
+    This function efficiently finds the next smallest integer that is not present in the input list.
+    It leverages sets for fast membership checks.
+    
+    Args:
+        data: A list of integers.
+  
+    Returns:
+        The next smallest integer that is not in the list.
+      """
+
+    data_set = set(data)  # Convert the list to a set for efficient membership checks
+    smallest = start          # Start with the smallest possible positive integer
+    while smallest in data_set:  # Check if 'smallest' is in the set
+        smallest += 1              # If found, increment 'smallest'
+    return smallest            # Return the first integer not found in the set 
+
+
+def remove_inverted_tuples(list_of_tuples):
+    seen = set()
+    for i in range(len(list_of_tuples) - 1, -1, -1):  # Iterate backwards
+        tup = list_of_tuples[i]
+        reversed_tup = tup[::-1]
+        if reversed_tup in seen:
+            del list_of_tuples[i]  # Remove the tuple
+        else:
+            seen.add(tup)
+            
+# return list of indexes from mixed input of indexes and string (elements)
+def atoms_to_indexes(system, symbols):
+
+    # check if symbols is a list of strings
+    if isinstance(symbols, str):
+        if symbols == 'all':
+            return list(range(len(system.get_chemical_symbols())))
+
+    symbols = as_list(symbols)
+
+    indexes = []
+    for symbol in symbols:
+        if not isinstance(symbol, str):
+            indexes.append(symbol)
+        else:
+            for cc, atom in enumerate(system.get_chemical_symbols()):
+                if atom == symbol:
+                    indexes.append(cc)
+    return np.unique(indexes).tolist()
+
+def chunker(seq, size):
+    return (seq[pos:pos + size] for pos in range(0, len(seq), size))
+
+def get_nth_neighbors(graph, start_node, n):
+    visited = set()
+    queue = collections.deque([(start_node, 0)])
+    neighbors = []
+
+    while queue:
+        current_node, depth = queue.popleft()
+        if depth > n:
+            break
+        if current_node not in visited:
+            visited.add(current_node)
+            if depth > 0:  # Exclude the start_node itself
+                neighbors.append(current_node)
+            for neighbor in graph.neighbors(current_node):
+                if neighbor not in visited:
+                    queue.append((neighbor, depth + 1))
+
+    return neighbors
+
+def molecule_to_graph(molecule, cutoff_scale=1.0):
+    
+    # Generate cutoff
+    cutOff = cutoff_scale*np.array(neighborlist.natural_cutoffs(molecule))
+    ignore_atoms = ""  # Assuming ignore_atoms is an empty string
+    cutOff[atoms_to_indexes(molecule, ignore_atoms)] = 0
+
+    # Calculate neighbor list
+    neighborList = neighborlist.NeighborList(cutOff, self_interaction=False, bothways=True)
+    neighborList.update(molecule)
+
+    # Check if it's a polymer
+    is_polymer = "is_connected" in molecule.arrays
+    
+    # Generate graph
+    G = nx.Graph()
+    G.add_nodes_from(list(range(len(molecule))))
+    
+    # Iterate through neighbors to add edges
+    for atom_index, bonded_atoms in enumerate(neighborList.nl.neighbors):
+        for neighbor_index in bonded_atoms:
+            if is_polymer:
+                # Skip if the atoms belong to different monomers and are not connected
+                if molecule.arrays["mon_id"][atom_index] != molecule.arrays["mon_id"][neighbor_index]:
+                    if not (molecule.arrays["is_connected"][atom_index] and molecule.arrays["is_connected"][neighbor_index]):
+                        continue
+            # Add edge between the atoms
+            G.add_edge(atom_index, neighbor_index)
+    
+    return G
+
+def find_atom_types(molecule, max_depth=1):
+    
+    G = molecule_to_graph(molecule)
+    
+    # Get chemical symbols
+    symbols = molecule.get_chemical_symbols()
+    
+    # Create a dictionary to store the unique atom types and their IDs
+    atom_types = {}
+    type_id = 0
+
+    # Create an array to store the type ID of each atom
+    atom_type_ids = np.zeros(len(molecule), dtype=int)
+
+    # Iterate over each node in the graph
+    for node in G.nodes:
+        # Get the element of the current atom
+        element = symbols[node]
+        
+        # Get the elements of the nth nearest neighboring atoms
+        nth_neighbors = get_nth_neighbors(G, node, max_depth)
+        neighbor_elements = sorted([symbols[neighbor] for neighbor in nth_neighbors])
+        
+        # Create a unique identifier for the atom type
+        atom_type = (element, tuple(neighbor_elements))
+        
+        # Assign an ID to the atom type if it is not already in the dictionary
+        if atom_type not in atom_types:
+            atom_types[atom_type] = type_id
+            type_id += 1
+        
+        # Store the type ID in the array
+        atom_type_ids[node] = atom_types[atom_type]
+
+    return atom_type_ids, {v: k for k, v in atom_types.items()}
+
+def find_unique_paths_of_length(graph, length):
+    def dfs(current_node, current_path):
+        if len(current_path) == length + 1:
+            # Check if the reverse of the path already exists
+            if tuple(current_path[::-1]) not in paths:
+                paths.add(tuple(current_path))
+            return
+        for neighbor in graph.neighbors(current_node):
+            if neighbor not in current_path:  # Avoid cycles
+                dfs(neighbor, current_path + [neighbor])
+
+    paths = set()
+    for node in graph.nodes:
+        dfs(node, [node])
+    
+    # Convert set of tuples back to list of lists
+    paths = [list(path) for path in paths]
+    
+    # Sort paths lexicographically
+    paths.sort()
+    
+    return np.array(paths, dtype=int)
+
+def find_improper_idxs(graph):
+    nodes = [node for node, degree in dict(graph.degree()).items() if degree == 3]
+
+    # Find all nodes connected to those nodes
+    improper_idxs = []
+    for node in nodes:
+        improper_idxs.append(sorted([node,* graph.neighbors(node)]))
+        
+    return improper_idxs
+
+
+def same_rev_check(list1, list2):
+    if list(list1) == list(list2):
+        return True
+    elif list(list1) == list(reversed(list2)):
+        return True
+    return False

mdinterface/utils/database.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug  5 17:13:50 2024
+
+@author: roncofaber
+"""
+
+import numpy as np
+
+# internal modules
+from mdinterface.core.specie import Specie
+from mdinterface.core.topology import Bond, Angle, Atom, Dihedral, Improper
+
+import ase.build
+
+#%%
+
+# graphene https://onlinelibrary.wiley.com/doi/10.1002/adma.201705791
+class Graphene(Specie):
+    def __init__(self, **kwargs):
+        system = ase.build.graphene()
+        system.cell[-1][-1] = 3.35
+        g_b = Bond("C", "C", kr=469, r0=1.4)
+        g_d = Dihedral("C", "C", "C", "C", A1=7.25, A2=0, A3=-7.25, A4=0, A5=0)
+        g_i = Improper(a1="C", K=1.1, d=-1, n=2)
+        g_a = Angle("C", "C", "C", kr=63, theta0=120)
+        lj = {"C": [0.07, 3.54996412]}
+
+        super().__init__(system, bonds=g_b, dihedrals=g_d, impropers=g_i, angles=g_a, lj=lj, **kwargs)
+        
+        return
+
+# solvent https://docs.lammps.org/Howto_tip3p.html (Ewald model)
+class Water(Specie):
+    def __init__(self, model="ewald", **kwargs):
+        
+        if model.lower() == "ewald":
+            b1 = Bond("O", "H", kr=450, r0=0.9572)
+            a1 = Angle("H", "O", "H", kr=55, theta0=104.52)
+            charges = [-0.83, 0.415, 0.415]
+            lj = {"O": [0.102, 3.188], "H": [0.0, 1.0]}
+
+        super().__init__("H2O", charges=charges, bonds=b1, angles=a1, lj=lj, **kwargs)
+        return
+
+
+#oxygen https://pubs.acs.org/doi/10.1021/acs.jctc.0c01132 /!\: divide sig by 2**(1/6)
+class Oxygen(Specie):
+    def __init__(self, **kwargs):
+        
+        b1 = Bond("O", "O", kr=1640.4, r0=1.2074)
+        lj = {"O" : [0.1047, 2.9373]}
+
+        super().__init__("O2", charges = 0.0, lj=lj, bonds=b1, **kwargs)
+        return
+
+#hydrogen https://pubs.acs.org/doi/10.1021/acs.jctc.0c01132 /!\: divide sig by 2**(1/6)
+class Hydrogen(Specie):
+    def __init__(self, Hset="std", **kwargs):
+        
+        b1 = Bond("H", "H", kr=700, r0=0.7414)
+        
+        if Hset.lower() == "std":   # standard 12-6 set
+            lj = {"H" : [0.0153, 2.5996]}
+        elif Hset.lower() == "alt": # alternative 12-6 set
+            lj = {"H" : [0.0145, 2.8001]}
+
+        super().__init__("H2", charges = 0.0, lj=lj, bonds=b1, **kwargs)
+        return
+
+#nitrogen https://pubs.acs.org/doi/10.1021/acs.jctc.0c01132 /!\: divide sig by 2**(1/6)
+class Nitrogen(Specie):
+    def __init__(self, **kwargs):
+        
+        b1 = Bond("N", "N", kr=3190, r0=1.0977)
+        lj = {"N" : [0.0797, 3.2197]}
+
+        super().__init__("N2", charges = 0.0, lj=lj, bonds=b1, **kwargs)
+        return
+
+#perchlorate https://pubs.acs.org/doi/full/10.1021/jp801280s
+class Perchlorate(Specie):
+    def __init__(self, **kwargs):
+        
+        # Bond length
+        bl = 1.506
+        
+        # Coordinates of ClO4^- anion
+        coordinates = [
+            (0.0, 0.0, 0.0),  # Chlorine atom at the origin
+            (bl * np.sqrt(8/9), 0.0, -bl / 3),  # Oxygen atom 1
+            (-bl * np.sqrt(2/9), bl * np.sqrt(2/3), -bl / 3),  # Oxygen atom 2
+            (-bl * np.sqrt(2/9), -bl * np.sqrt(2/3), -bl / 3),  # Oxygen atom 3
+            (0.0, 0.0, bl)   # Oxygen atom 4
+        ]
+        
+        charges = [1.176, -0.544, -0.544, -0.544, -0.544]
+        
+        pclo = ase.Atoms("ClO4", positions=coordinates, charges=charges)
+        
+        b1 = Bond("Cl", "O", kr=757.286, r0=1.506)
+        b2 = Bond("O",  "O", kr=33.445,  r0=2.459)
+        a1 = Angle("O", "Cl", "O", kr=207.9, theta0=109.5)
+        lj = {
+            "Cl" : [0.1177, 3.5000],
+            "O"  : [0.2099, 2.9000]
+            }
+
+        super().__init__(atoms=pclo, lj=lj, bonds=[b1, b2], angles=a1, cutoff=1.5, **kwargs)
+        return

mdinterface/utils/map.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Oct 28 11:30:04 2024
+
+@author: roncofaber
+"""
+
+import numpy as np
+import mdinterface.utils.auxiliary as aux
+from mdinterface.core.topology import Bond, Angle, Dihedral, Improper
+
+#%%
+
+def map_atoms(atoms):
+    
+    # Create an array to store the type ID of each atom
+    atom_type_ids = []
+    type_id = 0
+    atoms_map = {}
+    atoms_list = []
+    
+    for cc, atom in enumerate(atoms):
+        if atom not in atoms_list:
+            atom_type_ids.append(atom.label)
+            atoms_list.append(atom)
+            atoms_map[atom.label] = type_id
+            type_id += 1
+            
+        else:
+            idx = atoms_list.index(atom)
+            atom_type_ids.append(atom.label)
+            atoms_map[atom.label] = idx
+    
+    atom_type_ids = np.array(atom_type_ids)
+    
+    return atoms_list, atoms_map, atom_type_ids
+
+def map_bonds(bonds):
+    bond_type_ids = []
+    type_id = 0
+    bond_map = {}
+    bonds_list = []
+    
+    for cc, bond in enumerate(bonds):
+        if bond not in bonds_list:
+            bond_type_ids.append(type_id)
+            bonds_list.append(bond)
+            bond_map[bond.symbols] = type_id
+            type_id += 1
+        else:
+            idx = bonds_list.index(bond)
+            bond_type_ids.append(idx)
+            bond_map[bond.symbols] = idx
+    
+    bond_type_ids = np.array(bond_type_ids)
+    return bonds_list, bond_map, bond_type_ids
+
+def map_angles(angles):
+    angle_type_ids = []
+    type_id = 0
+    angle_map = {}
+    angles_list = []
+    
+    for cc, angle in enumerate(angles):
+        if angle not in angles_list:
+            angle_type_ids.append(type_id)
+            angles_list.append(angle)
+            angle_map[angle.symbols] = type_id
+            type_id += 1
+        else:
+            idx = angles_list.index(angle)
+            angle_type_ids.append(idx)
+            angle_map[angle.symbols] = idx
+    
+    angle_type_ids = np.array(angle_type_ids)
+    return angles_list, angle_map, angle_type_ids
+
+def map_dihedrals(dihedrals):
+    dihedral_type_ids = []
+    type_id = 0
+    dihedral_map = {}
+    dihedrals_list = []
+    
+    for cc, dihedral in enumerate(dihedrals):
+        if dihedral not in dihedrals_list:
+            dihedral_type_ids.append(type_id)
+            dihedrals_list.append(dihedral)
+            dihedral_map[dihedral.symbols] = type_id
+            type_id += 1
+        else:
+            idx = dihedrals_list.index(dihedral)
+            dihedral_type_ids.append(idx)
+            dihedral_map[dihedral.symbols] = idx
+    
+    dihedral_type_ids = np.array(dihedral_type_ids)
+    return dihedrals_list, dihedral_map, dihedral_type_ids
+
+def map_impropers(impropers):
+    
+    if impropers is None:
+        return None, None
+    
+    improper_type_ids = []
+    type_id = 0
+    improper_map = {}
+    impropers_list = []
+    
+    for cc, improper in enumerate(impropers):
+        if improper not in impropers_list:
+            improper_type_ids.append(type_id)
+            impropers_list.append(improper)
+            improper_map[improper.symbols] = type_id
+            type_id += 1
+        else:
+            idx = impropers_list.index(improper)
+            improper_type_ids.append(idx)
+            improper_map[improper.symbols] = idx
+    
+    improper_type_ids = np.array(improper_type_ids)
+    return impropers_list, improper_map, improper_type_ids
+
+#%%
+
+def find_missing_bonds(nas):
+    tmp_bonds, _ = nas.bonds
+    all_bonds = aux.find_unique_paths_of_length(nas.graph, 1)
+
+    # Convert tmp_bonds to a set of tuples for efficient membership checking
+    tmp_bonds_set = set(tuple(bond) for bond in tmp_bonds)
+    tmp_bonds_set.update(tuple(reversed(bond)) for bond in tmp_bonds)
+
+    missing_bonds = []
+    for tmp_bond in all_bonds:
+        tmp_bond_tuple = tuple(tmp_bond)
+        tmp_bond_tuple_rev = tuple(reversed(tmp_bond_tuple))
+        if tmp_bond_tuple not in tmp_bonds_set and tmp_bond_tuple_rev not in tmp_bonds_set:
+            missing_bonds.append(tuple(nas._sids[ii] for ii in tmp_bond_tuple))
+
+    return missing_bonds
+
+def find_missing_angles(nas):
+    tmp_angles, _ = nas.angles
+    all_angles = aux.find_unique_paths_of_length(nas.graph, 2)
+
+    # Convert tmp_angles to a set of tuples for efficient membership checking
+    tmp_angles_set = set(tuple(angle) for angle in tmp_angles)
+    tmp_angles_set.update(tuple(reversed(angle)) for angle in tmp_angles)
+
+    missing = []
+    for tmp_ang in all_angles:
+        tmp_ang_tuple = tuple(tmp_ang)
+        tmp_ang_tuple_rev = tuple(reversed(tmp_ang_tuple))
+        if tmp_ang_tuple not in tmp_angles_set and tmp_ang_tuple_rev not in tmp_angles_set:
+            missing.append(tuple(nas._sids[ii] for ii in tmp_ang_tuple))
+    return missing
+
+def find_missing_dihedrals(nas):
+    tmp_dihedrals, _ = nas.dihedrals
+    all_dihedrals = aux.find_unique_paths_of_length(nas.graph, 3)
+
+    # Convert tmp_dihedrals to a set of tuples for efficient membership checking
+    tmp_dihedrals_set = set(tuple(dihedral) for dihedral in tmp_dihedrals)
+    tmp_dihedrals_set.update(tuple(reversed(dihedral)) for dihedral in tmp_dihedrals)
+
+    missing_dihedrals = []
+    for tmp_dihedral in all_dihedrals:
+        tmp_dihedral_tuple = tuple(tmp_dihedral)
+        tmp_dihedral_tuple_rev = tuple(reversed(tmp_dihedral_tuple))
+        if tmp_dihedral_tuple not in tmp_dihedrals_set and tmp_dihedral_tuple_rev not in tmp_dihedrals_set:
+            missing_dihedrals.append(tuple(nas._sids[ii] for ii in tmp_dihedral_tuple))
+
+    return missing_dihedrals
+
+def find_missing_impropers(nas):
+    tmp_impropers, _ = nas.impropers
+    all_impropers = aux.find_unique_paths_of_length(nas.graph, 3)  # Assuming path length 3 for impropers
+
+    # Convert tmp_impropers to a set of tuples for efficient membership checking
+    tmp_impropers_set = set(tuple(improper) for improper in tmp_impropers)
+    tmp_impropers_set.update(tuple(reversed(improper)) for improper in tmp_impropers)
+
+    missing_impropers = []
+    for tmp_improper in all_impropers:
+        tmp_improper_tuple = tuple(tmp_improper)
+        tmp_improper_tuple_rev = tuple(reversed(tmp_improper_tuple))
+        if tmp_improper_tuple not in tmp_impropers_set and tmp_improper_tuple_rev not in tmp_impropers_set:
+            missing_impropers.append(tuple(nas._sids[ii] for ii in tmp_improper_tuple))
+
+    return missing_impropers
+
+#%%
+
+def generate_missing_interactions(nas, interaction_type):
+    mss_interactions = nas.suggest_missing_interactions(interaction_type)
+
+    new_interactions = []
+    interaction_type_map = {}
+
+    # Determine the appropriate attributes based on the interaction type
+    if interaction_type == "bonds":
+        interaction_list = nas._btype
+        num_atoms = 2
+    elif interaction_type == "angles":
+        interaction_list = nas._atype
+        num_atoms = 3
+    elif interaction_type == "dihedrals":
+        interaction_list = nas._dtype
+        num_atoms = 4
+    elif interaction_type == "impropers":
+        interaction_list = nas._itype
+        num_atoms = 4
+    else:
+        raise ValueError("Invalid interaction type")
+
+    # Create a mapping of interaction types for faster lookup
+    for itype in interaction_list:
+        ctypes = tuple(nas._smap[ii] for ii in itype.symbols)
+        interaction_type_map[ctypes] = itype
+        interaction_type_map[ctypes[::-1]] = itype  # Add the reversed tuple as well
+
+    for mss_interaction in mss_interactions:
+        found_interaction = False
+        stypes = tuple(nas._smap[ii] for ii in mss_interaction)
+        stypes_rev = stypes[::-1]
+        
+        # topology attribute already existing in map
+        if stypes in interaction_type_map or stypes_rev in interaction_type_map:
+            if found_interaction:
+                raise ValueError(f"More than one possible {interaction_type[:-1]} found, abort!")
+                
+            if stypes in interaction_type_map:
+                ninteraction = interaction_type_map[stypes].copy()
+                
+            else:
+                ninteraction = interaction_type_map[stypes_rev].copy()
+                mss_interaction = mss_interaction[::-1]
+            
+            a1, a2, *rest = mss_interaction
+            
+            ninteraction._a1 = a1
+            ninteraction._a2 = a2
+            
+            if num_atoms > 2:
+                ninteraction._a3 = rest[0]
+            if num_atoms > 3:
+                ninteraction._a4 = rest[1]
+            new_interactions.append(ninteraction)
+            found_interaction = True
+        
+        # new topology attribute
+        else:
+            if found_interaction:
+                raise ValueError(f"More than one possible {interaction_type[:-1]} found, abort!")
+            
+            a1, a2, *rest = mss_interaction
+            
+            if num_atoms == 2:
+                ninteraction = Bond(a1, a2)
+            elif num_atoms == 3:
+                ninteraction = Angle(a1, a2, rest[0])
+            elif num_atoms == 4:
+                ninteraction = Dihedral(a1, a2, rest[0], rest[1])
+                
+            new_interactions.append(ninteraction)
+            found_interaction = True
+            
+
+    return new_interactions