rdworks 0.25.7__py3-none-any.whl → 0.35.1__py3-none-any.whl

rdworks/mol.py

@@ -1,19 +1,13 @@
-# rdworks/mol.py
-
-import os
-import io
 import copy
-import types
-import pathlib
 import itertools
-import math
 import json
 import logging
 import tempfile
 
+from io import StringIO, BytesIO
+from pathlib import Path
 from collections import defaultdict
 from collections.abc import Callable
-from pathlib import Path
 from typing import Iterator, Self
 
 import numpy as np
@@ -27,34 +21,35 @@ import CDPL.Chem
 import CDPL.ConfGen
 
 from rdkit import Chem, DataStructs
-
 from rdkit.Chem import ( 
     rdMolDescriptors, AllChem, Descriptors, QED, 
     rdFingerprintGenerator,
-    Draw, rdDepictor,
+    Draw, rdDepictor, inchi,
     rdDistGeom, rdMolAlign, rdMolTransforms, rdmolops
     )
 from rdkit.Chem.Draw import rdMolDraw2D
-
 from rdkit.ML.Cluster import Butina
+from PIL import Image
 
-from rdworks.std import desalt_smiles, standardize
+from rdworks.conf import Conf
+from rdworks.std import desalt_smiles, standardize, clean_2d
 from rdworks.xml import list_predefined_xml, get_predefined_xml, parse_xml
 from rdworks.scaffold import rigid_fragment_indices
 from rdworks.descriptor import rd_descriptor, rd_descriptor_f
-from rdworks.display import svg
-from rdworks.utils import convert_tril_to_symm, QT, fix_decimal_places_in_dict
+from rdworks.utils import convert_tril_to_symm, QT, recursive_round
 from rdworks.units import ev2kcalpermol
 from rdworks.autograph import NMRCLUST, DynamicTreeCut, RCKmeans, AutoGraph
 from rdworks.bitqt import BitQT
-from rdworks.conf import Conf
+from rdworks.torsion import create_torsion_fragment, get_torsion_atoms
+from rdworks.display import render_svg, render_png
+
+from scour.scour import scourString
 
 main_logger = logging.getLogger()
 
 
 class Mol:
-    """Container for molecular structure, conformers, and other information.
-    """
+    """Container for molecular structure, conformers, and other information."""
 
     MFP2 = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=2048)
     
@@ -62,100 +57,98 @@ class Mol:
     ETKDG_params.useSmallRingTorsions = True
     ETKDG_params.maxIterations = 2000
         
-
     def __init__(self, 
-                 molecular_input: str | Chem.Mol, 
-                 name:str='', 
-                 std:bool=False,
-                 max_workers:int=1,
-                 chunksize:int=4,
-                 progress:bool=False) -> None:
-        """Create a rdworks.Mol object.
+                 molecule: str | Chem.Mol | Conf | None = None, 
+                 name: str = '', 
+                 std: bool = False,
+                 reset_isotope: bool = True,
+                 remove_H: bool = True,
+                 max_workers: int = 1,
+                 chunksize: int = 4,
+                 progress: bool = False) -> None:
+        """Initialize.
 
         Examples:
-            >>> import rdworks
-            >>> m = rdworks.Mol('c1ccccc1', name='benzene')
+            >>> from rdworks import Mol
+            >>> m = Mol('c1ccccc1', name='benzene')
             
         Args:
-            molecular_input (str | Chem.Mol): SMILES or rdkit.Chem.Mol object
-            name (str, optional): name of the molecule. Defaults to ''.
-            std (bool, optional): whether to standardize the molecule. Defaults to False.
-
-        Raises:
-            ValueError: Invalid SMILES or rdkit.Chem.Mol object.
-            TypeError: No SMILES or rdkit.Chem.Mol object is provided.
-            RuntimeError: Desalting or standardization process failed.
+            molecule (str | Chem.Mol | None): SMILES or rdkit.Chem.Mol or None
+            name (str): name of the molecule. Defaults to ''.
+            std (bool): whether to standardize the molecule. Defaults to False.
+            max_workers (int): number of maximum workers for parallelization. Defaults to 1.
+            chunksize (int): batch size for parallelization. Defaults to 4.
+            progress (bool): whether to show progress bar. Defaults to False.
         """
-
-        self.rdmol = None # rdkit.Chem.Mol object
-        self.smiles = None # isomeric SMILES
-        self.name = None
+        assert isinstance(molecule, str | Chem.Mol | Conf) or molecule is None
+
+        self.rdmol = None # 2D, one and only one Conformer
+        self.smiles = '' # isomeric SMILES
+        self.confs = [] # container for 3D conformers
+        self.name = ''
+        self.InChIKey = '' # 27 characters (SHA-256 hash of InChI)
+        self.InChI = ''
         self.props = {}
-        self.confs = [] # 3D conformers (iterable)
         self.fp = None
         self.max_workers = max_workers
         self.chunksize = chunksize
         self.progress = progress
-        
-        if isinstance(molecular_input, str):
+
+        if molecule is None:
+            return
+
+        if isinstance(molecule, str): # 1-D SMILES           
             try:
-                self.rdmol = Chem.MolFromSmiles(molecular_input)
-                assert self.rdmol
-                self.smiles = Chem.MolToSmiles(self.rdmol)
+                if "." in molecule: # mandatory desalting
+                    (self.smiles, self.rdmol) = desalt_smiles(molecule)
+                else:
+                    self.rdmol = Chem.MolFromSmiles(molecule)
+                    self.smiles = Chem.MolToSmiles(self.rdmol)
             except:
-                raise ValueError(f'Mol() received invalid SMILES: {molecular_input}')
-        elif isinstance(molecular_input, Chem.Mol):
+                raise ValueError(f'Mol() Error: invalid SMILES {molecule}')
+ 
+        elif isinstance(molecule, Chem.Mol): # 2-D or 3-D Chem.Mol
             try:
-                self.rdmol = molecular_input
-                assert self.rdmol
+                self.rdmol, _ = clean_2d(molecule, reset_isotope, remove_H)
                 self.smiles = Chem.MolToSmiles(self.rdmol)
+                self.confs = [Conf(x) for x in _]
             except:
-                raise ValueError('Mol() received invalid rdkit.Chem.Mol object')
-        else:
-            raise TypeError('Mol() expects SMILES or rdkit.Chem.Mol object')
-       
-        ### desalting
-        if "." in self.smiles:
+                raise ValueError(f'Mol() Error: invalid Chem.Mol object')
+            
+        elif isinstance(molecule, Conf): # 3-D input
             try:
-                (self.smiles, self.rdmol) = desalt_smiles(self.smiles)
-                assert self.smiles
-                assert self.rdmol
+                self.rdmol, _ = clean_2d(molecule.rdmol, reset_isotope, remove_H)
+                self.smiles = Chem.MolToSmiles(self.rdmol)
+                self.confs = [molecule]
             except:
-                raise RuntimeError(f'Mol() error occurred in desalting: {self.smiles}')
-        
-        ### standardization
-        if std:
-            # standardization changes self.rdmol
-            try:
+                raise ValueError(f'Mol() Error: invalid Conf object')
+
+        try:
+            if std:
                 self.rdmol = standardize(self.rdmol)
                 self.smiles = Chem.MolToSmiles(self.rdmol)
-                assert self.smiles
-                assert self.rdmol
-            except:
-                raise RuntimeError('Mol() error occurred in standardization')
-        
-        ### naming
+        except:
+            raise RuntimeError('Mol() Error: standardization')
+    
+        assert self.smiles and self.rdmol, "Mol() Error: invalid molecule"
+
+        rdDepictor.Compute2DCoords(self.rdmol)
+
         try:
             self.name = str(name)
         except:
             self.name = 'untitled'
+
         self.rdmol.SetProp('_Name', self.name) # _Name can't be None
-        
-        ### set default properties
+        self.InChI = Chem.MolToInchi(self.rdmol)
+        self.InChIKey = inchi.InchiToInchiKey(self.InChI)
         self.props.update({
             'aka' : [], # <-- to be set by MolLibr.unique()
-            'atoms' : self.rdmol.GetNumAtoms(), 
-            # hydrogens not excluded
-            # m = Chem.MolFromSmiles("c1c[nH]cc1")
-            # m.GetNumAtoms()
-            # >> 5
-            # Chem.AddHs(m).GetNumAtoms()
-            # >> 10
+            'atoms' : self.rdmol.GetNumAtoms(), # hydrogens not excluded?
             'charge': rdmolops.GetFormalCharge(self.rdmol),
-            # number of rotatable bonds
             "nrb" : Descriptors.NumRotatableBonds(self.rdmol),
             })
-           
+
 
     def __str__(self) -> str:
         """String representation of the molecule.
@@ -187,21 +180,21 @@ class Mol:
         return hash(self.smiles)
     
 
-    def __eq__(self, other:object) -> bool:
-        """True if `other` molecule is identical with the molecule.
+    def __eq__(self, other: Self) -> bool:
+        """True if `other` Mol is identical with this Mol.
 
-        It compares canonicalized SMILES.
+        It compares InChIKeys.
 
         Examples:
             >>> m1 == m2
 
         Args:
-            other (object): other rdworks.Mol object.
+            other (object): other Mol object.
 
         Returns:
             bool: True if identical.
         """
-        return self.smiles == other.smiles
+        return self.InChIKey == other.InChIKey
     
 
     def __iter__(self) -> Iterator:
@@ -226,7 +219,7 @@ class Mol:
         return next(self.confs)
     
 
-    def __getitem__(self, index: int | slice) -> Conf:
+    def __getitem__(self, index: int | slice) -> Conf | Self:
         """Conformer object of conformers of the molecule with given index or slice of indexes.
 
         Examples:
@@ -235,31 +228,34 @@ class Mol:
         Args:
             index (int | slice): index for conformers.
 
-        Raises:
-            ValueError: conformers are not defined in the molecule or index is out of range. 
-
         Returns:
-            Conf: Conf object matching the index of the molecule.
+            Conf or Mol(copy) with conformers specified by index.
         """
-        if self.count() == 0:
-            raise ValueError(f"no conformers")
-        try:
-            return self.confs[index]
-        except:
-            raise ValueError(f"index should be 0..{self.count()-1}")
+        assert self.count() > 0, "no conformers"
         
+        if isinstance(index, slice):
+            new_object = self.copy()
+            new_object.confs = new_object.confs[index]
+            return new_object
+        
+        else:
+            return self.confs[index]
 
+        
     def copy(self) -> Self:
         """Returns a copy of self.
 
         Returns:
-            Self: a copy of self (rdworks.Mol) object.
+            a copy of self.
         """
         return copy.deepcopy(self)
 
 
-    def rename(self, prefix:str='', sep:str='/', start:int=1) -> Self:
-        """Rename conformer names and returns self
+    def rename(self, 
+               prefix: str = '', 
+               sep: str = '/', 
+               start: int = 1) -> Self:
+        """Updates name and conformer names.
         
         The first conformer name is {prefix}{sep}{start}
 
@@ -269,11 +265,12 @@ class Mol:
             start (int, optional): first serial number. Defaults to 1.
 
         Returns:
-            Self: rdworks.Mol object.
+            Self: modified self.
         """
         if prefix :
             self.name = prefix
             self.rdmol.SetProp('_Name', prefix)
+        
         # update conformer names
         num_digits = len(str(self.count())) # ex. '100' -> 3
         for (serial, conf) in enumerate(self.confs, start=start):
@@ -281,11 +278,13 @@ class Mol:
             while len(serial_str) < num_digits:
                 serial_str = '0' + serial_str
             conf.rename(f'{self.name}{sep}{serial_str}')
+        
         return self
     
 
-    def qed(self, properties:list[str]=['QED', 'MolWt', 'LogP', 'TPSA', 'HBD']) -> Self:
-        """Updates quantitative estimate of drug-likeness (QED).
+    def qed(self, 
+            properties: list[str] = ['QED', 'MolWt', 'LogP', 'TPSA', 'HBD']) -> Self:
+        """Updates quantitative estimate of drug-likeness (QED) and other descriptors.
 
         Args:
             properties (list[str], optional): Defaults to ['QED', 'MolWt', 'LogP', 'TPSA', 'HBD'].
@@ -294,53 +293,54 @@ class Mol:
             KeyError: if property key is unknown.
 
         Returns:
-            Self: rdworks.Mol object.
+            Self: modified self.
         """
         props_dict = {}
         for k in properties:
             try:
                 props_dict[k] = rd_descriptor_f[k](self.rdmol)
             except:
-                raise KeyError(f'Mol.qed() received undefined property {k} for {self}')
+                raise KeyError(f'qed() Error: unknown property {k}')
         self.props.update(props_dict)
+        
         return self
     
 
     def remove_stereo(self) -> Self:
-        """Removes stereochemistry and returns a copy of self. 
+        """Removes stereochemistry. 
 
         Examples:
-            >>> m = rdworks.Mol("C/C=C/C=C\\C", "double_bond")
+            >>> m = Mol("C/C=C/C=C\\C", "double_bond")
             >>> m.remove_stereo().smiles == "CC=CC=CC"
 
         Returns:
-            Self: rdworks.Mol object.
+            Self: modified self.
         """
-        obj = copy.deepcopy(self)
         # keep the original stereo info. for ring double bond
-        Chem.RemoveStereochemistry(obj.rdmol)
-        Chem.AssignStereochemistry(obj.rdmol, 
+        Chem.RemoveStereochemistry(self.rdmol)
+        Chem.AssignStereochemistry(self.rdmol, 
                                    cleanIt=False, 
                                    force=False, 
                                    flagPossibleStereoCenters=False)
-        obj.smiles = Chem.MolToSmiles(obj.rdmol)
-        return obj
+        self.smiles = Chem.MolToSmiles(self.rdmol)
+
+        return self
 
 
     def make_confs(self, 
                    n:int = 50, 
-                   method:str = 'RDKit_ETKDG',
-                   calculator:str | Callable = 'MMFF94') -> Self:
+                   method:str = 'ETKDG', 
+                   calculator:str | Callable = 'MMFF94',
+                   ) -> Self:
         """Generates 3D conformers.
 
         Args:
             n (int, optional): number of conformers to generate. Defaults to 50.
             method (str, optional): conformer generation method.
-                Choices are `RDKit_ETKDG`, `CDPL_CONFORGE`.
-                Defaults to 'RDKit_ETKDG'.
+                Choices are `ETKDG`, `CONFORGE`. Defaults to 'ETKDG'.
 
         Returns:
-            Self: rdworks.Mol object
+            Self: modified self.
 
         Reference:
             T. Seidel, C. Permann, O. Wieder, S. M. Kohlbacher, T. Langer, 
@@ -355,9 +355,9 @@ class Mol:
         
         self.confs = []
 
-        if method.upper() == 'RDKIT_ETKDG':
+        if method.upper() == 'ETKDG':
             rdmol_H = Chem.AddHs(self.rdmol, addCoords=True) # returns a copy with hydrogens added
-            conf_ids = rdDistGeom.EmbedMultipleConfs(rdmol_H, n, params=self.ETKDG_params)
+            conf_ids = rdDistGeom.EmbedMultipleConfs(rdmol_H, numConfs=n, params=self.ETKDG_params)
             for rdConformer in rdmol_H.GetConformers():
                 # number of atoms should match with conformer(s)
                 rdmol_conf = Chem.Mol(rdmol_H)
@@ -366,7 +366,7 @@ class Mol:
                 conf = Conf(rdmol_conf)
                 self.confs.append(conf)
         
-        elif method.upper() == 'CDPL_CONFORGE':
+        elif method.upper() == 'CONFORGE':
             with tempfile.NamedTemporaryFile() as tmpfile:
                 mol = CDPL.Chem.parseSMILES(self.smiles)
                 # create and initialize an instance of the class ConfGen.ConformerGenerator which
@@ -415,7 +415,7 @@ class Mol:
 
         # energy evaluations for ranking
         for conf in self.confs:
-            conf.get_potential_energy(calculator) # default: MMFF94
+            conf.potential_energy(calculator) # default: MMFF94
         
         # set relative energy, E_rel(kcal/mol)
         sort_by = 'E_tot(kcal/mol)'
@@ -424,50 +424,97 @@ class Mol:
         for conf in self.confs:
             conf.props.update({"E_rel(kcal/mol)": conf.props[sort_by] - lowest_energy})
 
-        return self.rename()
+        self = self.rename()
+
+        return self
 
 
-    def optimize(self, calculator:str | Callable = 'MMFF94', fmax:float=0.05) -> Self:
-        """Optimizes 3D conformers
+    def optimize_confs(self, 
+                       calculator: str | Callable = 'MMFF94', 
+                       fmax: float = 0.05, 
+                       max_iter: int = 1000,
+                       ) -> Self:
+        """Optimizes 3D geometry of conformers.
 
         Args:
-            calculator (str | Callable): _description_
-            fmax (float, optional): _description_. Defaults to 0.05.
+            calculator (str | Callable): MMFF94 (= MMFF), MMFF94s, UFF, or ASE calculator.
+                `MMFF94` or `MMFF` - Intended for general use, including organic molecules and proteins, 
+                    and primarily relies on data from quantum mechanical calculations. 
+                    It's often used in molecular dynamics simulations.
+                `MMFF94s` - A "static" variant of MMFF94, with adjusted parameters for out-of-plane 
+                    bending and dihedral torsions to favor planar geometries for specific nitrogen atoms. 
+                    This makes it better suited for geometry optimization studies where a static, 
+                    time-averaged structure is desired. The "s" stands for "static".
+                `UFF` - UFF refers to the "Universal Force Field," a force field model used for 
+                    molecular mechanics calculations. It's a tool for geometry optimization, 
+                    energy minimization, and exploring molecular conformations in 3D space. 
+                    UFF is often used to refine conformers generated by other methods, 
+                    such as random conformer generation, to produce more physically plausible 
+                    and stable structures.
+            fmax (float, optional): fmax for the calculator convergence. Defaults to 0.05.
+            max_iter (int, optional): max iterations for the calculator. Defaults to 1000.
 
         Returns:
-            Self: _description_
+            Self: modified self.
         """
