siman 1.2.4__tar.gz → 1.2.6__tar.gz

{siman-1.2.4/siman.egg-info → siman-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siman
-Version: 1.2.4
+Version: 1.2.6
 Summary: Manager for DFT calculations
 Home-page: https://github.com/dimonaks/siman
 Author: Dmitry Aksenov

{siman-1.2.4 → siman-1.2.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="siman",
-    version="1.2.4",
+    version="1.2.6",
     author="Dmitry Aksenov",
     author_email="dimonaks@gmail.com",
     description="Manager for DFT calculations",

{siman-1.2.4 → siman-1.2.6}/siman/calculators/vasp.py

@@ -487,13 +487,17 @@ class CalculationVasp(Calculation):
     def actualize_set(self, curset = None, params = None):
         """
         Makes additional processing of set parameters, which also depends on calculation
-    
-        adding parameters for atat
+        e.g. adding parameters for atat, etc.
+
+        INPUT:
+
+            - curset (str) - name of the current set
+            - params (dict) - dictionary with additional parameters from add_loop()
 
 
         TODO: 
             
-            if number is used after element, then it should be considered as separate type
+            if number is used after element, then it should be considered as a separate type
 
         RETURN:
             
@@ -512,6 +516,9 @@ class CalculationVasp(Calculation):
         #make element list
         el_list = [element_name_inv(el) for el in self.init.znucl] # length is equal to number of elements
         ldau = False
+        default_symprec = params.get('symprec') or 0.1
+        # print('default_symprec', default_symprec)
+        # default_symprec = 0.1
         if 'LDAUL' in vp and vp['LDAUL'] is not None: 
             ldau = True
 
@@ -519,23 +526,27 @@ class CalculationVasp(Calculation):
                 'This block checks if more types for one element should be added to structure'
                 uels_set = vp['LDAUL'].keys()
                 # print(uels_set)
-                uels = [] # list of elements provided by set relevant for the given structure
+                uels = [] # list of elements provided by set relevant for the given structure depending on anion
                 uelntypat = {} # number of types for each element from the structure, for which U should be used
+                nslashes = 0
                 for el in set(el_list):
                     for el_set in uels_set:
+                        if '/' in el_set:
+                            nslashes+=1
                         if el == el_set.split('/')[0]: # after slash the required coordination is given.
                             uels.append(el_set)
                             if el not in uelntypat:
                                 uelntypat[el] = 0
                             uelntypat[el] +=1
-                # print(uels, uelntypat)
+                # print('uels, uelntypat', uels, uelntypat)
+                # sys.exit()
                 anions_set = []
                 for el in uelntypat.keys(): #
                     if uelntypat[el] > 1: # this condition shows that multitype regime was asked for
                         printlog('LDAUL are given for the following multitype elements: ',uels, imp = 'y')
                         for el_set in uels:
                             if el in el_set and '/' not in el_set: # check that correct format is used
-                                printlog('Error! Element', el, f'has several types. LDAUL values should be given in format {el}/A but mixture of {el}/A and {el} was detected. Please correct')
+                                printlog('Warning! Element', el, f'has several types. LDAUL values should be given in format {el}/A but mixture of {el}/A and {el} was detected. Please check that U are assigned as you intend')
                             #check that required anions are present 
                             A = el_set.split('/')[1]
                             anions_set.append(A)
@@ -544,17 +555,17 @@ class CalculationVasp(Calculation):
                                 printlog(f'Warning! Anion {A} is absent in your structure but present in your set')
 
                         printlog(f'Checking if more types for {el} should be added ... ', imp = 'y')
-                        self.init, cords = self.init.add_types_for_el(el)
+                        self.init, cords = self.init.add_types_for_el(el, symprec = default_symprec)
                         if len(cords) == 1:
-                            printlog(f'Error! This structure has only one symmetry non-equivalent position for {el} and incompatible with the chosen set' )
+                            printlog(f'Warning! This structure has only one symmetry non-equivalent position for {el} and may be incompatible with the chosen set that have several definitions for {el}' )
                         
-                        if len(cords) != uelntypat[el]:
+                        if len(cords) > uelntypat[el]:
                             # print( len(cords), uelntypat[el] )
-                            printlog(f'Error! Number of non-equivalent position for {el} is {len(cords)}, which is incompatible  with {uelntypat[el]} coordinations provided the chosen set' )
+                            printlog(f'Warning! The number of non-equivalent position for {el} is {len(cords)}, which is more than the {uelntypat[el]} coordinations provided the chosen set' )
 
                         inter = list(set([item for sublist in cords for item in sublist]).intersection(set(anions_set))  ) 
                         if len(anions_set) != len(inter):
-                            printlog('Warning! Coordinations in your structure and provided LDAUL are incompatible ')
+                            printlog('Warning! Number of coordinations in your structure and provided LDAUL are different. This should not be a problem, but be carefull')
                         # sys.exit()
                         # for A in anions_set:
                         #     for cord in cords:
@@ -562,37 +573,49 @@ class CalculationVasp(Calculation):
                         #         if A in cords:
                         #             break
                         #     else:
+                
+                if nslashes > 0:
+                    el_list = self.init.get_unique_type_els(True, symprec = default_symprec) # new list of elements in M/A format for multielement regime
 
 
-            aniels = [invert(a) for a in header.ANION_ELEMENTS]
+            # aniels = [invert(a) for a in header.ANION_ELEMENTS]
             # set(aniels)
-            nintersections = len(set(aniels).intersection(el_list))
+            # nintersections = len(set(aniels).intersection(el_list)) #
             # print(nintersections, aniels, el_list)
 
-            el_list = self.init.get_unique_type_els(True) # new list after adding 
-            # sys.exit()
 
+            # print(el_list)
+            # sys.exit()
             for key in ['LDAUL', 'LDAUU', 'LDAUJ']:
                 # print( vp[key])
+                set_els = vp[key].keys()
+                # print(set_els)
+
                 try:
-                    if set(vp[key].keys()).isdisjoint(set(el_list)): #no common elements at all
-                        printlog('\n\n\nAttention! The '+str(key)+' doesnt not contain values for your elements! Setting to zero\n\n\n')
+                    if set(set_els).isdisjoint(set(el_list)): #no common elements at all
+                        printlog('\n\n\nWarning! The '+str(key)+f'={set_els} doesnt not contain explicit entries for any of your {set(el_list)} elements! Setting to zero or assigning implicitly\n\n\n')
                         # raise RuntimeError
 
                     new = []
                     for el in el_list:
                         
+                        el_bare = el.split('/')[0]
                         if el in vp[key]:
                             val = vp[key][el]
-                            
-                            for A in aniels:
-                                if A in el_list:  # use another U value for other anions, provided like Fe/S 
-                                    kk = el+'/'+A 
-                                    if kk in vp[key]:
-                                        if nintersections == 1:
-                                            val = vp[key][kk]
-                                        else:
-                                            printlog(f'Error! The chosen structure has more than one anion. The given U values {el}/{A} will be used for all {el} atoms')
+                        elif el_bare in vp[key]:
+                            val = vp[key][el_bare]
+                            printlog(f'Warning! I assign {key} of {el_bare} to {el}')
+
+                            # print(aniels)
+                            # sys.exit()
+                            # for A in aniels:
+                            #     if A in el_list:  # use another U value for other anions, provided like Fe/S - commented from April 1st 2023
+                            #         kk = el+'/'+A 
+                            #         if kk in vp[key]:
+                            #             if nintersections == 1:
+                            #                 val = vp[key][kk]
+                            #             else:
+                            #                 printlog(f'Warning! The chosen structure has more than one anion. The given U values {el}/{A} will be used for all {el} atoms')
 
 
 
@@ -604,8 +627,10 @@ class CalculationVasp(Calculation):
                                 val = -1
                             else:
                                 val =  0
-                            if '/' in el:
-                                printlog(f'Warning! no value is given in {key} for element {el}')
+                            for set_el in set_els:
+                                # print(el, set_el)
+                                if el == set_el or el == set_el.split('/')[0]:
+                                    printlog(f'Warning! no value is given in {key} for element {el}')
 
                         new.append(val)
                     
@@ -640,18 +665,23 @@ class CalculationVasp(Calculation):
                     # if ldau is true and multitype regime is true then everything is updated above
                     # if ldau is true and multitype is false than we cant use multitype here because LDAUL will become incompatible with POSCAR 
                     self.init, cords = self.init.add_types_for_el(el.split('/')[0])
-                    el_list = self.init.get_unique_type_els(True) # new list after adding 
+                    el_list = self.init.get_unique_type_els(True, symprec = default_symprec) # new list after adding 
                 else:
                     ''
 
             for iat in range(self.init.natom):
                 typ = self.init.typat[iat]
                 el  = el_list[typ-1]
+                el_bare = el.split('/')[0]
+
                 if el in curset.magnetic_moments:
                     magmom.append(curset.magnetic_moments[el])
+                elif el_bare in curset.magnetic_moments:
+                    magmom.append(curset.magnetic_moments[el])
+                    printlog(f'Warning! {el} was not found in your set, I use magmom={curset.magnetic_moments[el]} from {el_bare} for it')
                 else:
-                    if '/' in el:
-                        printlog(f'Warning! {el} was not found in your set, I use {mag_mom_other} for it')
+                    # if '/' in el:
+                    printlog(f'{el} was not found in your set, I use magmom={mag_mom_other} for it', imp = 'n')
                     magmom.append(mag_mom_other)
             
 

{siman-1.2.4 → siman-1.2.6}/siman/core/structure.py

@@ -375,16 +375,16 @@ class Structure():
         return int(sum(zvals))
 
 
-    def determine_symmetry_positions(self, element, silent = 0):
+    def determine_symmetry_positions(self, *args, **kwargs):
         from siman.geo import determine_symmetry_positions
 
-        return determine_symmetry_positions(self, element, silent)
+        return determine_symmetry_positions(self, *args, **kwargs)
 
-    def get_symmetry_positions(self, element):
+    def get_symmetry_positions(self, *args, **kwargs):
         #just another name
         from siman.geo import determine_symmetry_positions
 
-        return determine_symmetry_positions(self, element)
+        return determine_symmetry_positions(self, *args, **kwargs)
 
 
     def get_maglist(self):
@@ -2703,6 +2703,8 @@ class Structure():
         RETURN
             dict with the following keys:
             'av(A-O,F)'
+            'av' - average distance to surrounding atoms
+            'el' - list of surrounding elements
             'numbers'
             'dist'
             'xcart'
@@ -2788,8 +2790,9 @@ class Structure():
         el = st.get_elements()
         info['el'] = [el[i] for i in out_or[2]]
         info['av(A-O,F)'] = local_surrounding(x, st, n, 'av', True, only_elements = [8,9], round_flag = 0)
+        info['av'] = local_surrounding(x, st, n, 'av', True, round_flag = 0)
 
-        print
+        # print
 
         if more_info:
             info['avsq(A-O,F)'] = local_surrounding2(x, st, n, 'avsq', True, only_elements = [8,9])
@@ -3017,13 +3020,23 @@ class Structure():
 
     def localize_polaron(self, i, d, nn = 6):
         """
-        Localize small polaron at transition metal by adjusting TM-O distances
-        i - number of transition atom, from 0
-        d - shift in angstrom; positive increase TM-O, negative reduce TM-O distance
-        nn - number of neigbours
+        Localize small polaron at transition metal by adjusting TM-A distances
+
+        INPUT:
+            - i (int) - number of transition atom, from 0
+            - d (float) - shift in angstrom; positive increase TM-O, negative reduce TM-O distance
+            - nn (int) - number of neigbours
+
+        RETURN:
+
+            - st (Structure) - structure with localized polaron at atom i
+
+        AUTHOR:
+
+            Aksyonov DA
+        
 
         """
-        # nn
 
         st = copy.deepcopy(self)
         TM = st.get_el_z(i)
@@ -3034,11 +3047,17 @@ class Structure():
         silent = 1
         if 'n' in header.warnings or 'e' in header.warnings:
             silent = 0
-        # silent = 0
 
+        dic = st.nn(i, nn, from_one = 0, silent = silent)
+        els = dic['el'][1:]
+        unique_neighbours_els = set(els)
+        for A in unique_neighbours_els:
+            z = invert(A)
+            if z not in header.ANION_ELEMENTS:
+                printlog('Warning! provided element ', z, 'is not an anion element, I hope you know what you are doing. ')
 
-        dic = st.nn(i, nn, from_one = 0, silent = silent, only = [8,9])
-        printlog('Average TM-O distance before localization is {:.2f}'.format(dic['av(A-O,F)']), imp = '')
+        # print(els)
+        printlog('Average '+TM_name+'-'+str(unique_neighbours_els)+' distance before localization is {:.2f} A'.format(dic['av']), imp = 'n')
 
         #updated xcart
         xc = st.xcart[i]
@@ -3058,8 +3077,8 @@ class Structure():
 
         st.update_xred()
 
-        dic = st.nn(i, nn, from_one = 0, silent = silent, only = [8,9])
-        printlog('Average TM-O distance after localization is {:.2f}'.format(dic['av(A-O,F)']), imp = '')
+        dic = st.nn(i, nn, from_one = 0, silent = silent)
+        printlog('Average '+TM_name+'-'+str(unique_neighbours_els)+' distance after localization is {:.2f} A'.format(dic['av']), imp = 'n')
 
         st.name+='pol'+str(i+1)
 
@@ -3285,13 +3304,16 @@ class Structure():
 
         return st
 
-    def get_coordination(self, el, silent = 1):
+    def get_coordination(self, el, silent = 1, symprec = 0.1):
         """
         Get coordination for atom *el* for all non-equivalent types
 
         INPUT:
 
             - el (str) - element name
+            - silent (bool)
+            - symprec (float) - tolerance for symmetry finding, here a more crude value of 0.1 is used
+
 
 
         RETURN:
@@ -3304,7 +3326,7 @@ class Structure():
         """        
 
         st = self
-        numbers = st.determine_symmetry_positions(el, silent = 1)
+        numbers = st.determine_symmetry_positions(el, silent = 1, symprec = symprec)
         i = 1
         els = st.get_elements()
         coords = []
@@ -3318,7 +3340,7 @@ class Structure():
         return coords
 
 
-    def add_types_for_el(self, el):
+    def add_types_for_el(self, el, symprec = None):
         """
         Make several types for the same element. Needed to set different U and magnetic moments
         Currently new types are created based on symmetry. New types are added at the end of typat list
@@ -3326,6 +3348,7 @@ class Structure():
         INPUT:
 
             - el (str) - element name for which new types should be created
+            - symprec (float) - tolerance for symmetry finding, default is 0.01
 
         RETURN:
 
@@ -3343,7 +3366,7 @@ class Structure():
 
         st = self.copy()
 
-        numbers = st.determine_symmetry_positions(el, silent = 1)
+        numbers = st.determine_symmetry_positions(el, silent = 1, symprec = symprec)
         ntn = len(numbers) # new number of types for el
         z = invert(el)
         ntc = st.znucl.count(z) #current number of types for el
@@ -3351,7 +3374,7 @@ class Structure():
         # print(numbers)
         nt_add = ntn-ntc
         # coords = None
-        coords = self.get_coordination(el, silent = 0)
+        coords = self.get_coordination(el, silent = 0, symprec = symprec)
         if nt_add > 0:
             printlog('Current number of types=', ntc, 'is smaller than the number of non-equivalent positions=', ntn, '; Additional', nt_add, 'types will be added', imp = 'y')
             
@@ -3378,14 +3401,15 @@ class Structure():
 
 
 
-    def get_unique_type_els(self, coordination = False):
+    def get_unique_type_els(self, coordination = False, symprec = 0.1):
         """
         Get list of unique type elements 
 
         INPUT:
 
             - coordination (bool) - if true than the coordination of the element is given in format 'el/el_coord', where
-            el_cood is the closest-lying coordinating element. It is done only if more than one type for one element is found
+            el_cood is the closest-lying coordinating element. It is done for all elements
+            - symprec (float) - tolerance for symmetry finding, here a more crude symprec of 0.1 is used
 
         RETURN:
 
@@ -3403,13 +3427,14 @@ class Structure():
 
         els_typen = {}
 
+        els_typec = els_type.copy()
         if coordination:
-            els_typec = els_type.copy()
             for i, el in enumerate(els_type):
-                if els_type.count(el) > 1:
+                # if els_type.count(el) > 1:
+                if True: # now for all elements it is given in the form el/A
                     if el not in els_typen:
                         els_typen[el] = 0
-                    coords = self.get_coordination(el, silent = 1)
+                    coords = self.get_coordination(el, silent = 1, symprec = symprec)
                     coord_el = coords[els_typen[el]][0] #currently only first element is used
                     els_typec[i] = els_type[i]+f'/{coord_el}'
                     els_typen[el] +=1

{siman-1.2.4 → siman-1.2.6}/siman/geo.py

@@ -1147,21 +1147,34 @@ def cubic_supercell(st, ortho_sizes):
     return create_supercell(st, mul_matrix)
 
 
-def determine_symmetry_positions(st, element, silent = 0):
+def determine_symmetry_positions(st, element, silent = 0, symprec = 0.01, angle_tolerance = 5.0):
     """
-    determine non-equivalent positions for atoms of type *element*
+    Determine non-equivalent positions for atoms of type *element* using pymatgen library
 
-    element (str) - name of element, for example Li
+    INPUT:
+
+        - st (Structure)
+        - element (str) - name of element, for example Li
+        - silent (bool) 
+        - symprec (float) - tolerance for symmetry finding
+        - angle_tolerance - Angle tolerance for symmetry finding
+
+    RETURN: 
+
+        - list of lists -  atom numbers for each non-equivalent position
 
-    return list of lists -  atom numbers for each non-equivalent position
+    AUTHOR:
+
+        D. Aksyonov
     """
 
     from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
 
 
     stp = st.convert2pymatgen()
-
-    spg = SpacegroupAnalyzer(stp)
+    # print(st, symprec, angle_tolerance)
+    # sys.exit()
+    spg = SpacegroupAnalyzer(stp, symprec, angle_tolerance)
 
     info = spg.get_symmetry_dataset()
 

{siman-1.2.4 → siman-1.2.6/siman.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siman
-Version: 1.2.4
+Version: 1.2.6
 Summary: Manager for DFT calculations
 Home-page: https://github.com/dimonaks/siman
 Author: Dmitry Aksenov