I do not remember

Author: mesonepigreco

Modules/Ensemble.py

@@ -172,6 +172,9 @@ def __init__(self, dyn0, T0, supercell = None):
         self.force_computed = None 
         self.stress_computed = None
 
+        # Get the extra quantities
+        self.extra_quantities = {}
+
     def convert_units(self, new_units):
         """
         CONVERT ALL THE VARIABLE IN A COHERENT UNIT OF MEASUREMENTS

Modules/SchaMinimizer.py

@@ -98,6 +98,7 @@
                            __SCHA_T__]
 
 __MAX_DIAG_ERROR_COUNTER__ = 5
+__MAX_IMAG_ERROR_COUNTER__ = 50
 
 class SSCHA_Minimizer(object):
 
@@ -161,6 +162,7 @@ def __init__(self, ensemble = None, root_representation = "normal",
         self.minimizer = None# 
 
         self.max_diag_error_counter = __MAX_DIAG_ERROR_COUNTER__
+        self.max_imag_freq_counter = __MAX_IMAG_ERROR_COUNTER__
 
         # Projection. This is chosen to fix some constraint on the minimization
         self.projector_dyn = None
@@ -263,6 +265,17 @@ def __setattr__(self, name, value):
                 raise ValueError("Error, the step attribute {} must be positive ({} given)".format(name, value))
 
 
+    def set_minimization_step(self, step):
+        """
+        Set an uniform minimization step for both the dynamical matrix and the structure minimization.
+
+        Try to always use this function unless you specifically want two difference speed between the structure and the dynamical matrix minimization.
+        """
+
+        self.min_step_dyn = step
+        self.min_step_struc = step
+
+
     def set_ensemble(self, ensemble):
         """Provide an ensemble to the minimizer object"""
 
@@ -445,6 +458,7 @@ def minimization_step(self, custom_function_gradient = None):
         # Here a cycle to avoid diagonalization issues
         is_diag_ok = False
         diag_error_counter = 0
+        imag_freq_counter = 0
         while not is_diag_ok:
             is_diag_ok = True
             self.minimizer.update_dyn(new_kl_ratio, dyn_grad, struct_grad)
@@ -476,7 +490,7 @@ def minimization_step(self, custom_function_gradient = None):
                 print("Immaginary frequencies found! Redoing the step.")
                 new_kl_ratio = 0
                 is_diag_ok = False
-                diag_error_counter += 1            
+                imag_freq_counter += 1            
             else:
                 # Update the ensemble
                 try:
@@ -491,18 +505,34 @@ def minimization_step(self, custom_function_gradient = None):
 
             if diag_error_counter >= self.max_diag_error_counter:
                 ERROR_MSG = """
-Error, exceeded the maximum number of diagonalization error. (or imaginary steps)
+Error, exceeded the maximum number of diagonalization error. 
 
        you can get rid of this error by increasing max_diag_error_counter variable.
 
-       Something is very wrong with the dynamical matrix.
+       Something is very wrong with the dynamical matrix.self.minimizer
        I'm saving the dynamical matrix as error_dyn, 
        if you want to check it or restart the calculation from there.
 """
                 print(ERROR_MSG)
                 sys.stdout.flush()
                 self.dyn.save_qe("error_dyn")
                 raise ValueError(ERROR_MSG)
+            elif imag_freq_counter >= self.max_imag_freq_counter:
+                ERROR_MSG = """
+Error, exceeded the maximum number of step with an imaginary frequency ({}).
+       it is possible that something wrong is happening with the original dynamical matrix.
+       This error may be caused by a wrong imposition of acoustic sum rule or
+       the presence of 0 frequency modes.
+
+       Final dynamical matrix saved into error_dyn.
+       
+       If you believe this is not a problem, you can try to increase max_imag_freq_counter
+       from the '{}' object or reduce the 'min_step_dyn'
+""".format(self.max_imag_freq_counter, self.__class__.__name__) 
+                print(ERROR_MSG)
+                sys.stdout.flush()
+                self.dyn.save_qe("error_dyn")
+                raise ValueError(ERROR_MSG)
 
 
         # Save the ensemble [TODO: IT IS DEBUG]

Modules/Utilities.py

@@ -450,7 +450,10 @@ def __init__(self):
 
         self.total_freqs = []
         self.__save_fname = None
+        self.__save_atoms_fname = None
+        self.save_atomic_positions = False
         self.__save_each_step = False
+        self.current_struct = None
 
     def Reset(self):
         """
@@ -473,6 +476,16 @@ def SetupWeights(self, fname, save_each_step = True):
         self.save_weights = True
         self.__save_each_step = save_each_step
 
+    def SetupAtomicPositions(self, fname, save_each_step = True):
+        """
+        Setup the saving of the data on atomic position along with the minimization
+        """
+
+        self.__save_atoms_fname = fname
+        self.save_atomic_positions = True 
+        self.__save_each_step = save_each_step
+
+
     def SetupSaving(self, fname, save_each_step = True):
         """
         Setup the system to save the data each time the function is called.
@@ -513,6 +526,12 @@ def Save(self, fname= None):
 
         if self.save_weights:
             np.savetxt(self.weights_file, np.transpose(self.weights), header = "Each row is a step containing all the weights of the configurations")
+
+        if self.save_atomic_positions:
+            text = self.current_struct.save_scf(filename = None, get_text = True)
+            with open(self.__save_atoms_fname, "a") as fp:
+                fp.write(text)
+            
 
 
     def CFP_SaveAll(self, minim):
@@ -532,6 +551,9 @@ def CFP_SaveAll(self, minim):
 
         if self.save_dynmats:
             minim.dyn.save_qe(self.save_dyn_prefix + "_ka%05d_" % self.ka)
+        
+        if self.save_atomic_positions:
+            self.current_struct = minim.dyn.structure.copy()
 
         # This perform also the saving
         self.CFP_SaveFrequencies(minim)