ensemble-analyzer 0.0.10a6__py3-none-any.whl

ensemble_analyzer/__main__.py

@@ -0,0 +1,5 @@
+from ensemble_analyzer.launch import main
+
+if __name__ == '__main__':
+    
+    main()

ensemble_analyzer/_calculators/__init__.py

@@ -0,0 +1,12 @@
+import importlib
+import pkgutil
+
+# Importa automaticamente tutti i moduli nella cartella
+for module_info in pkgutil.iter_modules(__path__):
+    if module_info.name != "base":  # evita di ricaricare base.py
+        importlib.import_module(f"{__name__}.{module_info.name}")
+
+# Espone il registro globale
+from .base import CALCULATOR_REGISTRY, BaseCalc, register_calculator
+
+__all__ = ["CALCULATOR_REGISTRY", "BaseCalc", "register_calculator"]

ensemble_analyzer/_calculators/_gaussian.py

@@ -0,0 +1,91 @@
+import os
+from ase.calculators.gaussian import Gaussian
+from ensemble_analyzer._calculators.base import BaseCalc, register_calculator
+
+
+@register_calculator("gaussian")
+class GaussianCalc(BaseCalc):
+    """
+    ASE-compatible Gaussian calculator wrapper.
+    This class follows the same structure as OrcaCalc,
+    encapsulating the logic for SP, OPT, and FREQ calculations.
+    """
+
+    def common_str(self):
+        """
+        Build the common Gaussian input string (route section)
+        based on the Protocol parameters.
+        """
+
+        # Construct solvent model (if any)
+        solv = ""
+        if self.protocol.solvent:
+            if self.protocol.solvent.smd:
+                solv = f" SCRF=(SMD,Solvent={self.protocol.solvent.solvent})"
+            else:
+                solv = f" SCRF=(CPCM,Solvent={self.protocol.solvent.solvent})"
+
+        # Basic route section
+        route = f"# {self.protocol.functional}/{self.protocol.basis}{solv}"
+
+        # Add user-specified custom input
+        if self.protocol.add_input.strip():
+            route += " " + self.protocol.add_input.strip()
+
+        if self.protocol.read_orbitals:
+            route += " guess=read"
+
+        # Default options: no population output
+        # route += " pop=none"
+
+        return route
+
+    def _std_calc(self):
+        route = self.common_str()
+
+        calc = Gaussian(
+            label="gaussian",
+            output_type='N',
+            mem=f"{self.cpu*2}GB",
+            extra=route,
+            charge=self.protocol.charge,
+            mult=self.protocol.mult,
+            nprocshared=self.cpu,
+        )
+        if self.protocol.read_orbitals:
+            calc.oldchk = (
+                f"{self.conf.folder}/protocol_{self.protocol.read_orbitals}.chk"
+            )
+
+        return calc, "gaussian"
+
+    def single_point(self):
+
+        calc, label = self._std_calc()
+        return calc, label
+
+    def optimisation(self):
+
+        calc, label = self._std_calc()
+        if not self.protocol.constrains:
+            calc.parameters["extra"] += " opt"
+        else:
+            calc.parameters["extra"] += " opt=(modredudant)"
+            redundant = "\n".join([f"X {i+1} F" for i in self.protocol.constrains])
+            # Counting in gaussian starts at 1
+            
+            if calc.parameters.get("addsec"):
+                calc.parameters["addsec"] += redundant
+            else: 
+                calc.parameters["addsec"] = redundant
+
+        if self.protocol.freq: 
+            calc.parameters["extra"] += " freq=(HPModes,vcd)"
+
+        return calc, label
+
+    def frequency(self):
+
+        calc, label = self._std_calc()
+        calc.parameters["extra"] += " freq=(HPModes,vcd)"
+        return calc, label

ensemble_analyzer/_calculators/_orca.py