-        self.confs = [ conf.optimize(calculator, fmax) for conf in self.confs ]
+        self.confs = [ conf.optimize(calculator, fmax, max_iter) for conf in self.confs ]
+
         return self
 
 
-    def sort_confs(self) -> Self:
-        """Sorts conformers by `E_tot(eV)` or `E_tot(kcal/mol)` and sets `E_rel(kcal/mol)`. 
+    def sort_confs(self, calculator: str | Callable | None = None) -> Self:
+        """Sorts by `E_tot(kcal/mol)` or `E_tot(eV)` and sets `E_rel(kcal/mol)`. 
 
+        Args:
+            calculator (str | Callable | None): MMFF94 (= MMFF), MMFF94s, UFF, or ASE calculator.
+                `MMFF94` or `MMFF` - Intended for general use, including organic molecules and proteins, 
+                    and primarily relies on data from quantum mechanical calculations. 
+                    It's often used in molecular dynamics simulations.
+                `MMFF94s` - A "static" variant of MMFF94, with adjusted parameters for out-of-plane 
+                    bending and dihedral torsions to favor planar geometries for specific nitrogen atoms. 
+                    This makes it better suited for geometry optimization studies where a static, 
+                    time-averaged structure is desired. The "s" stands for "static".
+                `UFF` - UFF refers to the "Universal Force Field," a force field model used for 
+                    molecular mechanics calculations. It's a tool for geometry optimization, 
+                    energy minimization, and exploring molecular conformations in 3D space. 
+                    UFF is often used to refine conformers generated by other methods, 
+                    such as random conformer generation, to produce more physically plausible 
+                    and stable structures.
         Raises:
             KeyError: if `E_tot(eV)` or `E_tot(kcal/mol)` is not defined.
 
         Returns:
-            Self: rdworks.Mol object.
+            Self: modified self.
         """
-        if all(['E_tot(eV)' in c.props for c in self.confs]):
-            sort_by = 'E_tot(eV)'
-            conversion = 23.060547830619026  # eV to kcal/mol
-        elif all(['E_tot(kcal/mol)' in c.props for c in self.confs]):
+        if calculator is not None:
+            # re-calculate potential energies
+            for conf in self.confs:
+                PE = conf.potential_energy(calculator=calculator) # sets `E_tot(kcal/mol)`
+
+        if all(['E_tot(kcal/mol)' in conf.props for conf in self.confs]):
             sort_by = 'E_tot(kcal/mol)'
             conversion = 1.0
+
+        elif all(['E_tot(eV)' in conf.props for conf in self.confs]):
+            sort_by = 'E_tot(eV)'
+            conversion = ev2kcalpermol  # eV to kcal/mol
+        
         else:
-            raise KeyError(f'Mol.sort_confs() requires E_tot(eV) or E_tot(kcal/mol) property')
-        self.confs = sorted(self.confs, key=lambda c: c.props[sort_by]) # ascending order
+            raise KeyError(f'sort_confs() requires `E_tot(eV)` or `E_tot(kcal/mol)` property')
+        
+        # ascending order
+        self.confs = sorted(self.confs, key=lambda c: c.props[sort_by])
+
         if self.count() > 0:
-            E_lowest = self.confs[0].props[sort_by]
+            E_min = self.confs[0].props[sort_by]
             for conf in self.confs:
-                E_rel = (conf.props[sort_by] - E_lowest)* conversion
+                E_rel = conversion * (conf.props[sort_by] - E_min)
                 conf.props.update({"E_rel(kcal/mol)": E_rel})
+        
         return self
     
 
-    def align_confs(self, method:str='rigid_fragment') -> Self:
+    def align_confs(self, method: str = 'rigid_fragment') -> Self:
         """Aligns all conformers to the first conformer.
 
         Args:
@@ -476,7 +523,7 @@ class Mol:
                 Defaults to `rigid_fragment`.
 
         Returns:
-            Self: rdworks.Mol object.
+            Self: modified self.
         """
 
         if self.count() < 2: # nothing to do
@@ -527,7 +574,10 @@ class Mol:
         return self
     
 
-    def cluster_confs(self, method:str='QT', threshold:float=1.0, sortby:str='size') -> Self:
+    def cluster_confs(self, 
+                      method: str = 'QT', 
+                      threshold: float = 1.0, 
+                      sort: str = 'size') -> Self:
         """Clusters all conformers and sets cluster properties.
         
         Following cluster properties will be added: `cluster`, `cluster_mean_energy`, 
@@ -546,14 +596,14 @@ class Mol:
                 `AutoGraph`.
                 Defaults to `QT`.
             threshold (float, optional): RMSD threshold of a cluster. Defaults to 1.0.
-            sortby (str, optional): sort cluster(s) by mean `energy` or cluster `size`. 
+            sort (str, optional): sort cluster(s) by mean `energy` or cluster `size`. 
                 Defaults to `size`.
 
         Raises:
             NotImplementedError: if unsupported method is requested.
 
         Returns:
-            Self: rdworks.Mol object
+            Self: modified self.
         """
         if method != 'DQT': # rmsd of x,y,z coordinates (non-H)
             conf_rdmols_noH = [Chem.RemoveHs(Chem.Mol(conf.rdmol)) for conf in self.confs]
@@ -572,7 +622,7 @@ class Mol:
             torsions = []
             for conf in self.confs:
                 t_radians = []
-                for (i, j, k, l, rot_indices, fix_indices) in torsion_atom_indices:
+                for torsion_key, (i, j, k, l) in torsion_atom_indices.items():
                     t_radians.append(
                         rdMolTransforms.GetDihedralRad(conf.rdmol.GetConformer(), i, j, k, l))
                 torsions.append(np.array(t_radians))
@@ -664,14 +714,14 @@ class Mol:
                                      'iqr_energy' : iqr_energy,
                                      })
             # sort cluster index
-            if sortby == 'size':
+            if sort == 'size':
                 cluster_list = sorted(cluster_list, key=lambda x: x['size'], reverse=True)
             
-            elif sortby == 'energy':
+            elif sort == 'energy':
                 cluster_list = sorted(cluster_list, key=lambda x: x['median_energy'], reverse=False)
             
             else:
-                raise NotImplementedError(f'{sortby} is not implemented yet.')
+                raise NotImplementedError(f'{sort} is not implemented yet.')
 
             for cluster_idx, cluster_dict in enumerate(cluster_list, start=1):
                 for conf_idx in cluster_dict['confs']:
@@ -697,10 +747,10 @@ class Mol:
 
 
     def drop_confs(self,
-                   stereo_flipped:bool=True,
-                   unconverged:bool=True,
+                   stereo_flipped: bool = True,
+                   unconverged: bool = True,
                    similar: bool | None = None,
-                   similar_rmsd:float=0.3,
+                   similar_rmsd: float = 0.3,
                    cluster: bool | None =None,
                    k: int | None = None,
                    window: float | None = None,
@@ -718,39 +768,46 @@ class Mol:
             k (int, optional): drop all except for `k` lowest energy conformers.
             window (float, optional): drop all except for conformers within `window` of relative energy.
         
-        Returns:
-            Self: a copy of rdworks.Mol object.
-
         Examples:
             To drop similar conformers within rmsd of 0.5 A
             >>> mol.drop_confs(similar=True, similar_rmsd=0.5)
             
             To drop conformers beyond 5 kcal/mol
             >>> mol.drop_confs(window=5.0)
-            
+
+        Returns:
+            Self: modified self.    
         """
-        obj = copy.deepcopy(self)
+
+        reasons = [f'stereo flipped',  
+                   f'unconverged', 
+                   f'similar({similar_rmsd})',
+                   f'cluster(non-centroid)',
+                   f'k and/or energy window',
+                   ]
+        
+        w = max([len(s) for s in reasons])
                
