Merge branch 'master' into Diegom_sobol

Author: mesonepigreco

Modules/Ensemble.py

@@ -1923,25 +1923,26 @@ def get_preconditioned_gradient(self, subtract_sscha = True, return_error = Fals
         """
 
         t1 = time.time()
-        supercell_dyn = self.current_dyn.GenerateSupercellDyn(self.supercell)
-
+        super_struct = self.current_dyn.structure.generate_supercell(self.supercell)
+        #supercell_dyn = self.current_dyn.GenerateSupercellDyn(self.supercell)
+        
         # Dyagonalize
-        w, pols = supercell_dyn.DyagDinQ(0)
+        w, pols = self.current_dyn.DiagonalizeSupercell()#supercell_dyn.DyagDinQ(0)
 
         if not self.ignore_small_w:
-            trans = CC.Methods.get_translations(pols, supercell_dyn.structure.get_masses_array())
+            trans = CC.Methods.get_translations(pols, super_struct.get_masses_array())
         else:
             trans = np.abs(w) < CC.Phonons.__EPSILON_W__
 
-        ityp = supercell_dyn.structure.get_ityp() + 1 # Py to fortran convertion
-        mass = np.array(list(supercell_dyn.structure.masses.values()))
-
+        ityp = super_struct.get_ityp() + 1 # Py to fortran convertion
+        mass = np.array(list(super_struct.masses.values()))
+        
         log_err = "err_yesrho"
 
         mass *= 2
         w /= 2
 
-        nat = supercell_dyn.structure.N_atoms
+        nat = super_struct.N_atoms
         eforces = np.zeros((self.N, nat, 3), dtype = np.float64, order = "F")
         u_disp = np.zeros((self.N, nat, 3), dtype = np.float64, order = "F")
         #print nat
@@ -1982,11 +1983,20 @@ def get_preconditioned_gradient(self, subtract_sscha = True, return_error = Fals
 
             # Perform the fourier transform
             if return_error:
-                q_grad,q_grad_err = CC.Phonons.GetDynQFromFCSupercell(grad, np.array(self.current_dyn.q_tot),
-                                                    self.current_dyn.structure, supercell_dyn.structure,fc2=grad_err)
+                # Check if a multiprocessing function can be exploited
+                if hasattr(CC.Phonons, 'GetDynQFromFCSupercell_parallel') and CC.Settings.GetNProc() > 1:  
+                    q_grad,q_grad_err = CC.Phonons.GetDynQFromFCSupercell_parallel(grad, np.array(self.current_dyn.q_tot),
+                                                        self.current_dyn.structure, super_struct,fc2=grad_err)
+                else:
+                    q_grad,q_grad_err = CC.Phonons.GetDynQFromFCSupercell(grad, np.array(self.current_dyn.q_tot),
+                                                        self.current_dyn.structure, super_struct,fc2=grad_err)
             else:
-                q_grad = CC.Phonons.GetDynQFromFCSupercell(grad, np.array(self.current_dyn.q_tot),
-                                                    self.current_dyn.structure, supercell_dyn.structure)
+                if hasattr(CC.Phonons, 'GetDynQFromFCSupercell_parallel'):
+                    q_grad = CC.Phonons.GetDynQFromFCSupercell_parallel(grad, np.array(self.current_dyn.q_tot),
+                                                        self.current_dyn.structure, super_struct)
+                else:
+                    q_grad = CC.Phonons.GetDynQFromFCSupercell(grad, np.array(self.current_dyn.q_tot),
+                                                        self.current_dyn.structure, super_struct)
             #q_grad_err = CC.Phonons.GetDynQFromFCSupercell(grad_err, np.array(self.current_dyn.q_tot),
              #                                           self.current_dyn.structure, supercell_dyn.structure)
         else:

Modules/SchaMinimizer.py

@@ -352,6 +352,7 @@ def minimization_step(self, custom_function_gradient = None):
                         #CC.symmetries.CustomASR(err)
                     else:
                         # We have a supercell, we must generate the dynamical matrix in the supercell
+                        t_5 = time.time()
                         super_structure = self.dyn.structure.generate_supercell(supercell)
                         fc_supercell = CC.Phonons.GetSupercellFCFromDyn(dyn_grad, np.array(self.dyn.q_tot), \
                             self.dyn.structure, super_structure)
@@ -360,13 +361,22 @@ def minimization_step(self, custom_function_gradient = None):
                         qe_sym_supcell = CC.symmetries.QE_Symmetry(super_structure)
                         qe_sym_supcell.SetupFromSPGLIB()
 
+                        t_6 = time.time()
+
                         # Apply the symmetries to the fc_supercell matrix
                         qe_sym_supcell.ApplySymmetriesToV2(fc_supercell)
 
+                        t_7 = time.time()
                         # Convert back to Q space
-                        dyn_grad = CC.Phonons.GetDynQFromFCSupercell(fc_supercell, np.array(self.dyn.q_tot), \
+                        dyn_grad = CC.Phonons.GetDynQFromFCSupercell_parallel(fc_supercell, np.array(self.dyn.q_tot), \
                             self.dyn.structure, super_structure)
 
+                        t_8 = time.time()
+
+                        print('    [symmetrization]  Time to prepare the suprecell dyn   : {:.6f} s'.format(t_6 - t_5))
+                        print('    [symmetrization]  Time to symmetrize in the supercell : {:.6f} s'.format(t_7 - t_6))
+                        print('    [symmetrization]  Time to return in fourier space     : {:.6f} s'.format(t_8 - t_7))
+                    
                     # Apply the sum rule at gamma
                     CC.symmetries.CustomASR(dyn_grad[0,:,:])
                 else: