aegon 0.1.0__py3-none-any.whl

aegon/__init__.py

@@ -0,0 +1 @@
+#

aegon/atom2image.py

@@ -0,0 +1,121 @@
+import os
+import numpy as np
+from ase.data import covalent_radii
+from ase.data.colors import cpk_colors
+#------------------------------------------------------------------------------------------
+aspect_ratios_4by3 = {
+    'a': (800, 600),     #SVGA
+    'b': (1024, 768),    #XGA
+    'c': (1280, 960),    #UXGA
+    'd': (1600, 1200),
+    'e': (2048, 1536),
+    'f': (3200, 2400),
+    'g': (6000, 4500),
+}
+aspect_ratios_16by9 = {
+    'a': (1280, 720),    # HD
+    'b': (1920, 1080),   # Full HD
+    'c': (2560, 1440),   # QHD/2K
+    'd': (3840, 2160),   # 4K UHD
+    'e': (7680, 4320),   # 8K UHD
+}
+#------------------------------------------------------------------------------------------
+bwd='0.12'                    # 0.15 GRUESO DE LOS ENLACES
+dlv=0.15                      # GRUESO DEL LADO DEL CUBO
+sphere_factor=float(0.55)     # 0.5 (g 1.5)
+projection='orthographic'     # 'perspective'
+reflection='reflection 0.0'
+reflection_model='phong 1.0'  # 'specular'
+radio_factor=float(1.30)      # 1.4 1.6 #ALCANCE DE LOS ENLACES
+tmit = 0.35                   # transmit (transparencia) 0.35 0.75
+#-----------------------------------------------------------------------------------------
+def write_image(poscarin, basename, f=1.2, quality='f'):
+    if quality in aspect_ratios_4by3:
+        width, height = aspect_ratios_4by3[quality]
+        print(f"Width: {width}, Height: {height}")
+    else:
+        print(f"'{quality}' is not defined.")
+    poscarxx=poscarin.copy()
+    matrix=poscarxx.cell
+    a1=np.array(matrix[0,:])
+    a2=np.array(matrix[1,:])
+    a3=np.array(matrix[2,:])
+    a=np.linalg.norm(a1)
+    b=np.linalg.norm(a2)
+    c=np.linalg.norm(a3)
+    d=max([a,b,c])
+    factor=f*d
+    background1,background2,background3='2.0','2.0','2.0'
+    light11,light12,light13='1','1','1'
+    light21,light22,light23='1','1','1'
+    camara_rotate='y*0.0'
+    camara_loca1,camara_loca2,camara_loca3='0','0',str(factor)
+    camara_look1,camara_look2,camara_look3='0','0','0'
+    name_pov=basename+'.pov' 
+    name_png=basename+'.png'
+    opnew = open(name_pov,'w')
+    print('global_settings { assumed_gamma 1.0 }', file=opnew)
+    #print('# include \'colors.inc\'', file=opnew)
+    print('background{color rgb<2.0, 2.0, 2.0>}\n', file=opnew)
+    print('light_source {< 10, -8, -8> color rgb <1, 1, 1>}', file=opnew)
+    print('light_source {< -8,  8,  8> color rgb <1, 1, 1>}\n', file=opnew)
+    print('camera {%s location <0, 0, %4.2f> look_at <0, 0, 0> rotate y*0.0}\n' %(projection, factor), file=opnew)
+    def primo(v1,v2):
+        print('cylinder {<%9.6f, %9.6f, %9.6f> <%9.6f, %9.6f, %9.6f>, %6.4f pigment{color rgb <0, 0, 0>} finish {%s %s}}' %(-v1[0],v1[1],v1[2],-v2[0],v2[1],v2[2],dlv,reflection_model,reflection), file=opnew)
+    #PARA QUE LA FIGURA SIEMPRE SALGA CENTRADA
+    a0=-(a1+a2+a3)/2
+    primo(a0,a0+a1)
+    primo(a0,a0+a2)
+    primo(a0,a0+a3)
+    primo(a0+a1,a0+a1+a2)
+    primo(a0+a1,a0+a1+a3)
+    primo(a0+a2,a0+a1+a2)
+    primo(a0+a2,a0+a2+a3)
+    primo(a0+a3,a0+a1+a3)
+    primo(a0+a3,a0+a2+a3)
+    primo(a0+a1+a2,a0+a1+a2+a3)
+    primo(a0+a1+a3,a0+a1+a2+a3)
+    primo(a0+a2+a3,a0+a1+a2+a3)
+    nn=len(poscarxx)
+    for ii in range(nn):
+        ni=poscarxx[ii].number
+        ri=covalent_radii[ni]
+        xxi,yyi,zzi=np.array(poscarxx[ii].position) + a0
+        for jj in range(ii+1,nn):
+            nj=poscarxx[jj].number
+            rj= covalent_radii[nj]
+            xxj,yyj,zzj=np.array(poscarxx[jj].position) + a0
+            uij=poscarxx[jj].position - poscarxx[ii].position
+            rr=np.linalg.norm(uij)
+            uijn=uij/rr
+            rt=rr/(ri+rj)
+            if rt < radio_factor:
+                xpm, ypm, zpm=(xxj+xxi)/2.0, (yyj+yyi)/2.0, (zzj+zzi)/2.0
+                cpki=cpk_colors[ni]
+                cpkj=cpk_colors[nj]
+                kolori=f"<{', '.join(f'{x:.3f}' for x in cpki)}>"
+                kolorj=f"<{', '.join(f'{x:.3f}' for x in cpkj)}>"
+                otf=float(0.95)
+                xxic=xxi+sphere_factor*otf*ri*uijn[0]
+                yyic=yyi+sphere_factor*otf*ri*uijn[1]
+                zzic=zzi+sphere_factor*otf*ri*uijn[2]
+                xxjc=xxj-sphere_factor*otf*rj*uijn[0]
+                yyjc=yyj-sphere_factor*otf*rj*uijn[1]
+                zzjc=zzj-sphere_factor*otf*rj*uijn[2]
+                print('cylinder {<%9.6f, %9.6f, %9.6f> <%9.6f, %9.6f, %9.6f> %s pigment {color rgb %s} finish {%s %s}}' %(-xxic,yyic,zzic,-xpm,ypm,zpm,bwd,kolori,reflection_model,reflection), file=opnew)
+                print('cylinder {<%9.6f, %9.6f, %9.6f> <%9.6f, %9.6f, %9.6f> %s pigment {color rgb %s} finish {%s %s}}' %(-xpm,ypm,zpm,-xxjc,yyjc,zzjc,bwd,kolorj,reflection_model,reflection), file=opnew)
+    for iatom in poscarxx:
+        cr=covalent_radii[iatom.number]
+        radii_div2=sphere_factor*cr
+        cpk=cpk_colors[iatom.number]
+        kolor=f"<{', '.join(f'{x:.3f}' for x in cpk)}>"
+        xx, yy, zz=np.array(iatom.position) + a0
+        s0='pigment {color rgb'
+        print('sphere {<%9.6f, %9.6f, %9.6f>, %6.4f pigment {color rgb %s} finish {%s %s}}' %(-xx,yy,zz,radii_div2,kolor,reflection_model,reflection), file=opnew)
+    opnew.close()
+    comp='povray +A Display=Off Output_File_Type=N All_Console=Off Width='+str(width)+' Height='+str(height)+' '+name_pov+' > /dev/null 2>&1'
+    os.system(comp)
+    print('Output= %s %s' %(name_pov, name_png))
+    doma='rm -f '+str(name_pov)
+    os.system(doma)
+#-----------------------------------------------------------------------------------------