-        if stereo_flipped and obj.count() > 0:
-            mask = [Chem.MolToSmiles(Chem.RemoveHs(_.rdmol)) == obj.smiles for _ in obj.confs]
-            obj.confs = list(itertools.compress(obj.confs, mask))
+        if stereo_flipped and self.count() > 0:
+            mask = [Chem.MolToSmiles(Chem.RemoveHs(_.rdmol)) == self.smiles for _ in self.confs]
+            self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs stereo_flipped={mask.count(False)} -> {obj.count()}')
+                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[0]:<{w}} -> {self.count()}')
         
-        if unconverged and obj.count() > 0:
-            mask = [_.props['Converged'] if 'Converged' in _.props else True for _ in obj.confs]
-            obj.confs = list(itertools.compress(obj.confs, mask))
+        if unconverged and self.count() > 0:
+            mask = [_.props['Converged'] if 'Converged' in _.props else True for _ in self.confs]
+            self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs unconverged={mask.count(False)} -> {obj.count()}')
+                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[1]:<{w}} -> {self.count()}')
 
-        if similar and obj.count() > 1:
+        if similar and self.count() > 1:
             # it is observed that there are essentially identical conformers 
             # such as 180-degree ring rotation and there is not minor conformational variations
             # in the RDKit ETKDG generated conformers.
-            conf_rdmols_noH = [Chem.RemoveHs(Chem.Mol(_.rdmol)) for _ in obj.confs]
+            conf_rdmols_noH = [Chem.RemoveHs(Chem.Mol(_.rdmol)) for _ in self.confs]
             # copies are made for rmsd calculations to prevent coordinates changes
             lower_triangle_values = []
-            for i in range(obj.count()): # number of conformers
+            for i in range(self.count()): # number of conformers
                 for j in range(i):
                     # rdMolAlign.GetBestRMS takes symmetry into account
                     # removed hydrogens to speed up
@@ -758,10 +815,10 @@ class Mol:
                     lower_triangle_values.append(best_rms)
             symm_matrix = convert_tril_to_symm(lower_triangle_values)
             cluster_assignment, centroid_indices = QT(symm_matrix, similar_rmsd)
-            mask = [conf_idx in centroid_indices for conf_idx, conf in enumerate(obj.confs)]
-            obj.confs = list(itertools.compress(obj.confs, mask))
+            mask = [conf_idx in centroid_indices for conf_idx, conf in enumerate(self.confs)]
+            self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs similar({similar_rmsd})={mask.count(False)} -> {obj.count()}')
+                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[2]:<{w}} -> {self.count()}')
 
             # note: it will retain the conformers with lower index
             # so, it should be sorted before dropping
@@ -781,29 +838,29 @@ class Mol:
             #         retained_confs.append(Chem.RemoveHs(conf_i.rdmol)) # store a copy of H-removed rdmol
             # obj.confs = list(itertools.compress(obj.confs, mask))
         
-        if cluster and obj.count() > 1:
+        if cluster and self.count() > 1:
             # drop non-centroid cluster member(s)
-            mask = [_.props['centroid'] if 'centroid' in _.props else True for _ in obj.confs]
-            obj.confs = list(itertools.compress(obj.confs, mask))
+            mask = [_.props['centroid'] if 'centroid' in _.props else True for _ in self.confs]
+            self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs cluster(non-centroid)={mask.count(False)} -> {obj.count()}')
+                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[3]:<{w}} -> {self.count()}')
 
-        if (k or window) and obj.count() > 0:
+        if (k or window) and self.count() > 0:
             if k:
-                mask_k = [i < k for i,_ in enumerate(obj.confs)]
+                mask_k = [i < k for i,_ in enumerate(self.confs)]
             else:
-                mask_k = [True,] * obj.count()
+                mask_k = [True,] * self.count()
             if window:
-                mask_window = [_.props['E_rel(kcal/mol)'] < window if 'E_rel(kcal/mol)' in _.props else True for _ in obj.confs]
+                mask_window = [_.props['E_rel(kcal/mol)'] < window if 'E_rel(kcal/mol)' in _.props else True for _ in self.confs]
             else:
-                mask_window = [True,] * obj.count()
+                mask_window = [True,] * self.count()
             # retain conformer(s) that satisfy both k and window conditions
             mask = [(x and y) for (x,y) in zip(mask_k, mask_window)]
-            obj.confs = list(itertools.compress(obj.confs, mask))
+            self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs k and/or window={mask.count(False)} -> {obj.count()}')
+                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[4]:<{w}} -> {self.count()}')
         
-        return obj
+        return self
 
 
     def count(self) -> int:
@@ -815,7 +872,7 @@ class Mol:
         return len(self.confs)
     
 
-    def is_nn_applicable(self,  model:str) -> bool:
+    def nnp_ready(self,  model: str = 'aimnet2') -> bool:
         """Check if a particular neural network model is applicable to current molecule.
 
         Args:
@@ -833,19 +890,18 @@ class Mol:
             # H, C, N, O, F, S, Cl
             atomic_numbers = [1, 6, 7, 8, 9, 16, 17 ]
         
-        elif model in ['aimnet', 'aimnet2']:
+        elif model.lower() in ['aimnet', 'aimnet2']:
             # H, B, C, N, O, F, Si, P, S, Cl, As, Se, Br, I
             atomic_numbers = [1, 5, 6, 7, 8, 9, 14, 15, 16, 17, 33, 34, 35, 53 ]
         
         else:
-            raise ValueError('is_nn_applicable() supports ANI-2x, ANI-2xt, or AIMNET')
+            raise ValueError('nnp_ready() supports ANI-2x, ANI-2xt, AIMNet, or AIMNet2')
         
-        for a in self.rdmol.GetAtoms():
-            if a.GetAtomicNum() not in atomic_numbers:
-                return False
+        if all([ a.GetAtomicNum() in atomic_numbers for a in self.rdmol.GetAtoms() ]):
+            return True
+        else:
+            return False
             
-        return True
-
 
     def charge(self) -> int:
         """Returns molecular formal charge
@@ -862,7 +918,7 @@ class Mol:
         Returns:
             list: list of element symbols.
         """
-        return [ a.GetSymbol() for a in self.rdmol.GetAtoms() ]
+        return [atom.GetSymbol() for atom in self.rdmol.GetAtoms()]
 
 
     def numbers(self) -> list[int]:
@@ -871,111 +927,19 @@ class Mol:
         Returns:
             list: list of atomic numbers.
         """
-        return [ a.GetAtomicNum() for a in self.rdmol.GetAtoms() ]
+        return [atom.GetAtomicNum() for atom in self.rdmol.GetAtoms()]
     
 
-    def torsion_atoms(self, strict:bool=True) -> list[tuple]:
-        """Determine dihedral angle atoms (a-b-c-d) and rotating group for each rotatable bond (b-c).
+    def torsion_atoms(self, strict: bool = True) -> dict[int, tuple]:
+        """Determine torsion/dihedral angle atoms (i-j-k-l) and rotating group for each rotatable bond (j-k).
 
         Args:
             strict (bool): whether to exclude amide/imide/ester/acid bonds.
 
         Returns:
-            [   (a, b, c, d, rot_atom_indices, fix_atom_indices), 
-                (a, b, c, d, rot_atom_indices, fix_atom_indices), 
-                ...,
-            ]
+            {torsion_key: (i, j, k, l), ...,}
         """
-        # https://github.com/rdkit/rdkit/blob/1bf6ef3d65f5c7b06b56862b3fb9116a3839b229/rdkit/Chem/Lipinski.py#L47%3E
-        # https://github.com/rdkit/rdkit/blob/de602c88809ea6ceba1e8ed50fd543b6e406e9c4/Code/GraphMol/Descriptors/Lipinski.cpp#L108
-        if strict :
-            # excludes amide/imide/ester/acid bonds
-            rotatable_bond_pattern = Chem.MolFromSmarts(
-                (
-                "[!$(*#*)&!D1&!$(C(F)(F)F)&!$(C(Cl)(Cl)Cl)&!$(C(Br)(Br)Br)&!$(C([CH3])("
-                "[CH3])[CH3])&!$([CD3](=[N,O,S])-!@[#7,O,S!D1])&!$([#7,O,S!D1]-!@[CD3]="
-                "[N,O,S])&!$([CD3](=[N+])-!@[#7!D1])&!$([#7!D1]-!@[CD3]=[N+])]-,:;!@[!$"
-                "(*#*)&!D1&!$(C(F)(F)F)&!$(C(Cl)(Cl)Cl)&!$(C(Br)(Br)Br)&!$(C([CH3])(["
-                "CH3])[CH3])]"
-                )
-            )
-        else:
-            rotatable_bond_pattern = Chem.MolFromSmarts('[!$(*#*)&!D1]-&!@[!$(*#*)&!D1]')
-        rotatable_bonds = self.rdmol.GetSubstructMatches(rotatable_bond_pattern)
-        torsion_angle_atom_indices = []
-
-        # small rings (n=3 or 4)
-        small_rings = [ r for r in list(self.rdmol.GetRingInfo().AtomRings()) if len(r) < 5 ]
-        # ex. = [(1, 37, 35, 34, 3, 2), (29, 28, 30)]
-
-        forbidden_terminal_nuclei = [1, 9, 17, 35, 53] # H,F,Cl,Br,I
-
-        for (b_idx, c_idx) in rotatable_bonds:
-            # determine a atom ``a`` that define a dihedral angle 
-            a_candidates = []
-            for neighbor in self.rdmol.GetAtomWithIdx(b_idx).GetNeighbors():
-                neighbor_idx = neighbor.GetIdx()
-                if neighbor_idx == c_idx:
-                    continue
-                neighbor_atomic_num = neighbor.GetAtomicNum()
-                if neighbor_atomic_num not in forbidden_terminal_nuclei:
-                    a_candidates.append((neighbor_atomic_num, neighbor_idx))
-            
-            if not a_candidates:
-                continue
-            
-            (a_atomic_num, a_idx) = sorted(a_candidates, key=lambda x: (x[0], -x[1]), reverse=True)[0]
-
-            # is a-b in a small ring (n=3 or 4)?
-            is_in_small_ring = False
-            for small_ring in small_rings:
-                if (a_idx in small_ring) and (b_idx in small_ring):
-                    is_in_small_ring = True
-                    break
-            
-            if is_in_small_ring:
-                continue
-
-            # determine a atom ``d`` that define a dihedral angle
-            d_candidates = []
-            for neighbor in self.rdmol.GetAtomWithIdx(c_idx).GetNeighbors():
-                neighbor_idx = neighbor.GetIdx()
-                if (neighbor_idx == b_idx):
-                    continue
-                neighbor_atomic_num = neighbor.GetAtomicNum()
-                if neighbor_atomic_num not in forbidden_terminal_nuclei:
-                    d_candidates.append((neighbor_atomic_num, neighbor_idx))
-            
-            if not d_candidates:
-                continue
-            
-            (d_atomic_num, d_idx) = sorted(d_candidates, key=lambda x: (x[0], -x[1]), reverse=True)[0]
-
-            # is c-d in a small ring?
-            is_in_small_ring = False
-            for small_ring in small_rings:
-                if (c_idx in small_ring) and (d_idx in small_ring):
-                    is_in_small_ring = True
-                    break
-            
-            if is_in_small_ring:
-                continue
-
-            # determine a group of atoms to be rotated
-            # https://ctr.fandom.com/wiki/Break_rotatable_bonds_and_report_the_fragments
-            em = Chem.EditableMol(self.rdmol)
-            em.RemoveBond(b_idx, c_idx)
-            fragmented = em.GetMol()
-            (frag1, frag2) = Chem.GetMolFrags(fragmented, asMols=False) # returns tuple of tuple
-            hac1 = sum([ 1 for i in frag1 if self.rdmol.GetAtomWithIdx(i).GetAtomicNum() > 1 ])
-            hac2 = sum([ 1 for i in frag2 if self.rdmol.GetAtomWithIdx(i).GetAtomicNum() > 1 ])
-            
-            # smaller fragment will be rotated and must contain at least three heavy atoms
-            if min(hac1, hac2) >= 3:
-                (frag_rot, frag_fix) = sorted([(hac1, frag1), (hac2, frag2)])
-                torsion_angle_atom_indices.append((a_idx, b_idx, c_idx, d_idx, frag_rot[1], frag_fix[1]))
-
-        return torsion_angle_atom_indices
+        return {i: d[:4] for i, d in enumerate(get_torsion_atoms(self.rdmol, strict))}
 
 
     def compute(self, **kwargs) -> Self:
@@ -987,147 +951,152 @@ class Mol:
             progress (bool): whether to show progress bar.
 
         Returns:
-            Self: rdworks.MolLibr object.
+            Self: modified self.
         """
         self.max_workers = kwargs.get('max_workers', self.max_workers)
         self.chunksize = kwargs.get('chunksize', self.chunksize)
         self.progress = kwargs.get('progress', self.progress)
+        
         return self
     
 
-    @staticmethod
-    def _map_optimize_conf(conf:Conf, targs:tuple) -> Conf:
-        """A map function to apply Conf.optimize() on `conf`.
-
-        The default behavior of map() is to pass the elements of the iterable to the function by reference. 
-        This means that if the function modifies the elements of the iterable, 
-        those changes will be reflected in the iterable itself.
-
-        Args:
-            conf (Conf): subject rdworks.Conf object.
-            targs (tuple): tuple of arguments to be passed to Conf.optimize().
-
-        Returns:
-            Conf: rdworks.Conf object
-        """
-        return conf.optimize(*targs)
-    
-
     def torsion_energies(self,
-                         calculator:str | Callable, 
-                         fmax:float = 0.05,
-                         interval:float = 15.0,
+                         calculator: str | Callable,
+                         torsion_key: int | None = None,
+                         simplify: bool = True, 
+                         fmax: float = 0.05,
+                         interval: float = 20.0,
                          use_converged_only: bool = True,
-                         optimize_ref: bool = False,
                          **kwargs,
                          ) -> Self:
         """Calculates potential energy profiles for each torsion angle using ASE optimizer.
 
+        It uses the first conformer as a reference.
+
         Args:
             calculator (str | Callable): 'MMFF', 'UFF', or ASE calculator.
+            torsion_key (int | None): torsion index to calculate. Defaults to None (all).
+            simplify (bool, optional): whether to use fragment surrogate. Defaults to True.
             fmax (float, optional): fmax of ASE optimizer. Defaults to 0.05.
             interval (float, optional): interval of torsion angles in degree. Defaults to 15.0.
             use_converged_only (bool, optional): whether to use only converged data. Defaults to True.
 
         Returns:
-            list[dict]: [{'indices':list, 'angle':list, 'E_rel(kcal/mol)':list}, ...]
+            Self: modified self.
         """
+        assert self.count() > 0, "torsion_energies() requires at least one conformer"
+
         self = self.compute(**kwargs)
 
-        torsion_atoms_indices = self.torsion_atoms()
-
-        ref_conf = self.confs[0].copy() # use the lowest energy conformer as a reference
-        if optimize_ref:
-            ref_conf = ref_conf.optimize(calculator, fmax)
-
-        # mol.confs will be populated with torsion conformers. 
-        # It is designed for a batch optimization in the future.
-        mol = self.copy()
-        mol.confs = []
-        data = []
-
-        for k, (a, b, c, d, rot_indices, fix_indices) in enumerate(torsion_atoms_indices):
-            data.append({'angle':[], 'init':[], 'final':[], 'Converged':[]})
-            for angle in np.arange(-180.0, 180.0, interval): 
-                # Iterated numpy.ndarray does not contain the last 180: -180., ..., (180).
-                x = ref_conf.copy()
-                x.props.update({'torsion_index': k, 'angle': float(angle)})
-                AllChem.SetDihedralDeg(x.rdmol.GetConformer(), a, b, c, d, angle)
-                # All atoms bonded to atom d will move.
-                mol.confs.append(x)
-
-        # Optimize
-        # with ProcessPoolExecutor(max_workers=self.max_workers) as executor:
-        #     largs = [ (calculator, fmax,) ] * mol.count()
-        #     if self.progress:
-        #         lconfs = list(tqdm(
-        #             executor.map(Mol._map_optimize_conf, mol.confs, largs, chunksize=1),
-        #             desc="Optimize conformers",
-        #             total=mol.count()))
-        #     else:
-        #         lconfs = list(
-        #             executor.map(Mol._map_optimize_conf, mol.confs, largs, chunksize=1))
-        #     mol.confs = lconfs
-
-        # Calculate relaxation energies
-        for conf in mol.confs:
-            conf = conf.optimize(calculator, fmax)
-            # conf.optimize() updates coordinates and conf.props: 
-            #   `angle`, `E_tot_init(kcal/mol)`, `E_tot(kcal/mol)`, `Converged`.
-            i = conf.props['torsion_index']
-            data[i]['angle'].append(conf.props['angle'])
-            data[i]['init'].append(conf.props['E_tot_init(kcal/mol)'])
-            data[i]['final'].append(conf.props['E_tot(kcal/mol)'])
-            data[i]['Converged'].append(conf.props['Converged'])
+        if torsion_key is None:
+            torsion_atoms_indices = self.torsion_atoms()
+        else:
+            torsion_atoms_indices = {torsion_key: self.torsion_atoms()[torsion_key]}
+
+        ref_conf = self.confs[0].copy()
+
+        data = {}
+
+        if simplify:
+            for tk, indices in torsion_atoms_indices.items():
+                frag, frag_ijkl = create_torsion_fragment(ref_conf.rdmol, indices)
+                frag_conf = Conf(frag)
+                data[tk] = {'indices': indices, 'angle':[], 'init':[], 'last':[], 'Converged':[]}
+                for angle in np.arange(-180.0, 180.0, interval): 
+                    # Iterated numpy.ndarray does not contain the last 180: -180., ..., (180).
+                    conf = frag_conf.copy()
+                    conf.props.update({'torsion_key': tk, 'angle': float(angle)})
+                    conf.set_torsion(*frag_ijkl, angle) # atoms bonded to `l` move.
+                    conf = conf.optimize(calculator, fmax, **kwargs)
+                    # conf.optimize() updates coordinates and conf.props: 
+                    #   `angle`, `E_tot_init(kcal/mol)`, `E_tot(kcal/mol)`, `Converged`.
+                    tk = conf.props['torsion_key']
+                    data[tk]['angle'].append(conf.props['angle'])
+                    data[tk]['init'].append(conf.props['E_tot_init(kcal/mol)'])
+                    data[tk]['last'].append(conf.props['E_tot(kcal/mol)'])
+                    data[tk]['Converged'].append(conf.props['Converged'])
+                    frag_cleaned, _ = clean_2d(frag, reset_isotope=True, remove_H=True)
+                    rdDepictor.Compute2DCoords(frag_cleaned)
+                    # to serialize the molecule
+                    data[tk]['frag'] = Chem.MolToMolBlock(frag_cleaned)
+                    data[tk]['frag_indices'] = frag_ijkl
+
+        else:
+            # mol.confs will be populated with torsion conformers. 
+            # It is designed for a batch optimization in the future.
+            mol = self.copy()
+            mol.confs = []
+            for tk, indices in torsion_atoms_indices.items():
+                data[tk] = {'indices': indices, 'angle':[], 'init':[], 'last':[], 'Converged':[]}
+                for angle in np.arange(-180.0, 180.0, interval): 
+                    # Iterated numpy.ndarray does not contain the last 180: -180., ..., (180).
+                    x = ref_conf.copy()
+                    x.props.update({'torsion_key': tk, 'angle': float(angle)})
+                    x.set_torsion(*indices, angle) # atoms bonded to `l` move.
+                    mol.confs.append(x)
+
+            # Calculate relaxation energies
+            for conf in mol.confs:
+                conf = conf.optimize(calculator, fmax, **kwargs)
+                # conf.optimize() updates coordinates and conf.props: 
+                #   `angle`, `E_tot_init(kcal/mol)`, `E_tot(kcal/mol)`, `Converged`.
+                tk = conf.props['torsion_key']
+                data[tk]['angle'].append(conf.props['angle'])
+                data[tk]['init'].append(conf.props['E_tot_init(kcal/mol)'])
+                data[tk]['last'].append(conf.props['E_tot(kcal/mol)'])
+                data[tk]['Converged'].append(conf.props['Converged'])
         
         # Post-processing
-        torsion_energy_profiles = []
-        for indices, datadict in zip(torsion_atoms_indices, data):
+        torsion_energy_profiles = {}
+        for tk, dictdata in data.items():
             if use_converged_only:
-                datadict['angle'] = list(itertools.compress(datadict['angle'], datadict['Converged']))
-                datadict['init'] = list(itertools.compress(datadict['init'], datadict['Converged']))
-                datadict['final'] = list(itertools.compress(datadict['final'], datadict['Converged']))
-            relax = np.array(datadict['init']) - np.median(datadict['final'])
+                dictdata['angle'] = list(itertools.compress(dictdata['angle'], dictdata['Converged']))
+                dictdata['init'] = list(itertools.compress(dictdata['init'], dictdata['Converged']))
+                dictdata['last'] = list(itertools.compress(dictdata['last'], dictdata['Converged']))
+            relax = np.array(dictdata['init']) - np.median(dictdata['last'])
             E_rel = relax - np.min(relax)
-            torsion_energy_profiles.append({
-                'indices': indices, # (a, b, c, d, rot_indices, fix_indices)
-                'angle': np.array(datadict['angle']).tolist(), # np.ndarray -> list for serialization
-                'E_rel(kcal/mol)': E_rel.tolist(), # np.ndarray -> list for serialization
-                })
+            torsion_energy_profiles[tk] = {
+                'indices' : dictdata['indices'],
+                'angle' : np.round(np.array(dictdata['angle']), 1).tolist(), # np.ndarray -> list for serialization
+                'E_rel(kcal/mol)': np.round(E_rel, 2).tolist(), # np.ndarray -> list for serialization
+                'frag' : dictdata.get('frag', None),
+                'frag_indices' : dictdata.get('frag_indices', None),
+                }
+
         self.props['torsion'] = torsion_energy_profiles
         self.props['torsion_calculator'] = str(calculator)
 
         return self
 
 
-
-
-    def similarity(self, other:object) -> float:
-        """Returns Tanimoto similarity with `other` rdworks.Mol object.
+    def similarity(self, other: Self) -> float:
+        """Returns Tanimoto similarity with other Mol object.
 
         Args:
-            other (rdworks.Mol): other rdworks.Mol object.
+            other (Mol): other Mol object.
 
         Raises:
-            TypeError: if `other` is not rdworks.Mol object type.
+            TypeError: if `other` is not Mol object type.
 
         Returns:
             float: Tanimoto similarity.
         """
-        if not isinstance(other, Mol):
-            raise TypeError("Mol.is_similar() expects Mol object")
+        assert isinstance(other, Mol), "similarity() Error: invalid Mol object"
+        
         if not self.fp:
             self.fp = self.MFP2.GetFingerprint(self.rdmol)
+        
         if not other.fp:
             other.fp = other.MFP2.GetFingerprint(other.rdmol)
+        
         return DataStructs.TanimotoSimilarity(self.fp, other.fp)
     
 
-    def is_similar(self, other:object, threshold:float) -> bool:
-        """Check if `other` molecule is similar within `threshold`.
+    def is_similar(self, other: Self, threshold: float) -> bool:
+        """Check if other molecule is similar within Tanimoto similarity threshold.
 
         Args:
-            other (rdworks.Mol): other rdworks.Mol object to compare with.
+            other (Mol): other Mol object to compare with.
             threshold (float): Tanimoto similarity threshold.
 
         Returns:
@@ -1135,8 +1104,21 @@ class Mol:
         """
         return self.similarity(other) >= threshold
 
-        
-    def is_matching(self, terms: str | Path, invert:bool=False) -> bool:
+
+    def has_substr(self, substr: str) -> bool:
+        """Determine if the molecule has the substructure match.
+
+        Args:
+            pattern (str): SMARTS or SMILES.
+
+        Returns:
+            bool: True if matches.
+        """
+        query = Chem.MolFromSmarts(substr)
+        return self.rdmol.HasSubstructMatch(query)
+
+
+    def is_matching(self, terms: str | Path, invert: bool = False) -> bool:
         """Determines if the molecule matches the predefined substructure and/or descriptor ranges.
 
         invert | terms(~ or !) | effect
@@ -1154,14 +1136,15 @@ class Mol:
         Returns:
             bool: True if matches.
         """
-        if isinstance(terms, pathlib.PosixPath):
+        if isinstance(terms, Path):
             path = terms.as_posix()
+
         elif isinstance(terms, str):
             if terms.startswith('~') or terms.startswith('!'):
                 terms = terms.replace('~','').replace('!','')
                 invert = (invert ^ True)
             try:
-                path = pathlib.Path(terms) # test if terms points to a xml file
+                path = Path(terms) # test if terms points to a xml file
                 assert path.is_file()
             except:
                 path = get_predefined_xml(terms)
@@ -1192,8 +1175,10 @@ class Mol:
             if combine.lower() == 'or' and any(mask):
                 # early termination if any term is satisfied
                 return invert ^ True # XOR(^) inverts only if invert is True
+        
         if combine.lower() == 'and' and all(mask):
             return invert ^ True
+        
         return invert ^ False
 
 
@@ -1246,6 +1231,7 @@ class Mol:
                     continue
                 else:
                     stereos.append(element.specified == Chem.StereoSpecified.Specified)
+        
         # note all([]) returns True
         return all(stereos)
 
@@ -1262,12 +1248,12 @@ class Mol:
             if element.type == Chem.StereoType.Bond_Double:
                 if self.rdmol.GetBondWithIdx(element.centeredOn).IsInRing():
                     ring_bond_stereo_info.append((element.centeredOn, element.descriptor))
+        
         return ring_bond_stereo_info
 
 
     def report_stereo(self) -> None:
-        """Print out stereochemistry information.
-        """
+        """Report stereochemistry information for debug"""
         num_chiral_centers = rdMolDescriptors.CalcNumAtomStereoCenters(self.rdmol)
         # Returns the total number of atomic stereocenters (specified and unspecified)
         num_unspecified_chiral_centers = rdMolDescriptors.CalcNumUnspecifiedAtomStereoCenters(self.rdmol)
