Wrong atomic mass created automatically

[jgSi1113]

Dear all,

I am performing a NPT calculation via SSCHA+QE via a cluster. After I solved the parallelization problem I asked before, the multi jobs are created and submitted. But when I checked the input files, I found the atomic mass is wrong in all input files, such as following:

ATOMIC_SPECIES
B  1.0   B_ONCV_PBE_sr.upf 
C  1.0   C_ONCV_PBE_sr.upf 
Sr  1.0   Sr_ONCV_PBE_sr.upf 

In my python script, I set the pseudopotentials part as:

pseudopotentials = {'Sr' : 'Sr_ONCV_PBE_sr.upf',
	                  'B' : 'B_ONCV_PBE_sr.upf',
	                  'C' : 'C_ONCV_PBE_sr.upf'	}

Why it happens? It's too incredible.

The full python script are given as below. Please give me some suggestions kindly.

# Import the sscha code
import sscha, sscha.Ensemble, sscha.SchaMinimizer, sscha.Relax, sscha.Utilities

# Import the cellconstructor library to manage phonons
import cellconstructor as CC, cellconstructor.Phonons
import cellconstructor.Structure, cellconstructor.calculators

# Import the DFT calculator
import cellconstructor.calculators
from ase.calculators.espresso import Espresso

# Import numerical and general pourpouse libraries
import numpy as np, matplotlib.pyplot as plt
import sys, os

#Define the local cluster
import sscha.Cluster
import sscha.LocalCluster
my_hpc=sscha.LocalCluster.LocalCluster(hostname='jgsi', pwd='xxx', binary='./pw.x -npools 9 < PREFIX.pwi > PREFIX.pwo', mpi_cmd='../mpirun -np NPROC')
my_hpc.workdir = "/public/home/jgsi/SSCHA/KBC/MP/test4relax/Cal"
my_hpc.n_cpu = 36 # We will use 36 processors
my_hpc.n_nodes = 1 #In 1 node
my_hpc.batch_size = 10
my_hpc.job_number = 20
my_hpc.time= "360:00:00" 


# Initialize the DFT (Quantum Espresso) calculator for gold
# The input data is a dictionary that encodes the pw.x input file namelist
input_data = {
    'control' : {
        # Avoid writing wavefunctions on the disk
        'disk_io' : 'None',
        # Where to find the pseudopotential
        'pseudo_dir' : './', 
        	# Print the forces
        'tprnfor' : True, 
        		   # Print the stress tensor     
        'tstress' : True,      

    },
    'system' : {
        # Specify the basis set cutoffs
        'ecutwfc' : 80,   # Cutoff for wavefunction
        #'ecutrho' : 45*4, # Cutoff for the density
        # Information about smearing (it is a metal)
        'occupations' : 'smearing',
        'smearing' : 'mp',
        'degauss' : 0.02
    },
    'electrons' : {
        'conv_thr' : 1e-8,
        'mixing_beta' : 0.45
    }
}

# the pseudopotential for each chemical element
# In this case just Gold
pseudopotentials = {'Sr' : 'Sr_ONCV_PBE_sr.upf',
	                  'B' : 'B_ONCV_PBE_sr.upf',
	                  'C' : 'C_ONCV_PBE_sr.upf'	}

# the kpoints mesh and the offset
kpts = (6,6,6)
koffset = (0,0,0)

# Prepare the quantum espresso calculator
espresso_calc = CC.calculators.Espresso(input_data,
                                        pseudopotentials,
                                      #  command = command,
                                        kpts = kpts,
                                        koffset = koffset)

TEMPERATURE = 0
N_CONFIGS = 200
MAX_ITERATIONS = 30
START_DYN = 'QE.dyn'
NQIRR = 4

# Let us load the starting dynamical matrix
dyn = CC.Phonons.Phonons(START_DYN, NQIRR)
# Remove the imaginary frequencies
dyn.ForcePositiveDefinite()
#Enforce the sum rule
dyn.Symmetrize()

# Initialize the random ionic ensemble
ensemble = sscha.Ensemble.Ensemble(dyn, TEMPERATURE, supercell = dyn.GetSupercell())
# Initialize the free energy minimizer
minim = sscha.SchaMinimizer.SSCHA_Minimizer(ensemble)
# We set up the minimization parameters
minim.min_step_dyn = 0.05     # The minimization step on the dynamical matrix
minim.min_step_struc = 0.05   # The minimization step on the structure
minim.kong_liu_ratio = 0.5     # The parameter that estimates whether the ensemble is still good
minim.gradi_op = "all" # Check the stopping condition on both gradients
minim.meaningful_factor = 0.2 # How much small the gradient should be before I stop?

# Initialize the simulation
relax = sscha.Relax.SSCHA(minim, ase_calculator=espresso_calc, N_configs = N_CONFIGS,
                          max_pop = MAX_ITERATIONS,
                          save_ensemble = True,
                          cluster = my_hpc)

import os
if not os.path.exists("ensembles"):
    os.mkdir("ensembles")
#relax.vc_relax(fix_volume = True, static_bulk_modulus = 120, ensemble_loc = "ensembles")
relax.vc_relax(target_press = 30, static_bulk_modulus = 100, ensemble_loc = "ensembles")

# Define the I/O operations
# To save info about the free energy minimization after each step
ioinfo = sscha.Utilities.IOInfo()
ioinfo.SetupSaving("minim_info")
relax.setup_custom_functions(custom_function_post = ioinfo.CFP_SaveAll)

# Now we can save the final dynamical matrix
relax.minim.finalize(verbose=2)
relax.minim.dyn.save_qe("sscha_T{}_dyn".format(TEMPERATURE))
relax.minim.dyn.structure.save_scf("My_final_structure.scf")

Any suggestions and discussions will be greatly appreciated.

Thanks and Regards!
Jianguo Si

[mesonepigreco]

Hi,
This is not a problem since the PW calculations ignore the mass (isotopes do not matter for electronic calculations). Indeed, the mass is correctly accounted in the SSCHA calculation, as it is stored in the input and output dynamical matrices.

[jgSi1113]

Thanks for your reply. I checked the total energy and the stress, this is very close to the one I calculated with right atomic mass. Thank again!

Jianguo Si