aegon/libcfg.py

@@ -0,0 +1,79 @@
+import os
+import numpy as np
+from ase import Atom, Atoms
+from ase.data import chemical_symbols
+from aegon.libposcar import tag
+#------------------------------------------------------------------------------------------
+def readcfgs(filename):
+    if not os.path.isfile(filename):
+        print(f"El archivo {filename} no existe.")
+        return []
+    moleculas = [] 
+    singlemol = None  
+    natom = 0 
+    with open(filename, 'r') as contcarfile:
+        for line in contcarfile:
+            line = line.strip()
+            if line == "BEGIN_CFG":
+                if singlemol: 
+                    moleculas.append(singlemol)
+                singlemol = Atoms()  
+            elif "Size" in line:
+                size_line = contcarfile.readline().strip()
+                natom = int(size_line)
+            elif "AtomData" in line:
+                for _ in range(natom):
+                    coord_line = contcarfile.readline().strip()
+                    ls = coord_line.split()
+                    numero_atomico = int(5) #Escribir ls[1]  
+                    ss = chemical_symbols[numero_atomico] 
+                    xc, yc, zc = float(ls[2]), float(ls[3]), float(ls[4])
+                    ai = Atom(symbol=ss, position=(xc, yc, zc))
+                    singlemol.append(ai)
+                    #print(f"tomo aadido: {ai}") 
+            elif line == "Energy":
+                energy_line = contcarfile.readline().strip()
+                energy = float(energy_line)
+                singlemol.info['e'] = energy
+                singlemol.info['i'] = '_'
+                #print(f"Energa registrada: {energy}")
+        if singlemol:
+            moleculas.append(singlemol)
+    return moleculas
+#------------------------------------------------------------------------------------------
+def writecfgs(poscarlist, file, force=False):
+    if not isinstance(poscarlist, list): poscarlist = [poscarlist]
+    f=open(file,"w")
+    poscarlist=tag(poscarlist)
+    for atoms in poscarlist:
+        print("BEGIN_CFG", file=f)
+        print(" Size", file=f)
+        natoms=len(atoms)
+        print("    %d" %(natoms), file=f)
+        if np.any(atoms.pbc):
+            print(" Supercell", file=f)
+            matrix=atoms.cell
+            print("       %10.6f    %10.6f    %10.6f" %(matrix[0,0],matrix[0,1],matrix[0,2]), file=f)
+            print("       %10.6f    %10.6f    %10.6f" %(matrix[1,0],matrix[1,1],matrix[1,2]), file=f)
+            print("       %10.6f    %10.6f    %10.6f" %(matrix[2,0],matrix[2,1],matrix[2,2]), file=f)
+        if force:
+            print(" AtomData:  id type       cartes_x      cartes_y      cartes_z           fx          fy          fz",file=f)
+            forces=atoms.arrays['forces']
+            for k, atom in enumerate(atoms):
+                xc, yc, zc = atom.position
+                fx, fy, fz=forces[k]
+                tipo = atom.tag
+                print("            %2d    %d     %10.6f    %10.6f    %10.6f    %9.6f   %9.6f   %9.6f" %(k+1,tipo,xc,yc,zc,fx,fy,fz), file=f)
+        else:
+            print(" AtomData:  id type       cartes_x      cartes_y      cartes_z", file=f)
+            for k, atom in enumerate(atoms):
+                xc, yc, zc = atom.position
+                tipo = atom.tag
+                print("             %d    %d     %10.6f    %10.6f    %10.6f" %(k+1,tipo,xc,yc,zc), file=f)
+        print(" Energy", file=f)
+        energy=atoms.info['e']
+        print("        %12.8f" %(energy), file=f)
+        print(" Feature   EFS_by    VASP", file=f)
+        print("END_CFG\n", file=f)
+    f.close()
+#------------------------------------------------------------------------------------------