@@ -0,0 +1,91 @@
+from ase.calculators.orca import ORCA, OrcaProfile
+from ensemble_analyzer._calculators.base import BaseCalc, register_calculator
+import shutil
+import os
+
+VERSION = None
+
+try:
+    ORCA_COMMAND = os.getenv("ORCACOMMAND") or shutil.which("orca")
+    orca_profile = OrcaProfile(command=ORCA_COMMAND)
+    VERSION = int(os.getenv("ORCAVERSION")[0])
+except Exception:
+    orca_profile = None
+
+
+@register_calculator("orca")
+class OrcaCalc(BaseCalc):
+    label = "orca"
+    VERSION = VERSION if VERSION else 0
+
+    def common_str(self):
+
+        if self.protocol.solvent:
+            if "xtb" in self.protocol.functional.lower():
+                solv = f"ALPB({self.protocol.solvent.solvent})"
+            elif self.protocol.solvent.solvent.strip():
+                solv = f" {self.protocol.solvent}"
+            else:
+                solv = f" CPCM"
+        else:
+            solv = ""
+
+        si = f"{self.protocol.functional} {self.protocol.basis} {solv} nopop"
+
+        ob = (
+            f"%pal nprocs {self.cpu} end "
+            + self.protocol.add_input.format(CONF=self.conf.folder)
+            + (" %maxcore 5000" if "maxcore" not in self.protocol.add_input else "")
+        )
+
+        return si, ob
+
+    def _std_calc(self):
+        si, ob = self.common_str()
+
+        calculator = ORCA(
+            profile=orca_profile,
+            label="orca",
+            orcasimpleinput=si,
+            orcablocks=ob,
+            charge=self.protocol.charge,
+            mult=self.protocol.mult,
+        )
+
+        if self.protocol.read_orbitals:
+            calculator.parameters["orcasimpleinput"] += " moread"
+            calculator.parameters[
+                "orcablocks"
+            ] += f'\n%moinp "{self.conf.folder}/protocol_{self.protocol.read_orbitals}/{self.conf.number}_p{self.protocol.read_orbitals}_orca.gbw"\n'
+
+        if "freq" in self.protocol.add_input.lower():
+            calculator.parameters["orcablocks"] += "\n%freq vcd true end\n"
+
+        return calculator, "orca"
+
+    def single_point(self):
+        return self._std_calc()
+
+    def optimisation(self):
+        calc, label = self._std_calc()
+        calc.parameters["orcasimpleinput"] += " opt"
+        if self.constrains:
+            text = "\n%geom Constraints "
+            for i in self.constrains:
+                text += " {C " + str(i) + " C}"
+            text += "end end\n"
+            calc.parameters["orcasimpleinput"] += text
+            
+        if self.protocol.freq:
+            calc.parameters["orcasimpleinput"] += " freq"
+            if self.VERSION > 5:
+                calc.parameters["orcablocks"] += "\n%freq vcd true end\n"
+
+        return calc, label
+
+    def frequency(self):
+        calc, label = self._std_calc()
+        calc.parameters["orcasimpleinput"] += " freq"
+        if self.VERSION > 5:
+            calc.parameters["orcablocks"] += "\n%freq vcd true end\n"
+        return calc, label

ensemble_analyzer/_calculators/base.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+
+from typing import Dict
+
+
+def register_calculator(name):
+    """Decorator to register each calculator"""
+
+    def decorator(cls):
+        CALCULATOR_REGISTRY[name.lower()] = cls
+        return cls
+
+    return decorator
+
+
+class BaseCalc(ABC):
+
+    def __init__(self, protocol, cpu: int, conf=None):
+        self.protocol = protocol
+        self.cpu = cpu
+        self.conf = conf
+        self.constrains = protocol.constrains
+
+    @abstractmethod
+    def common_str(self):
+        """String for the solvent definition"""
+        pass
+
+    @abstractmethod
+    def single_point(self):
+        """Create the common ASE calculator"""
+        pass
+
+    @abstractmethod
+    def optimisation(self):
+        """Add to the calculator the opt flag"""
+        pass
+
+    @abstractmethod
+    def frequency(self):
+        """Add to the calculator the opt flag"""
+        pass
+
+CALCULATOR_REGISTRY : Dict[str, BaseCalc]= {}

ensemble_analyzer/_clustering/cluster_config.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from typing import List, Optional
+import numpy as np
+
+
+@dataclass
+class PCAResult:
+    """Results from PCA analysis"""
+    scores              : np.ndarray                # PCA-transformed coordinates (n_conformers, n_components)
+    clusters            : np.ndarray                # Cluster assignments (n_conformers,)
+    colors              : List[str]                 # Conformer colors
+    numbers             : List[int]                 # Conformer IDs
+    energies            : np.ndarray                # Relative energies [Eh]
+    explained_variance  : np.ndarray                # Variance explained by each component
+    n_clusters          : Optional[int]     = None  # Number of clusters used
+
+
+@dataclass
+class ClusteringConfig:
+    """Configuration for clustering operations"""
+    n_clusters              : Optional[int]     = None  # If None, auto-detect optimal
+    include_H               : bool              = True  # Include hydrogen in distance matrix
+    set_cluster_attribute   : bool              = True  # Set cluster ID on Conformer objects
+    min_k                   : int               = 2     # Minimum clusters for silhouette search
+    max_k                   : int               = 30    # Maximum clusters for silhouette search
+    random_state            : int               = 42    # Fix value for reproducibility of the random initiation of cluster points