Merge branch 'master' into new_cluster_interface

Author: mesonepigreco

.github/workflows/python-testsuite.yml

@@ -49,5 +49,6 @@ jobs:
       run: |
         export OMP_NUM_THREADS=1
         cd tests
+        rm -rf __pycache__
         # Test excluding very long running tests
         pytest -v -m "not release"

Modules/Cluster.py

@@ -189,6 +189,12 @@ def __init__(self, hostname=None, pwd=None, extra_options="", workdir = "",
         self.n_together_def = 1
         self.use_multiple_submission = False
 
+        # If true, add the set -x option at the beggining of the script
+        # This options makes the system print on stdout all executed commands.
+        # Very usefull to debug if something goes wrong.
+        # On some clusters may cause malfunctions.
+        self.add_set_minus_x = True
+
 
         # This is a set of lines to be runned before the calculation
         # It can be used to load the needed modules in the cluster
@@ -228,6 +234,11 @@ def __init__(self, hostname=None, pwd=None, extra_options="", workdir = "",
         # Useful if the cluster has a limit for the maximum number of jobs allowed.
         self.batch_size = 1000
 
+        # This could be a function that generates for each input file additional
+        # text in the submission file.
+        # Usefull if you want to copy things in a different directory to run the calculation on the cluster.
+        self.additional_script_parameters = None
+
 
         # Allow to setup additional custom extra parameters
         self.custom_params = {}
@@ -438,9 +449,11 @@ def batch_submission(self, list_of_structures, calc, indices,
         new_mpicmd  = self.mpi_cmd.replace("NPROC", str(self.n_cpu))
         results = [None] * N_structs
         submitted = []
+        submission_labels = []
         for i in range(N_structs):
             # Prepare a typical label
             lbl = label + "_" + str(indices[i])
+            submission_labels.append(lbl)
 
             atm = list_of_structures[i].get_ase_atoms()
             atm.set_calculator(calc)
@@ -530,17 +543,28 @@ def batch_submission(self, list_of_structures, calc, indices,
 
 
         # Add the set -x option
-        submission += "set -x\n"
+        if self.add_set_minus_x:
+            submission += "set -x\n"
 
         # Add the loading of the modules
         submission += self.load_modules + "\n"
 
         # Go to the working directory
         submission += "cd " + self.workdir + "\n"
+
+        # If any, apply the extra text before and after the calculation
+        other_input = ""
+        other_output = ""
+        if self.additional_script_parameters is not None:
+            other_input, other_output = self.additional_script_parameters(submission_labels)
+
+        submission += other_input
 
         # Use the xargs trick
         #submission += "xargs -d " + r"'\n'" + " -L1 -P%d -a %s -- bash -c\n" % (n_togheder, 
         submission += app_list 
+
+        submission += other_output
 
         # Copy the submission script
         sub_fpath = "%s/%s.sh" % (self.local_workdir, label + "_" + str(indices[0]))

Modules/SchaMinimizer.py

@@ -177,6 +177,7 @@ def __init__(self, ensemble = None, root_representation = "normal",
         self.precond_dyn = True
 
         self.minim_struct = True
+        self.minim_dyn = True
 
         # This is a debugging flag
         # If true the preconditioning of the original ensemble
@@ -318,10 +319,14 @@ def minimization_step(self, custom_function_gradient = None):
         #dyn_grad, err = self.ensemble.get_free_energy_gradient_respect_to_dyn()
         #dyn_grad, err = self.ensemble.get_fc_from_self_consistency(True, True)
         #dyn_grad, err = self.ensemble.get_fc_from_self_consistency(True, True)
-        if self.precond_dyn:
-            dyn_grad, err = self.ensemble.get_preconditioned_gradient(True, True, preconditioned=1)
+        if self.minim_dyn:
+            if self.precond_dyn:
+                dyn_grad, err = self.ensemble.get_preconditioned_gradient(True, True, preconditioned=1)
+            else:
+                dyn_grad, err = self.ensemble.get_preconditioned_gradient(True, True, preconditioned=0)
         else:
-            dyn_grad, err = self.ensemble.get_preconditioned_gradient(True, True, preconditioned=0)
+            dyn_grad = np.zeros( (len(self.dyn.q_tot), 3 * self.dyn.structure.N_atoms, 3 * self.dyn.structure.N_atoms), dtype = np.complex128)
+            err = np.zeros_like(dyn_grad)
 
 
         # Perform the symmetrization
@@ -330,45 +335,46 @@ def minimization_step(self, custom_function_gradient = None):
 #        qe_sym.ImposeSumRule(err)
 #        qe_sym.SymmetrizeDynQ(err, np.array([0,0,0]))
         t1 = time.time()
-        if not self.neglect_symmetries:
-            # Check if the symmetries must be applied in the supercell
-            if self.use_spglib:
-                # Check if we have a supercell
-                supercell = self.dyn.GetSupercell()
-                n_cell = np.prod(supercell)
-                if n_cell == 1:
-                    # Only gamma, apply the symmetries
-                    qe_sym.ApplySymmetriesToV2(dyn_grad[0, :, :])
-
-                    #qe_sym.ApplySymmetriesToV2(err)
-                    #CC.symmetries.CustomASR(err)
+        if self.minim_dyn:
+            if not self.neglect_symmetries:
+                # Check if the symmetries must be applied in the supercell
+                if self.use_spglib:
+                    # Check if we have a supercell
+                    supercell = self.dyn.GetSupercell()
+                    n_cell = np.prod(supercell)
+                    if n_cell == 1:
+                        # Only gamma, apply the symmetries
+                        qe_sym.ApplySymmetriesToV2(dyn_grad[0, :, :])
+
+                        #qe_sym.ApplySymmetriesToV2(err)
+                        #CC.symmetries.CustomASR(err)
+                    else:
+                        # We have a supercell, we must generate the dynamical matrix in the supercell
+                        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)
+
+                        # Lets generate a new symmetries for the supercell
+                        qe_sym_supcell = CC.symmetries.QE_Symmetry(super_structure)
+                        qe_sym_supcell.SetupFromSPGLIB()
+
+                        # Apply the symmetries to the fc_supercell matrix
+                        qe_sym_supcell.ApplySymmetriesToV2(fc_supercell)
+
+                        # Convert back to Q space
+                        dyn_grad = CC.Phonons.GetDynQFromFCSupercell(fc_supercell, np.array(self.dyn.q_tot), \
+                            self.dyn.structure, super_structure)
+                    
+                    # Apply the sum rule at gamma
+                    CC.symmetries.CustomASR(dyn_grad[0,:,:])
                 else:
-                    # We have a supercell, we must generate the dynamical matrix in the supercell
-                    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)
-
-                    # Lets generate a new symmetries for the supercell
-                    qe_sym_supcell = CC.symmetries.QE_Symmetry(super_structure)
-                    qe_sym_supcell.SetupFromSPGLIB()
-
-                    # Apply the symmetries to the fc_supercell matrix
-                    qe_sym_supcell.ApplySymmetriesToV2(fc_supercell)
-
-                    # Convert back to Q space
-                    dyn_grad = CC.Phonons.GetDynQFromFCSupercell(fc_supercell, np.array(self.dyn.q_tot), \
-                        self.dyn.structure, super_structure)
+                    qe_sym.SymmetrizeFCQ(dyn_grad, np.array(self.dyn.q_stars), asr = "custom")
+                    #qe_sym.SymmetrizeFCQ(err, np.array(self.dyn.q_stars), asr = "custom")
 
-                # Apply the sum rule at gamma
-                CC.symmetries.CustomASR(dyn_grad[0,:,:])
+                # Just divide the error by the square root the number of symmetries
+                err /= np.sqrt(qe_sym.QE_nsym * np.prod(self.ensemble.supercell))
             else:
-                qe_sym.SymmetrizeFCQ(dyn_grad, np.array(self.dyn.q_stars), asr = "custom")
-                #qe_sym.SymmetrizeFCQ(err, np.array(self.dyn.q_stars), asr = "custom")
-            
-            # Just divide the error by the square root the number of symmetries
-            err /= np.sqrt(qe_sym.QE_nsym * np.prod(self.ensemble.supercell))
-        else:
-            CC.symmetries.CustomASR(dyn_grad[0, :,:])
+                CC.symmetries.CustomASR(dyn_grad[0, :,:])
         t2 = time.time()
         print ("Time elapsed to symmetrize the gradient:", t2 - t1, "s")
 
@@ -468,6 +474,8 @@ def minimization_step(self, custom_function_gradient = None):
             is_diag_ok = True
             self.minimizer.update_dyn(new_kl_ratio, dyn_grad, struct_grad)
 
+            
+
             # Get the new dynamical matrix and strucure after the step
             new_dyn, new_struct = self.minimizer.get_dyn_struct()
 
@@ -892,6 +900,9 @@ def init(self, verbosity = False, delete_previous_data = True):
             delete_previous_data : bool
                 If true, it will clean previous minimizations from the free energies, gradients...
         """
+
+        if (not self.minim_dyn) and (not self.minim_struct):
+            raise ValueError("Error, either one of minim_dyn or minim_struct should be True.")
 
         # Check the ensemble size
         if not self.ensemble.structures:

tests/test_gradient_evolution/test_relax.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+from __future__ import division
+
+import sys, os
+import numpy as np
+import cellconstructor as CC
+import cellconstructor.Phonons
+
+import sscha, sscha.Ensemble
+import sscha.SchaMinimizer
+
+"""
+This test makes a simple relaxation of the sample ensemble
+provided within this distribution
+"""
+
+def test_gradient_comparison(verbose = False):
+    total_path = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(total_path)
+
+    DATA_PATH = "../../Examples/ensemble_data_test/"
+
+    dyn_start = CC.Phonons.Phonons(os.path.join(DATA_PATH, "dyn"))
+
+
+    # Perform the minimization
+    ens = sscha.Ensemble.Ensemble(dyn_start, 0, dyn_start.GetSupercell())
+    ens.load(DATA_PATH, 2, 1000)
+
+    minim = sscha.SchaMinimizer.SSCHA_Minimizer(ens)
+    minim.minim_struct = True
+    minim.min_step_dyn = 0.5
+    minim.min_step_struc = 0.5
+    minim.meaningful_factor = 1e-10
+    minim.max_ka = 5
+
+    class CG:
+        def __init__(self):
+            self.ka = 0
+        def compare_gradients(self, dyn_grad, struct_grad):
+            ka = self.ka
+            
+            if not os.path.exists("grad_{}.dat".format(ka)):
+                np.savetxt("grad_{}.dat".format(ka), dyn_grad[0,:,:])
+            else:
+                correct_grad = np.loadtxt("grad_{}.dat".format(ka))
+                diff = np.max(np.abs(dyn_grad - correct_grad))
+                print("KA = {} | difference = {}".format(ka, diff))
+            self.ka += 1
+
+    cg = CG()
+    
+    minim.init()
+    minim.run(custom_function_gradient = cg.compare_gradients)
+    minim.finalize()
+
+    
+
+if __name__ == "__main__":
+    test_gradient_comparison(True)

tests/test_rho_update/rho.dat

@@ -0,0 +1,100 @@
+4.539220355821488306e-01
+1.411526449794866522e+00
+2.104710325189953046e+00
+1.307973163516430670e+00
+9.698244944445526539e-01
+6.079171591146247389e-01
+8.638305258146310450e-01
+1.364249855976386483e+00
+1.150362638627647982e+00
+9.282376473677631523e-01
+7.481192048339360134e-01
+3.963286781380914725e-01
+8.697536941689273382e-01
+8.246715668237457608e-01
+3.994984794357198110e-01
+5.046320360558806950e-01
+9.329591782510011644e-01
+1.034134496933409197e+00
+1.261538977433160902e+00
+8.983074250578575448e-01
+1.016582863091882283e+00
+1.178658097285228301e+00
+5.400118861260385650e-01
+5.815053907267632161e-01
+1.672259771808280115e+00
+1.193477382384837915e+00
+1.139073730384374539e+00
+8.978012988414395545e-01
+8.891090775619920894e-01
+2.459552753806575343e+00
+9.824445587590747708e-01
+1.157391371610775321e+00
+1.359971082419375144e+00
+1.186643630233218172e+00
+7.227648865314558746e-01
+1.095252449457546851e+00
+5.454369201695307146e-01
+1.104938252792029285e+00
+7.482719193837685800e-01
+1.498463555239989420e+00
+5.572994625789204903e-01
+7.705556253595574612e-01
+6.986817913535011693e-01
+5.447730186037899047e-01
+1.141109810306783379e+00
+9.919214313253675863e-01
+8.552194270819423183e-01
+8.114897140621727401e-01
+7.490298145732271484e-01
+5.733037139914664015e-01
+7.814040834364547328e-01
+1.184479312351917502e+00
+1.431239307147331496e+00
+5.745975497809883148e-01
+6.852131914998749185e-01
+7.331097689064051126e-01
+4.424517778140502067e-01
+1.648708815350376167e+00
+6.498338247002786172e-01
+8.659896174386515488e-01
+6.691119551407023192e-01
+5.392713915162969940e-01
+1.251206844589672906e+00
+4.362932779004319306e-01
+5.922883410805960258e-01
+8.794036099552269281e-01
+9.019277098138261950e-01
+1.160878890503636240e+00
+1.105650006125480811e+00
+1.165694660516127801e+00
+9.486042209926186519e-01
+5.014128121316550057e-01
+1.082562669335646488e+00
+6.828508512622004645e-01
+6.216703952241426911e-01
+6.891275313437438266e-01
+9.977369856535546200e-01
+7.427079255525675938e-01
+7.694943795491897554e-01
+1.113645044986756760e+00
+1.560928717016897282e+00
+7.277430228963687187e-01
+5.139526369854987564e-01
+1.004312304546424173e+00
+3.358750079123379861e-01
+4.447819855182386095e-01
+1.216612868580458917e+00
+4.800835463817738069e-01
+6.242423793254461284e-01
+9.930756363113935059e-01
+4.709592911549231875e-01
+1.031033707302008828e+00
+1.234728079118472044e+00
+1.648877984075169723e+00
+1.387104853294882867e+00
+6.636840015273967053e-01
+7.958957361111163031e-01
+8.739496782321736212e-01
+8.012650880673536369e-01
+6.980785469953588729e-01