@@ -1292,8 +1278,7 @@ class Mol:
 
 
     def report_props(self) -> None:
-        """Print out properties.
-        """
+        """Report properties"""
         if self.props:
             print(f"Properties({len(self.props)}):")
             fixed_width = max([len(k) for k in self.props]) + 4
@@ -1305,7 +1290,59 @@ class Mol:
             print(f"Properties: None")
 
 
-    def to_sdf(self, confs:bool=False, props:bool=True) -> str:
+    def draw(self, 
+             coordgen: bool = False,
+             rotate: bool = False,
+             axis: str = 'z', 
+             degree: float = 0.0,
+             ) -> Self:
+        """Draw molecule in 2D.
+
+        Args:
+            coordgen (bool, optional): whether to use `coordgen`. Defaults to False.
+            rotate (bool, optional): whether to rotate drawing. Defaults to False.
+            axis (str, optional): axis for rotation. Defaults to 'z'.
+            degree (float, optional): degree for rotation. Defaults to 0.0.
+
+        Returns:
+            Self.
+        """
+        rdDepictor.SetPreferCoordGen(coordgen)
+        rdDepictor.Compute2DCoords(self.rdmol)
+        
+        if rotate:
+            rad = (np.pi/180.0) * degree
+            c = np.cos(rad)
+            s = np.sin(rad)
+            if axis.lower() == 'x':
+                rotmat = np.array([
+                    [1., 0., 0., 0.],
+                    [0., c, -s,  0.],
+                    [0., s,  c,  0.],
+                    [0., 0., 0., 1.],
+                    ])
+            elif axis.lower() == 'y':
+                rotmat = np.array([
+                    [ c,  0., s,  0.],
+                    [ 0., 1., 0., 0.],
+                    [-s,  0., c,  0.],
+                    [ 0., 0., 0., 1.],
+                    ])
+            elif axis.lower() == 'z':
+                rotmat = np.array([
+                    [c, -s,  0., 0.],
+                    [s,  c,  0., 0.],
+                    [0., 0., 1., 0.],
+                    [0., 0., 0., 1.],
+                    ])
+            rdMolTransforms.TransformConformer(
+                self.rdmol.GetConformer(), 
+                rotmat)        
+        
+        return self
+
+
+    def to_sdf(self, confs: bool = False, props: bool = True) -> str:
         """Returns strings of SDF output.
 
         Args:
@@ -1315,8 +1352,8 @@ class Mol:
         Returns:
             str: strings of SDF output.
         """
-        in_memory = io.StringIO()
-        with Chem.SDWriter(in_memory) as f:
+        buf = StringIO()
+        with Chem.SDWriter(buf) as f:
             if confs:
                 for conf in self.confs:
                     rdmol = Chem.Mol(conf.rdmol)
@@ -1336,45 +1373,61 @@ class Mol:
                     for k,v in self.props.items():
                         rdmol.SetProp(k, str(v))
                 f.write(rdmol)
-        return in_memory.getvalue()
-    
-
-    def to_image(self, width:int=300, height:int=300, index:bool=False, svg:bool=True) -> object:            
-        """Returns PIL(Python Image Library) image object.
+        
+        return buf.getvalue()
+       
 
-        Use .save(output_filename) method to save as an image file.
+    def to_png(self,
+               width: int = 300, 
+               height: int = 300,
+               legend: str = '', 
+               atom_index: bool = False, 
+               highlight_atoms: list[int] | None = None,
+               highlight_bonds: list[int] | None = None,
+               redraw: bool = False,
+               coordgen: bool = False,
+               trim: bool = True,
+               ) -> Image.Image:
+        """Draw 2D molecule in PNG format.
 
         Args:
-            width (int, optional): width of image. Defaults to 300.
-            height (int, optional): height of image. Defaults to 300.
-            index (bool, optional): whether to highlight atom indexes. Defaults to False.
-            svg (bool, optional): whether to return in SVG format. Defaults to True.
-
+            width (int, optional): width. Defaults to 300.
+            height (int, optional): height. Defaults to 300.
+            legend (str, optional): legend. Defaults to ''.
+            atom_index (bool, optional): whether to show atom index. Defaults to False.
+            highlight_atoms (list[int] | None, optional): atom(s) to highlight. Defaults to None.
+            highlight_bonds (list[int] | None, optional): bond(s) to highlight. Defaults to None.
+            redraw (bool, optional): whether to redraw. Defaults to False.
+            coordgen (bool, optional): whether to use coordgen. Defaults to False.
+            trim (bool, optional): whether to trim white margins. Default to True.
+        
         Returns:
-            object: PIL image object.
+            Image.Image: output PIL Image object.
         """
-        if index:
-            for a in self.rdmol.GetAtoms():
-                a.SetProp("atomNote", str(a.GetIdx()+1))
         
-        return Draw.MolsToImage(self.rdmol, 
-                                size=(width,height), 
-                                kekulize=True,
-                                wedgeBonds=True, # draw wedge (stereo)
-                                fitImage=False,
-                                options=None,
-                                canvas=None,
-                                useSVG=svg)
-    
+        return render_png(self.rdmol,
+                          width = width, 
+                          height = height, 
+                          legend = legend, 
+                          atom_index = atom_index, 
+                          highlight_atoms = highlight_atoms,
+                          highlight_bonds = highlight_bonds,
+                          redraw = redraw, 
+                          coordgen = coordgen, 
+                          trim = trim)
 
     def to_svg(self, 
-               width:int = 400, 
-               height:int = 400,
-               legend:str = '', 
-               index:bool = False, 
-               highlight: list[int] | None = None,
-               coordgen:bool = False) -> str:
-        """Returns depiction strings in SVG format.
+               width: int = 300, 
+               height: int = 300,
+               legend: str = '', 
+               atom_index: bool = False, 
+               highlight_atoms: list[int] | None = None,
+               highlight_bonds: list[int] | None = None,
+               redraw: bool = False,
+               coordgen: bool = False,
+               optimize: bool = True,
+               ) -> str:
+        """Draw 2D molecule in SVG format.
 
         Examples:
             For Jupyternotebook, wrap the output with SVG:
@@ -1383,55 +1436,60 @@ class Mol:
             >>> SVG(libr[0].to_svg())
 
         Args:
-            width (int): width (default:400)
-            height (int): height (default:400)
-            legend (str): legend
-            index (bool): True/False whether to display atom index
-            highlight (list): list of atom indices to highlight
+            width (int, optional): width. Defaults to 300.
+            height (int, optional): height. Defaults to 300.
+            legend (str, optional): legend. Defaults to ''.
+            atom_index (bool, optional): whether to show atom index. Defaults to False.
+            highlight_atoms (list[int] | None, optional): atom(s) to highlight. Defaults to None.
+            highlight_bonds (list[int] | None, optional): bond(s) to highlight. Defaults to None.
+            redraw (bool, optional): whether to redraw. Defaults to False.
+            coordgen (bool, optional): whether to use coordgen. Defaults to False.
+            optimize (bool, optional): whether to optimize SVG string. Defaults to True.
 
         Returns:
-            str: SVG text
+            str: SVG string
         """
-        rdDepictor.SetPreferCoordGen(coordgen)
-
-        rdmol_2d = Chem.Mol(self.rdmol)
-        rdDepictor.Compute2DCoords(rdmol_2d)
-        rdDepictor.StraightenDepiction(rdmol_2d)
-
-        for atom in rdmol_2d.GetAtoms():
-            for key in atom.GetPropsAsDict():
-                atom.ClearProp(key)
-
-        if index: # index hides polar hydrogens
-            for atom in rdmol_2d.GetAtoms():
-                atom.SetProp("atomLabel", str(atom.GetIdx()))
-                # atom.SetProp("atomNote", str(atom.GetIdx()))
-                # atom.SetProp("molAtomMapNumber", str(atom.GetIdx()))
-
-        drawer = rdMolDraw2D.MolDraw2DSVG(width, height)
-        if highlight:
-            drawer.DrawMolecule(rdmol_2d, legend=legend, highlightAtoms=highlight)
-        else:
-            drawer.DrawMolecule(rdmol_2d, legend=legend)
-        drawer.FinishDrawing()
-        return drawer.GetDrawingText()
-
-        
-    def plot_energy(self, df:pd.DataFrame) -> str:
-        """Returns Seaborn plot strings for dihedral energy profile in SVG format.
+        return render_svg(self.rdmol, 
+                          width = width, 
+                          height = height, 
+                          legend = legend, 
+                          atom_index = atom_index, 
+                          highlight_atoms = highlight_atoms,
+                          highlight_bonds = highlight_bonds,
+                          redraw = redraw, 
+                          coordgen = coordgen, 
+                          optimize = optimize)
+    
 
-        Input pandas DataFrame must have columns: `angle` and `E_rel(kcal/mol)`
+    def plot_torsion_energies(self, 
+                              torsion_key: int,
+                              svg: bool = False,
+                              upper_limit: float = 35.0,
+                              zoomin_limit: float = 5.0,
+                              **kwargs,
+                              ) -> str | None:
+        """Plot torsion energies.
 
         Args:
