Biblioteca con scripts sencillos de Python

Teoría sobre del Índice de Parr

Parr, R.G. and Pearson, R.G. (1983) Absolute Hardness: Companion Parameter to Absolute Electronegativity. Journal of the American Chemical Society, 105, 7512-7516. https://doi.org/10.1021/ja00364a005

El índice de Parr ($ \omega $) es una medida teórica que se utiliza para evaluar la electrofilia de una molécula. Se basa en el potencial químico ($ \mu $) y la dureza química ($ \eta $) de la molécula.

El índice de Parr se calcula con la siguiente fórmula:

omega = (mu^2) / (2 * eta)

Donde:

$ \mu $ (potencial químico): Representa la capacidad de la molécula para aceptar electrones. Es la media de las energías de los orbitales HOMO y LUMO.
$ \eta $ (dureza química): Refleja la resistencia de la molécula a la transferencia de electrones. Se calcula como la diferencia de energía entre el LUMO y el HOMO.

En resumen, un mayor valor de $ \omega $ significa que la molécula es más electrofílica, es decir, más propensa a aceptar electrones.

Uso del Script

Este script Python calcula el índice de Parr para un conjunto de moléculas presentes en un archivo SDF y las ordena de mayor a menor electrofilia. Para ello, se utilizan las herramientas RDKit y PySCF.

Para usar el script, sigue los siguientes pasos:

Asegúrate de tener instalados los módulos necesarios. Puedes instalar RDKit y PySCF con:

pip install rdkit pyscf

Modifica las rutas de entrada y salida en el script para que apunten a tus archivos SDF de entrada y los destinos deseados.
Ejecuta el script con el siguiente comando:

python electr.py

El archivo de salida será generado en formato SDF, donde las moléculas estarán ordenadas por su índice de Parr.

Script Python

A continuación, te presentamos el código completo del script Python que puedes utilizar:


import os
from rdkit import Chem
from rdkit.Chem import AllChem
from pyscf import gto, scf

# Rutas de entrada y salida
input_sdf = "/home/jant/aaa/electrofilia.sdf"
output_sdf = "/home/jant/aaa/electrofilia-salida.sdf"

def calculate_parr_index(molecule):
    """
    Calcula el índice de Parr para la electrofilia usando PySCF.
    """
    mol = gto.M(
        atom=molecule,
        basis="sto-3g"  # Base estándar
    )
    mf = scf.RHF(mol)  # Hartree-Fock restringido
    mf.kernel()

    # Obtener energías de orbitales moleculares
    mo_energies = mf.mo_energy
    num_electrons = mol.nelectron  # Número total de electrones
    num_occupied_orbitals = num_electrons // 2  # Orbitales ocupados para sistemas cerrados

    homo_energy = mo_energies[num_occupied_orbitals - 1]  # Índice del HOMO
    lumo_energy = mo_energies[num_occupied_orbitals]      # Índice del LUMO

    # Calcular potencial químico y dureza
    chemical_potential = -(homo_energy + lumo_energy) / 2
    hardness = lumo_energy - homo_energy

    # Calcular índice de Parr (electrofilia)
    if hardness != 0:
        parr_index = (chemical_potential**2) / (2 * hardness)
    else:
        parr_index = float('inf')  # Si dureza es cero, electrofilia tiende a infinito

    return parr_index, homo_energy, lumo_energy

def main():
    # Leer el archivo SDF
    supplier = Chem.SDMolSupplier(input_sdf, removeHs=False)
    if not supplier:
        print("Error al leer el archivo SDF.")
        return

    results = []
    
    for mol in supplier:
        if mol is None or mol.GetNumAtoms() == 0:  # Validar que la molécula tiene átomos
            print("Molécula vacía o inválida encontrada. Se omite.")
            continue

        try:
            # Optimizar la geometría con RDKit
            AllChem.EmbedMolecule(mol, randomSeed=42)
            AllChem.UFFOptimizeMolecule(mol)

            # Extraer geometría atómica
            atom_coords = [
                f"{atom.GetSymbol()} {pos[0]} {pos[1]} {pos[2]}"
                for atom, pos in zip(mol.GetAtoms(), mol.GetConformer().GetPositions())
            ]
            geometry = "\n".join(atom_coords)

            # Calcular índice de Parr
            parr_index, homo_energy, lumo_energy = calculate_parr_index(geometry)

            # Guardar resultados con la molécula
            mol.SetProp("ParrIndex", str(parr_index))
            mol.SetProp("HOMO", str(homo_energy))
            mol.SetProp("LUMO", str(lumo_energy))
            results.append((parr_index, mol))
        except Exception as e:
            print(f"Error al procesar una molécula: {e}")
            continue

    # Ordenar por índice de Parr (mayor electrofilia primero)
    results.sort(key=lambda x: x[0], reverse=True)

    # Escribir el archivo SDF de salida
    writer = Chem.SDWriter(output_sdf)
    for _, mol in results:
        writer.write(mol)
    writer.close()

    print(f"Archivo de salida generado: {output_sdf}")

if __name__ == "__main__":
    main()

Un mayor índice de Parr es indicativo de mayor electrofilia.

El índice de Parr ($ \omega $) mide la tendencia de una molécula a aceptar electrones en función de su potencial químico ($ \mu $) y su dureza química ($ \eta $). Matemáticamente:

$$\omega = \frac{\mu^2}{2\eta}$$

$\mu$ (potencial químico): Representa la capacidad de la molécula para ganar electrones. Es proporcional al negativo de la media de las energías de los orbitales HOMO y LUMO:

\[ \mu = - \frac{E_{\text{HOMO}} + E_{\text{LUMO}}}{2} \]

$\eta$ (dureza química): Refleja la resistencia a la transferencia de electrones y se calcula como:

\[ \eta = E_{\text{LUMO}} - E_{\text{HOMO}} \]

Interpretación del índice de Parr

Mayor $\mu$: Si una molécula tiene un potencial químico elevado ($\mu$), significa que es más propensa a aceptar electrones.
Menor $\eta$: Si la dureza química ($\eta$) es baja, hay menos resistencia a la aceptación de electrones.

Por lo tanto:

Una molécula con un alto índice de Parr ($ \omega $) es más electrofílica, es decir, tiene una mayor capacidad para aceptar electrones.
Moléculas con valores bajos de $ \omega $ son menos electrofílicas.

Al ordenar las moléculas de mayor a menor $ \omega $, estarás clasificándolas de mayor a menor electrofilia.