Inquiry on Parallelization for SSCHA Calculation and GAP machine-learning potential

[anyi-mxh]

Dear developers,

I am currently working with the SSCHA in combination with a GAP machine-learning potential, and I've encountered an issue related to the computational time required for our system. Our calculation setup requires a large number of configurations, with the max_pop parameter set to 10,000 for stability. However, due to the size of the system, completing the calculation with this setting is extremely slow.

We have found that reducing max_pop results in the appearance of imaginary frequencies in the Hessian matrix, making it essential to maintain this value for accurate results. Given this, we are seeking to parallelize our calculations to speed up the process.

Could you kindly provide guidance or suggest any modifications to the script that would allow us to parallelize the SSCHA calculation? Take the following script as an example.

from quippy.potential import Potential
import cellconstructor as CC
import cellconstructor.Phonons

# Import the SSCHA engine (we will use it later)
import sscha, sscha.Ensemble, sscha.SchaMinimizer, sscha.Relax

# Declare SSCHA variables
temperature = 2000.0
nconf = 1000
max_pop = 10000

# Load in the GAP potential
gap_file = './GAP.xml'
pot = Potential('IP GAP', param_filename=gap_file)

# Load in the SSCHA dynamical matrices
dyn_prefix = './06_the_SSCHA_with_machine_learning_potentials/start_dyn'
nqirr = 3
dyn = CC.Phonons.Phonons(dyn_prefix, nqirr)

# Relax the structure at 2000 K
ensemble = sscha.Ensemble.Ensemble(dyn, T0=temperature,
supercell = dyn.GetSupercell())
ensemble.generate(N = nconf)
minimizer = sscha.SchaMinimizer.SSCHA_Minimizer(ensemble)
minimizer.min_step_dyn = 0.1
minimizer.kong_liu_ratio = 0.5
minimizer.meaningful_factor = 0.001
minimizer.max_ka = 100000
relax = sscha.Relax.SSCHA(minimizer, ase_calculator = pot,
N_configs = nconf, max_pop = max_pop, save_ensemble = True)
relax.vc_relax(ensemble_loc='Ensemble_location')
relax.minim.dyn.save_qe('final_dyn')
# We can check minimization procedure
relax.minim.plot_results(save_filename = 'sscha', plot = False)

Thank you very much for your time and support. I look forward to your response.

Best regards,
mxh

[mesonepigreco]

Hi, these are very strange settings. My suspect is that you just need to increase nconf and keep max_pop to just 4 or 5, as nconf is what really determines the precision and accuracy of the calculation, while max_pop determines how many iterations are required to go near the solution. In particular for the Hessian, it is required to have a large number of nconf to converge, while max_pop is mostly irrelevant above few tens.

Anyway, to parallelize it should be sufficient to run the script with mpirun as

mpirun -n 4 python myscript.py

Where in this case we are parallelizing over 4 processors.
If you have multiple mpi installed, check that the version you are using match the one employed to compile the python library mpi4py.

You can see from the output if it is parallelizing: it should print that it is computing the number of configurations divided by the processors.