-            df (pd.DataFrame): input dataframe.
+            torsion_key (int): torsion data to plot.
+            svg (bool, optional): whether to return SVG strings. Defaults to False.
+            upper_limit (float, optional): upper limit for E_rel(kcal/mol). Defaults to 35.0.
+            zoomin_limit (float, optional): lower limit for E_rel(kcal/mol). Defaults to 5.0.
+            **kwargs: matplotlib.pyplot.plt.figure options.
 
         Returns:
-            str: Seaborn plot in strings.
+            SVG strings or None for Jupyter Notebook.
         """
+        data = self.props['torsion'][torsion_key]
+        df = pd.DataFrame({ax: data[ax] for ax in ['angle', 'E_rel(kcal/mol)']})
         
-        # sns.set_theme()
+        plt.figure(**kwargs)
+        plt.clf()  # Clear the current figure to prevent overlapping plots
+
+        sns.set_theme()
         sns.color_palette("tab10")
         sns.set_style("whitegrid")
+
         if len(df['angle']) == len(df['angle'].drop_duplicates()):
             g = sns.lineplot(x="angle",  
                              y="E_rel(kcal/mol)", 
@@ -1448,31 +1506,57 @@ class Mol:
                              markersize=10)
         g.xaxis.set_major_locator(ticker.MultipleLocator(30))
         g.xaxis.set_major_formatter(ticker.ScalarFormatter())
-        if df["E_rel(kcal/mol)"].max() > 35.0:
+        if df["E_rel(kcal/mol)"].max() > upper_limit:
             g.set(title=self.name,
                   xlabel='Dihedral Angle (degree)', 
                   ylabel='Relative Energy (Kcal/mol)',
                   xlim=(-190, 190),
-                  ylim=(-1.5, 35.0))
-        elif df["E_rel(kcal/mol)"].max() < 5.0:
+                  ylim=(-1.5, upper_limit))
+        elif df["E_rel(kcal/mol)"].max() < zoomin_limit:
             g.set(title=self.name,
                   xlabel='Dihedral Angle (degree)', 
                   ylabel='Relative Energy (Kcal/mol)',
                   xlim=(-190, 190),
-                  ylim=(-1.5, 5.0))
+                  ylim=(-1.5, zoomin_limit))
         else:
             g.set(title=self.name, 
                   xlabel='Dihedral Angle (degree)', 
                   ylabel='Relative Energy (Kcal/mol)',
                   xlim=(-190, 190),)
         g.tick_params(axis='x', rotation=30)
-        in_memory = io.StringIO()
-        plt.savefig(in_memory, format='svg', bbox_inches='tight')
-        plt.clf()
-        return in_memory.getvalue()
-    
+        
+        if svg:
+            buf = StringIO()
+            plt.savefig(buf, format='svg', bbox_inches='tight')
+            plt.close() # prevents duplicate plot outputs in Jupyter Notebook
+            svg_string = buf.getvalue()
+            # optimize SVG string
+            scour_options = {
+                'strip_comments': True,
+                'strip_ids': True,
+                'shorten_ids': True,
+                'compact_paths': True,
+                'indent_type': 'none',
+            }
+            svg_string = scourString(svg_string, options=scour_options)
+
+            return svg_string
+        
+        else:
+            buf = BytesIO()
+            plt.savefig(buf, format='png', bbox_inches='tight')
+            plt.close() # prevents duplicate plot outputs in Jupyter Notebook
+            buf.seek(0)
+            img = Image.open(buf)
+            plt.imshow(img)
+            plt.axis('off') # Optional: remove axes
+            plt.show()
+        
 
-    def to_html(self, htmlbody:bool=False) -> str:
+    def to_html(self, 
+                htmlbody: bool = False, 
+                contents: str = 'torsion',
+                ) -> str:
         """Returns HTML text of dihedral energy profile.
 
         Args:
@@ -1481,42 +1565,86 @@ class Mol:
         Returns:
             str: HTML text.
         """
+        HTML = ''
         if htmlbody:
-            HTML = "<html><body>"
-        else:
-            HTML = ""
-        # start of content
-        HTML += f'<h1 style="text-align:left">{self.name}</h1>'
-        HTML += "<table>"
-        for datadict in self.props['torsion']: # list of dict
-            (a1, a2, a3, a4, _, _) = datadict['indices']
-            df = pd.DataFrame({k:datadict[k] for k in ['angle', 'E_rel(kcal/mol)']})
-            svg_rdmol = self.to_svg(highlight=[a1, a2, a3, a4], index=True)
-            svg_energy_plot = self.plot_energy(df)
-            HTML += f"<tr>"
-            HTML += f"<td>{a1}-{a2}-{a3}-{a4}</td>"
-            HTML += f"<td>{svg_rdmol}</td>"
-            HTML += f"<td>{svg_energy_plot}</td>"
-            HTML += f"</tr>"
-        HTML += '</table>'
-        HTML += '<hr style="height:2px;border-width:0;color:gray;background-color:gray">'
-        # end of content
+            HTML = '<html><body>'
+
+        if contents.lower() == 'torsion':
+            # start of content
+            HTML += f'<h1 style="text-align:left">{self.name}</h1>'
+            HTML += '<table>'
+            for tk, dictdata in self.props['torsion'].items():
+                ijkl = dictdata['indices']
+                ijkl_str = '-'.join([str(i) for i in ijkl])
+                svg_mol = self.to_svg(highlight_atoms=ijkl, atom_index=True)
+                svg_plot = self.plot_torsion_energies(torsion_key=tk, svg=True)
+                frag = dictdata.get('frag', None)
+                if frag is not None:
+                    frag = Chem.MolFromMolBlock(frag)
+                    pqrs = dictdata['frag_indices']
+                    pqrs_str = '-'.join([str(i) for i in pqrs])
+                    svg_frag = render_svg(frag, highlight_atoms=pqrs, atom_index=True)
+                    HTML += f'<tr><td>{ijkl_str}</td><td>{svg_mol}</td>'
+                    HTML += f'<td>{pqrs_str}<td>{svg_frag}</td><td>{svg_plot}</td></tr>'
+                else:
+                    HTML += f'<tr><td>{ijkl_str}</td><td>{svg_mol}</td><td>{svg_plot}</td></tr>'
+            HTML += '</table>'
+            HTML += '<hr style="height:2px;border-width:0;color:gray;background-color:gray">'
+            # end of content
+
         if htmlbody:
-            HTML += "</body></html>"
+            HTML += '</body></html>'
+
         return HTML
 
 
-    def serialize(self, key: str | None = None, decimal_places:int=2) -> str:
+    def dumps(self, key: str = "", decimals: int = 2) -> str:
         """Returns JSON dumps of properties.
 
         Args:
             key (str | None): key for a subset of properties. Defaults to None.
-            decimal_places (int, optional): decimal places for float numbers. Defaults to 2.
+            decimals (int, optional): decimal places for float numbers. Defaults to 2.
 
         Returns:
-            str: serialized JSON dumps.
+            str: JSON dumps.
         """
-        props = fix_decimal_places_in_dict(self.props, decimal_places)
+        props = recursive_round(self.props, decimals)
+
         if key:
             return json.dumps({key:props[key]})
+        
         return json.dumps(props)
+
+
+    def serialize(self, decimals: int = 2) -> str:       
+        serialized = json.dumps({
+            'name'  : self.name,
+            'smiles': self.smiles,
+            'props' : recursive_round(self.props, decimals),
+            'confs' : [conf.serialize() for conf in self.confs],
+            })
+        
+        return serialized
+
+    
+    def deserialize(self, serialized: str) -> Self:
+        """Updates self with the serialized string input.
+
+        Args:
+            serialized (str): input
+
+        Returns:
+            Self: modified self.
+        """
+        data = json.loads(serialized)
+
+        self.name = data['name']
+        self.smiles = data['smiles'] # isomeric SMILES, no H
+        self.rdmol = Chem.MolFromSmiles(data['smiles']) # for 2D depiction
+        self.rdmol.SetProp('_Name', self.name)
+        self.InChI = Chem.MolToInchi(self.rdmol)
+        self.InChIKey = inchi.InchiToInchiKey(self.InChI)
+        self.props = data['props']
+        self.confs = [Conf().deserialize(_) for _ in data['confs']] # for 3D conformers (iterable)
+        
+        return self