aegon/libclustering.py

@@ -0,0 +1,54 @@
+from sklearn.cluster import KMeans, AgglomerativeClustering, HDBSCAN
+#----------------------------------------------------------------------------------------------------------
+
+def clustering_agg(lista, descriptors, n_clusters):
+
+    if len(descriptors) < n_clusters:
+        print("La cantidad de descriptores es menor que el número de clusters. Devolviendo la lista original.")
+        return {0: lista}
+    else:
+        model = AgglomerativeClustering(n_clusters=n_clusters)
+        labels = model.fit_predict(descriptors)
+        
+    clusters = {i: [] for i in range(n_clusters)}
+    for idx, label in enumerate(labels):
+        clusters[label].append(lista[idx])
+    
+    return clusters
+#-----------------------------------------------------------------------------------------------------------
+
+def clustering_kmeans (lista, descriptors, n_clusters):
+    
+    if len(descriptors) < n_clusters:
+        print("La cantidad de descriptores es menor que el número de clusters. Devolviendo la lista original.")
+        return {0: lista}
+    else:
+        model = KMeans(n_clusters=n_clusters, init='k-means++', max_iter=3000, tol=1e-7)
+        model.fit(descriptors)
+        labels = model.labels_
+        
+    clusters = {i: [] for i in range(n_clusters)}
+    for idx, label in enumerate(labels):
+        clusters[label].append(lista[idx])
+
+    return clusters
+#--------------------------------------------------------------------------------------------------------------
+    
+def clustering_hdbscan(lista, descriptores):
+    if len(descriptores) < 100:
+        print("La cantidad de descriptores es menor a 100. Devolviendo la lista original.")
+        return {0: lista}
+    
+    model = HDBSCAN(min_cluster_size = 5, cluster_selection_epsilon = 0.2, cluster_selection_method = "eom")
+    #model = DBSCAN()
+    model.fit(descriptores)
+
+    labels = model.labels_
+    n_clus = len(set(labels))
+
+    clusters = {label: [] for label in set(labels)}  
+
+    for idx, label in enumerate(labels):
+        clusters[label].append(lista[idx])
+
+    return clusters, n_clus

aegon/libcode.py

@@ -0,0 +1,87 @@
+from aegon.libcodegaussian import get_geometry_gaussian, get_traj_gaussian
+from aegon.libcodeorca     import get_geometry_orca,     get_traj_orca
+from aegon.libcodevasp     import get_geometry_vasp,     get_traj_vasp 
+from aegon.libcodegulp     import get_geometry_gulp
+from aegon.libcfg          import writecfgs
+from aegon.libutils        import writexyzs
+from aegon.libposcar       import writeposcars
+#------------------------------------------------------------------------------------------
+# CREATION OF CLASSES
+class read_out:
+    
+    def __init__(self):
+       self.fileout_traj = {
+           "gaussian": get_traj_gaussian,
+           "orca":     get_traj_orca,
+           "vasp":     get_traj_vasp
+       } 
+       self.fileout_geometry = {
+           "gaussian": get_geometry_gaussian,
+           "orca":     get_geometry_orca,
+           "vasp":     get_geometry_vasp,
+           "gulp":     get_geometry_gulp
+       } 
+    def traj(self, document, file_name, force=False):
+        if document not in self.fileout_traj:
+            raise ValueError(f"This '{document}' do not exist.")
+        if not isinstance(file_name, str):
+            raise TypeError("The second argument must be a (str).")
+        if not isinstance(force, bool):
+            raise TypeError("The third argument must be a boolean (True/False).")
+        return self.fileout_traj[document](file_name, force)
+    
+    def geo(self,document,name):
+        if document not in self.fileout_geometry:
+            raise ValueError(f"This '{document}' do not exist.")
+        if not isinstance(name, str):
+            raise TypeError("The second argument must be a (str).")   
+        return self.fileout_geometry[document](name)
+#------------------------------------------------------------------------------------------
+class write:
+    @classmethod
+    def cfg(cls, data, output_file, force=False):
+        try:
+            if isinstance(data, bool) and not data:
+                raise ValueError("Data is False. Cannot execute cfg.")
+            else:
+               if not isinstance(data, list):
+                   data = [data]
+            if not isinstance(output_file, str):
+                raise ValueError("The first argument must be a (str).")
+            if not isinstance(force, bool):
+                raise ValueError("The second argument must be a boolean (True/False).")
+            writecfgs(data, output_file, force)  
+            print("Writing %s" %(output_file))
+        except Exception as e:
+            print(f"Error in cfg: {e}")
+    @classmethod
+    def xyz(cls, data, output_file):
+        try:
+            if isinstance(data, bool) and not data:
+                raise ValueError("Data is False. Cannot execute cfg.")
+            else:
+                if not isinstance(data, list):
+                    data = [data]
+            if not isinstance(output_file, str):
+                raise ValueError("The first argument must be a (str).")
+            writexyzs(data, output_file)  
+            print("Writing %s" %(output_file))
+        except Exception as e:
+            print(f"Error in xyz: {e}")
+    @classmethod       
+    def poscar(cls,data, output_file, opt='D'):
+        try:
+            if isinstance(data, bool) and not data:
+                raise ValueError("Data is False. Cannot execute cfg.")
+            else:
+                if not isinstance(data, list):
+                    data = [data]
+            if not isinstance(output_file, str):
+                raise ValueError("The first argument must be a (str).")
+            if not isinstance(opt, str):
+                raise ValueError("The second argument must be a (str). \tOptions:D,C or other.")
+            writeposcars(data, output_file, opt)
+            print("Writing %s" %(output_file))
+        except Exception as e:
+            print(f"Error in vasp: {e}")
+#------------------------------------------------------------------------------------------

aegon/libcodegaussian.py

@@ -0,0 +1,152 @@
+import os.path
+import numpy as np
+from ase import Atom, Atoms
+from ase.data import chemical_symbols
+#------------------------------------------------------------------------------------------
+hartree2eV = 27.211386245981 #NIST
+bohr2angstrom=0.529177210544 #NIST
+eVtokcalpermol=23.060548012069496
+hartree2kcalmol=627.5094738898777
+#------------------------------------------------------------------------------------------
+def get_termination_gaussian(pathfilename):
+    if os.path.isfile(pathfilename):
+        normal=0
+        gaufile=open(pathfilename,'r')
+        for line in gaufile:
+            if "Normal termination" in line: normal=normal+1
+        gaufile.close()
+        return normal
+    else:
+        return False
+#------------------------------------------------------------------------------------------
+def get_energy_gaussian(filename):
+    enehartree=float(0.0)
+    gaufile=open(filename,'r')
+    for line in gaufile:
+        if "SCF Done" in line:
+            scf=line.split()
+            enehartree=float(scf[4])
+    gaufile.close()
+    #enekcalmol=enehartree*hartree2kcalmol
+    eneeV = enehartree * hartree2eV
+    return eneeV
+#------------------------------------------------------------------------------------------
+def get_geometry_gaussian(pathfilename):
+    nt=get_termination_gaussian(pathfilename)
+    if nt==False: return False
+    energy=get_energy_gaussian(pathfilename)
+    filename = os.path.basename(pathfilename)
+    namein=filename.split('.')[0] 
+    gaufile=open(pathfilename,'r')
+    for line in gaufile:
+        if line.strip() in ("Input orientation:", "Standard orientation:"):
+            moleculeout = Atoms()
+            moleculeout.info['c'] = nt
+            moleculeout.info['e'] = energy
+            moleculeout.info['i'] = namein
+            for ii in range(4): line=gaufile.readline()
+            line=gaufile.readline()
+            while not line.startswith(" --------"):
+                ls = line.split()
+                if (len(ls) == 6 and ls[0].isdigit() and ls[1].isdigit() and ls[2].isdigit()):
+                    numero_atomico=int(ls[1])
+                    ss = chemical_symbols[numero_atomico]
+                    xc,yc,zc = float(ls[3]), float(ls[4]), float(ls[5])
+                    ai=Atom(symbol=ss, position=(xc, yc, zc))
+                    moleculeout.append(ai)
+                else:
+                    break
+                line=gaufile.readline()
+                ls = line.split()
+    gaufile.close()
+    return moleculeout
+#------------------------------------------------------------------------------------------
+def get_traj_gaussian(pathfilename, force=False):
+    nt=get_termination_gaussian(pathfilename)
+    if nt==False: return False
+    filename=os.path.basename(pathfilename)
+    namein=filename.split('.')[0]
+    start, end, ene, start_2, end_2 = [], [], [], [], []
+    openold = open(pathfilename,"r")
+    rline = openold.readlines()
+    for i in range(len(rline)):
+        if "Standard orientation:" in rline[i]:
+            start.append(i+5)
+            for j in range(i+5, len(rline)):
+                if rline[j].strip().startswith("-"):
+                    end.append(j - 1)
+                    break
+        if "Forces (Hartrees/Bohr)" in rline[i] and force:
+            start_2.append(i+3)
+            for j in range(i + 3, len(rline)):
+                if rline[j].strip().startswith("-"):
+                    end_2.append(j - 1)
+                    break
+        if "SCF Done" in rline[i]:
+            eneline = rline[i].split()
+            ene.append(eneline[4])      
+    moleculeout=[]
+    for i,iStart in enumerate(start[:-1]):
+        enehartree=float(ene[i])
+        eneeV = enehartree * hartree2eV
+        singlemol = Atoms()
+        singlemol.info['e'] = eneeV
+        singlemol.info['c'] = nt
+        singlemol.info['i'] = namein+'_'+str(i+1).zfill(3)
+        for line in rline[start[i] : end[i]+1]:
+            words = line.split() 
+            numero_atomico = int(words[1])
+            ss = chemical_symbols[numero_atomico]
+            xc,yc,zc = float(words[3]), float(words[4]), float(words[5])
+            ai=Atom(symbol=ss,position=(xc, yc, zc))
+            singlemol.append(ai)
+        if force:           
+            forces_list_by_group = []
+            for line in rline[start_2[i] : end_2[i]+1]:
+                words = line.split()
+                fx,fy,fz = float(words[2]), float(words[3]), float(words[4])
+                fx=fx*hartree2eV/bohr2angstrom
+                fy=fy*hartree2eV/bohr2angstrom
+                fz=fz*hartree2eV/bohr2angstrom
+                #IN ev/A
+                forces_list_by_group.append([fx,fy,fz])
+            singlemol.arrays['forces'] = np.array(forces_list_by_group)
+        moleculeout.extend([singlemol])
+    openold.close()
+    return (moleculeout)
+#------------------------------------------------------------------------------------------
+def get_freqneg_gaussian(pathfilename):
+    gaufile=open(pathfilename,'r')
+    freq_negative=0
+    freq_neg_list=[]
+    for line in gaufile:
+        if "Frequencies" in line:
+            freq=line.split()
+            freq.pop(0)
+            freq.pop(0)
+            for ifreq in range(len(freq)):
+                if float(freq[ifreq]) < 0.0:
+                    freq_negative=freq_negative+1
+                    freq_neg_list.append(float(freq[ifreq]))
+    gaufile.close()
+    freq_neg_list.sort()
+    freq_sample= freq_neg_list[0] if (freq_negative > 0) else 0.0
+    return freq_negative, freq_sample
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+def make_a_input(singlemol, level='#WB97XD def2TZVP OPT SCF=(XQC) FREQ' , folder='./'):
+    nameinp=singlemol.info['i']+'.inp'
+    fh=open(folder+nameinp,"w")
+    print("%NprocShared=13", file=fh)
+    print("%MEM=16GB", file=fh)
+    print("%s\n" %(level), file=fh)
+    print("Comment: %s\n" %(singlemol.info['i']), file=fh)
+    print("%d %d" %(singlemol.info['q'],singlemol.info['m']), file=fh)
+    for iatom in singlemol:
+        sym = iatom.symbol
+        xc, yc, zc = iatom.position
+        print ("%-2s %16.9f %16.9f %16.9f" % (sym,xc,yc,zc), file=fh)
+    fh.write("\n")
+    fh.close()
+#------------------------------------------------------------------------------------------