def md(self, directory="tmp-dftbplus-aimd", runopt="gen", auto=0):
"""
directory: a place for all the generated files
"""
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
#shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
os.system("cp %s %s/" % (self.poscar.xyz.file, directory))
# gen slurm script
self.gen_llhpc(directory=directory, cmd="$PMF_DFTBPLUS", scriptname="aimd.slurm")
# gen pbs script
self.gen_pbs(directory=directory, cmd="$PMF_DFTBPLUS", scriptname="aimd.pbs", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# gen local bash script
self.gen_bash(directory=directory, cmd="$PMF_DFTBPLUS", scriptname="aimd.sh")
# gen lsf_sz script
self.gen_lsf_sz(directory=directory, cmd="$PMF_DFTBPLUS", scriptname="aimd.lsf_sz", np=self.run_params["nodes"]*self.run_params["ppn"], np_per_node=self.run_params["ppn"], queue=self.run_params["queue"])
# gen lsf_sustc script
self.gen_lsf_sustc(directory=directory, cmd="$PMF_DFTBPLUS", scriptname="aimd.lsf_sustc", jobname=self.run_params["jobname"], np=self.run_params["nodes"]*self.run_params["ppn"], np_per_node=self.run_params["ppn"], queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash aimd.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="aimd", server=self.run_params["server"])
def scf(self, directory="tmp-abinit-static", runopt="gen", auto=0):
self.files.name = "static-scf.files"
self.files.main_in = "static-scf.in"
self.files.main_out = "static-scf.out"
self.files.wavefunc_in = "static-scf-i"
self.files.wavefunc_out = "static-scf-o"
self.files.tmp = "tmp"
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.system("cp *.psp8 %s/" % directory)
os.system("cp *.GGA_PBE-JTH.xml %s/" % directory)
os.system("cp %s %s/" % (self.dataset[0].system.xyz.file, directory))
#self.dataset[0].electrons.set_scf_nscf("scf")
# generate llhpc submit script
self.gen_llhpc(directory=directory, script="static-scf.slurm", cmd="$PMF_ABINIT")
# generate pbs job submit script
self.gen_pbs(directory=directory, script="static-scf.pbs", cmd="$PMF_ABINIT", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# generate local bash job run script
self.gen_bash(directory=directory, script="static-scf.sh", cmd="$PMF_ABINIT", mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash %s" % "static-scf.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="static-scf", server=self.run_params["server"])
def md(self, directory="tmp-siesta-md", inpname="molecular-dynamics.fdf", output="molecular-dynamics.out",
runopt="gen", auto=0):
"""
"""
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile(self.system.xyz.file, os.path.join(directory, os.path.basename(self.system.xyz.file)))
for element in self.system.xyz.specie_labels:
shutil.copyfile("%s.psf" % element, os.path.join(directory, "%s.psf" % element))
with open(os.path.join(directory, inpname), 'w') as fout:
self.system.to_fdf(fout)
self.electrons.to_fdf(fout)
self.ions.to_fdf(fout)
# gen yhbatch script
self.gen_llhpc(directory=directory, inpname=inpname, output=output, cmd="siesta")
# gen pbs script
self.gen_pbs(directory=directory, inpname=inpname, output=output, cmd="siesta", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# gen local bash script
self.gen_bash(directory=directory, inpname=inpname, output=output, cmd="siesta", mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
# run the simulation
os.chdir(directory)
os.system("%s siesta < %s | tee %s" % (self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="molecular-dynamics", server=self.run_params["server"])
def dynmat(self,
directory="tmp-qe-static",
inpname="dynmat-gamma.in",
output="dynmat-gamma.out",
runopt="gen",
auto=0):
"""
the default output file name of dynamt.x is dynmat.out
so we should not redirect the output of running of dynmat.x(not output file of dynamt.x)
to dynamt.out to save us from leaving it a mess.
"""
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("dynmat.x calculation:\n")
print(
" directory of previous scf or nscf calculattion not found!\n"
)
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
with open(os.path.join(directory, inpname), 'w') as fout:
fout.write("&input\n")
for item in self.dynmat_input:
if self.dynmat_input[item] is not None:
if type(self.dynmat_input[item]) == str:
fout.write("%s = '%s'\n" %
(item, self.dynmat_input[item]))
else:
fout.write("%s = %s\n" %
(item, self.dynmat_input[item]))
fout.write("/\n")
fout.write("\n")
# gen yhbatch script
self.gen_llhpc(directory=directory,
inpname=inpname,
output=output,
cmd="$PMF_DYNMATX")
# gen pbs script
self.gen_pbs(directory=directory,
inpname=inpname,
output=output,
cmd="$PMF_DYNMATX",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s $PMF_DYNAMATX < %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="dynmat-gamma",
server=self.run_params["server"])
def md(self,
directory="tmp-abinit-md",
inpname="molecular-dynamics.in",
runopt="gen",
auto=0):
#
self.dataset[0].electrons.set_scf_nscf("scf")
self.dataset[0].electrons.params["tolvrs"] = 1.0e-10
self.dataset[0].electrons.params["tolwrf"] = None
self.dataset[0].electrons.params["toldff"] = None
self.dataset[0].electrons.params["tolrff"] = None
self.dataset[0].electrons.params["toldfe"] = None #1.0e-6
self.files.name = "molecular-dynamics.files"
self.files.main_in = "molecular-dynamics.in"
self.files.main_out = "molecular-dynamics.out"
self.files.wavefunc_in = "md-i"
self.files.wavefunc_out = "md-o"
self.files.tmp = "tmp"
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.system("cp *.psp8 %s/" % directory)
os.system("cp *.GGA_PBE-JTH.xml %s/" % directory)
os.system("cp %s %s/" %
(self.dataset[0].system.xyz.file, directory))
#
# generate pbs job submit script
self.gen_llhpc(directory=directory,
script="molecular-dynamics.slurm",
cmd="$PMF_ABINIT")
# generate pbs job submit script
self.gen_pbs(directory=directory,
script="molecular-dynamics.pbs",
cmd="$PMF_ABINIT",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
# generate local bash job run script
self.gen_bash(directory=directory,
script="molecular-dynamics.sh",
cmd="$PMF_ABINIT",
mpi=self.run_param["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
#os.system("abinit < %s" % inpname.split(".")[0]+".files")
os.system("bash %s" % "molecular-dynamics.sh")
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="molecular-dynamics",
server=self.run_params["server"])
def q2r(self,
directory="tmp-qe-static",
inpname="q2r.in",
output="q2r.out",
runopt="gen",
auto=0):
"""
q2r.x:
calculation of Interatomic Force Constants(IFC) from
Dynamical matrices from the phonon calculation
"""
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("q2r calculation:\n")
print(
" directory of previous scf or nscf calculattion not found!\n"
)
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
with open(os.path.join(directory, inpname), 'w') as fout:
fout.write("&input\n")
for item in self.q2r_input:
if self.q2r_input[item] is not None:
if type(self.q2r_input[item]) == str:
fout.write("%s = '%s'\n" %
(item, self.q2r_input[item]))
else:
fout.write("%s = %s\n" %
(item, self.q2r_input[item]))
fout.write("/\n")
fout.write("\n")
# gen yhbatch script
self.gen_llhpc(directory=directory,
inpname=inpname,
output=output,
cmd="$PMF_Q2RX")
# gen pbs script
self.gen_pbs(directory=directory,
inpname=inpname,
output=output,
cmd="$PMF_Q2RX",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s $PMF_Q2RX < %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="q2r",
server=self.run_params["server"])
def metadynamics(self,
directory="tmp-cp2k-metadynamics",
inpname="metadynamics.inp",
output="metadynamics.out",
runopt="gen",
auto=0):
"""
:param directory:
directory is and path where the calculation will happen.
:param inpname:
input filename for the cp2k
:param output:
output filename for the cp2k
"""
self.motion.free_energy.status = True
self.motion.free_energy.metadyn.status = True
self.motion.free_energy.metadyn.printout.status = True
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile(
self.force_eval.subsys.xyz.file,
os.path.join(directory,
os.path.basename(
self.force_eval.subsys.xyz.file)))
with open(os.path.join(directory, inpname), 'w') as fout:
self.glob.to_input(fout)
self.force_eval.to_input(fout)
self.motion.to_input(fout)
# gen server job comit file
self.gen_llhpc(cmd="$PMF_CP2K",
directory=directory,
inpname=inpname,
output=output)
# gen pbs server job comit file
self.gen_pbs(cmd="$PMF_CP2K",
directory=directory,
inpname=inpname,
output=output,
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s $PMF_CP2K -in %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="metadynamics",
server=self.run_params["server"])
def scf(self,
directory="tmp-siesta-static",
inpname="static-scf.fdf",
output="static-scf.out",
runopt="gen",
auto=0,
properties=[]):
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile(
self.system.xyz.file,
os.path.join(directory,
os.path.basename(self.system.xyz.file)))
for element in self.system.xyz.specie_labels:
shutil.copyfile("%s.psf" % element,
os.path.join(directory, "%s.psf" % element))
# use self.properties.options to contorl the calculation of properties
self.properties.options = properties
with open(os.path.join(directory, inpname), 'w') as fout:
self.system.to_fdf(fout)
self.electrons.to_fdf(fout)
self.properties.to_fdf(fout)
# gen llhpc script
self.gen_llhpc(directory=directory,
inpname=inpname,
output=output,
cmd="siesta")
# gen pbs script
self.gen_pbs(directory=directory,
inpname=inpname,
output=output,
cmd="siesta",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"])
# gen local bash script
self.gen_bash(directory=directory,
inpname=inpname,
output=output,
cmd="siesta",
mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s siesta < %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="static-scf",
server=self.run_params["server"])
def run(self, directory="tmp-abinit-static", runopt="gen", auto=0):
self.files.name = "static.files"
self.files.main_in = "static.in"
self.files.main_out = "static.out"
self.files.wavefunc_in = "static-i"
self.files.wavefunc_out = "static-o"
self.files.tmp = "tmp"
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.system("cp *.psp8 %s/" % directory)
os.system("cp *.GGA_PBE-JTH.xml %s/" % directory)
os.system("cp %s %s/" % (self.dataset[0].system.xyz.file, directory))
# 0) overall default dataset
self.dataset[0].electrons.params["iscf"] = 7
self.dataset[0].electrons.params["prtden"] = 1
self.dataset[0].electrons.use_tol(tol="tolvrs", value=1.0e-8) # user must set it
# 1) scf
self.dataset[1].electrons.params["iscf"] = 7
self.dataset[1].electrons.params["prtden"] = 1
self.dataset[1].electrons.use_tol(tol="tolvrs", value=1.0e-8) # user must set it
# 2) nscf dos
self.dataset[2].electrons.params["iscf"] = -3
self.dataset[2].electrons.params["prtdos"] = 1
self.dataset[2].electrons.params["getwfk"] = 1
self.dataset[2].electrons.params["getden"] = 1
self.dataset[2].electrons.use_tol(tol="tolvrs", value=1.0e-8) # user must set it
# 3) nscf bands
self.dataset[3].electrons.params["iscf"] = -2
self.dataset[3].electrons.params["getwfk"] = 1
self.dataset[3].electrons.params["getden"] = 1
# when kptopt < 0 namely band structure calculatin, we can only use
self.dataset[3].electrons.use_tol(tol="tolwfr", value=1.0e-12)
# generate llhpc job submit script
self.gen_llhpc(directory=directory, script="static.slurm", cmd="$PMF_ABINIT")
# generate pbs job submit script
self.gen_pbs(directory=directory, script="static.pbs", cmd="$PMF_ABINIT", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# generate local bash job run script
self.gen_bash(directory=directory, script="static.sh", cmd="$PMF_ABINIT", mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash %s" % "static.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="static", server=self.run_params["server"])
def run_vasp(self, directory="tmp-uspex-vasp", runopt="gen", auto=0):
"""
directory: a place for all the generated files
"""
self.params["numSpecies"] = self.vasp.poscar.xyz.nspecies
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
os.system("cp %s %s/" % (self.vasp.poscar.xyz.file, directory))
#os.system("sflow convert -i %s -o %s" % (self.vasp.poscar.xyz.file, os.path.join(directory, "input_structure.cif")))
self.set_params({"CifFilePath": "input_structure.cif"})
with open(os.path.join(directory, "POSCAR"), 'w') as fout:
self.vasp.poscar.to_poscar(fout)
#with open(os.path.join(directory, "input.dat"), 'w') as fout:
# self.to_input_dat(fout)
with open(os.path.join(directory, "uspex.pbs"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" %
(self.run_params["nodes"], self.run_params["ppn"]))
if self.run_params["queue"] != None:
fout.write("#PBS -q %s\n" % self.run_params["queue"])
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("cat > INCAR<<EOF\n")
self.vasp.incar.to_incar(fout)
fout.write("EOF\n")
fout.write("cat > KPOINTS<<EOF\n")
self.vasp.kpoints.to_kpoints(fout)
fout.write("EOF\n")
fout.write("cat > INPUT.txt<<EOF\n")
self.to_input_txt(fout)
fout.write("EOF\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write("cat $PBS_NODEFILE > machinefile\n")
if runopt == "run" or runopt == "genrun":
# run the neb calculation
# each image on one core
os.chdir(directory)
#os.system("%s vasp" % mpi)
os.system("bash calypso.sh")
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="calypso",
server=self.run_params["server"])
def scf_restart(self,
directory="tmp-siesta-static",
inpname="static-scf-restart.fdf",
output="static-scf-restart.out",
runopt="gen",
auto=0,
properties=[]):
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("scf(restart) calculation:\n")
print(" directory of previous scf calculattion not found!\n")
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
self.electrons.dm["UseSaveDM"] = "true"
# use self.properties.option to contorl the calculation of properties
self.properties.options = properties
with open(os.path.join(directory, inpname), 'w') as fout:
self.system.to_fdf(fout)
self.electrons.to_fdf(fout)
self.properties.to_fdf(fout)
# gen llhpc script
self.gen_llhpc(directory=directory,
inpname=inpname,
output=output,
cmd="siesta")
# gen pbs script
self.gen_pbs(directory=directory,
inpname=inpname,
output=output,
cmd="siesta",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"])
# gen local bash script
self.gen_bash(directory=directory,
inpname=inpname,
output=output,
cmd="siesta",
mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s $PMF_SIESTA < %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="static-scf-restart",
server=self.run_params["server"])
def vib(self,
directory="tmp-cp2k-vib",
inpname="vib.inp",
output="vib.out",
runopt="gen",
auto=0):
"""
:param directory:
wheere the calculation will happen
:param inpname:
input filename for the cp2k
:param output:
output filename for the cp2k
"""
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile(
self.force_eval.subsys.xyz.file,
os.path.join(directory,
os.path.basename(
self.force_eval.subsys.xyz.file)))
with open(os.path.join(directory, inpname), 'w') as fout:
self.glob.to_input(fout)
self.force_eval.to_input(fout)
self.vibrational_analysis.to_input(fout)
# gen server job comit file
self.gen_llhpc(directory=directory,
cmd="$PMF_CP2K",
inpname=inpname,
output=output)
# gen pbs server job comit file
self.gen_pbs(directory=directory,
cmd="$PMF_CP2K",
inpname=inpname,
output=output,
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s $PMF_CP2K -in %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="vib",
server=self.run_params["server"])
def scf_nscf_dos_bands(self, directory="tmp-abinit-static", runopt="gen", auto=0):
"""
"""
self.files.name = "static-scf-nscf-dos-bands.files"
self.files.main_in = "static-scf-nscf-dos-bands.in"
self.files.main_out = "static-scf-nscf-dos-bands.out"
self.files.wavefunc_in = "static-scf-nscf-dos-bands-i"
self.files.wavefunc_out = "static-scf-nscf-dos-bands-o"
self.files.tmp = "tmp"
if runopt == "gen" or runopt == "genrun":
# overall default parameters setting
# 1) scf
# 2) nscf
self.dataset[0].electrons.params["irdwfk"] = 1
self.dataset[0].electrons.params["irdden"] = 1
# 3) bands
self.dataset[0].electrons.params["iscf"] = -2
self.dataset[0].electrons.params["nband"] = 8
self.dataset[0].electrons.params["tolwfr"] = 1.0e-12 # when kptopt < 0 namely band structure calculatin, we can only use tolwfr
self.dataset[0].electrons.params["tolvrs"] = None
self.dataset[0].electrons.params["toldfe"] = None
#self.dataset[0].electrons.params["irdden"] = 1 # actually irdden will be 1 by default if iscf < 0
# generate llhpc submit script
self.gen_llhpc(directory=directory, script="static-scf-nscf-dos-bands.slurm", cmd="$PMF_ABINIT")
# generate pbs job submit script
self.gen_pbs(directory=directory, script="static-scf-nscf-dos-bands.pbs", cmd="$PMF_ABINIT", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# generate local bash job run script
self.gen_bash(directory=directory, script="static-scf-nscf-dos-bands.sh", cmd="$PMF_ABINIT", mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash %s" % "static-scf-nscf-dos-bands.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="static-scf-nscf-dos-bands", server=self.run_params["server"])
def bands(self, directory="tmp-abinit-static", runopt="gen", auto=0):
"""
we can use abiopen.py static-band-output_GSR.nc --expose -sns=talk to view the band structure.
"""
self.files.name = "static-bands.files"
self.files.main_in = "static-bands.in"
self.files.main_out = "static-bands.out"
self.files.wavefunc_in = "static-nscf-o"
self.files.wavefunc_out = "static-bands-o"
self.files.tmp = "tmp"
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("band structure calculation:\n")
print(" directory of previous scf calculattion not found!\n")
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
self.dataset[0].electrons.params["iscf"] = -2
self.dataset[0].electrons.params["nband"] = 8
self.dataset[0].electrons.params["tolwfr"] = 1.0e-12 # when kptopt < 0 namely band structure calculatin, we can only use tolwfr
self.dataset[0].electrons.params["tolvrs"] = None
self.dataset[0].electrons.params["toldfe"] = None
#self.dataset[0].electrons.params["irdden"] = 1 # actually irdden will be 1 by default if iscf < 0
# generate llhpc submit script
self.gen_llhpc(directory=directory, script="static-bands.slurm", cmd="$PMF_ABINIT")
# generate pbs job submit script
self.gen_pbs(directory=directory, script="static-bands.pbs", cmd="$PMF_ABINIT", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# generate local bash job run script
self.gen_bash(directory=directory, script="static-bands.sh", cmd="$PMF_ABINIT", mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash %s" % "static-bands.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="static-bands", server=self.run_params["server"])
def phonon(self, directory="tmp-vasp-phonon", runopt="gen", auto=0):
"""
directory: a place for all the generated files
"""
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
os.system("cp %s %s/" % (self.poscar.xyz.file, directory))
## Construct and run every POSCAR scf
with open(os.path.join(directory, "POSCAR-original-unitcell"), 'w') as fout:
self.poscar.to_poscar(fout)
os.chdir(directory)
os.system("phonopy -d --dim='%d %d %d' -c POSCAR-original-unitcell" % (self.supercell_n[0], self.supercell_n[1], self.supercell_n[2]))
os.system("cp SPOSCAR POSCAR")
os.chdir("../")
#with open(os.path.join(directory, "INCAR"), 'w') as fout:
# self.incar.to_incar(fout)
# gen llhpc script
self.gen_llhpc(directory=directory, cmd="$PMF_VASP_STD", scriptname="phonon.slurm")
# gen pbs script
self.gen_pbs(directory=directory, cmd="$PMF_VASP_STD", scriptname="phonon.pbs", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# gen local bash script
self.gen_bash(directory=directory, cmd="$PMF_VASP_STD", scriptname="phonon.sh")
# gen lsf_sz script
self.gen_lsf_sz(directory=directory, cmd="$PMF_VASP_STD", scriptname="phonon.lsf_sz", np=self.run_params["nodes"]*self.run_params["ppn"], np_per_node=self.run_params["ppn"], queue=self.run_params["queue"])
# gen lsf_sustc script
self.gen_lsf_sustc(directory=directory, cmd="$PMF_VASP_STD", scriptname="phonon.lsf_sustc", jobname=self.run_params["jobname"], np=self.run_params["nodes"]*self.run_params["ppn"], np_per_node=self.run_params["ppn"], queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
#os.system("vasp")
os.system("bash phonon.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="phonon", server=self.run_params["server"])
def nscf(self, directory="tmp-abinit-static", runopt="gen", auto=0):
self.files.name = "static-nscf.files"
self.files.main_in = "static-nscf.in"
self.files.main_out = "static-nscf.out"
self.files.wavefunc_in = "static-scf-o"
self.files.wavefunc_out = "static-nscf-o"
self.files.tmp = "tmp"
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("non-scf calculation:\n")
print(" directory of previous scf calculattion not found!\n")
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
#self.dataset[0].electrons.set_scf_nscf("scf")
self.dataset[0].electrons.params["irdwfk"] = 1
self.dataset[0].electrons.params["irdden"] = 1
#
# generate llhpc submit script
self.gen_llhpc(directory=directory, script="static-nscf.slurm", cmd="$PMF_ABINIT")
# generate pbs job submit script
self.gen_pbs(directory=directory, script="static-nscf.pbs", cmd="$PMF_ABINIT", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# generate local bash job run script
self.gen_bash(directory=directory, script="static-nscf.sh", cmd="$PMF_ABINIT", mpi=self.run_params["mpi"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash %s" % "static-nscf.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="static-nscf", server=self.run_params["server"])
def md(self, directory="tmp-vasp-md", runopt="gen", ensemble=0, thermostat=0, auto=0):
"""
directory: a place for all the generated files
ensemble:
0: NVE
1: NVT
2: NPT
3: NPH
"""
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
os.system("cp %s %s/" % (self.poscar.xyz.file, directory))
self.incar.set_md(ensemble=ensemble, thermostat=thermostat)
with open(os.path.join(directory, "POSCAR"), 'w') as fout:
self.poscar.to_poscar(fout)
# gen llhpc script
self.gen_llhpc(directory=directory, cmd="$PMF_VASP_STD", scriptname="md.slurm")
# gen pbs script
self.gen_pbs(directory=directory, cmd="$PMF_VASP_STD", scriptname="md.pbs", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# gen local bash script
self.gen_bash(directory=directory, cmd="$PMF_VASP_STD", scriptname="md.sh")
# gen lsf_sz script
self.gen_lsf_sz(directory=directory, cmd="$PMF_VASP_STD", scriptname="md.lsf_sz", np=self.run_params["nodes"]*self.run_params["ppn"], np_per_node=self.run_params["ppn"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
#os.system("vasp")
os.system("bash md.sh")
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="md", server=self.run_params["server"])
def run(self, directory="tmp-abinit-dfpt-phonon", runopt="gen", auto=0):
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.system("cp *.psp8 %s/" % directory)
os.system("cp *.GGA_PBE-JTH.xml %s/" % directory)
os.system("cp %s %s/" %
(self.dataset[0].system.xyz.file, directory))
self.files.name = "dfpt-phonon.files"
self.files.main_in = "dfpt-phonon.in"
self.files.main_out = "dfpt-phonon.out"
self.files.wavefunc_in = "dfpt-phonon-i"
self.files.wavefunc_out = "dfpt-phonon-o"
self.files.tmp = "tmp"
for i in range(self.ndtset + 1):
self.dataset[i].dfpt.status = True
# overall default dataset
self.dataset[0].electrons.kpoints.params["kptopt"] = 3
#self.dataset[0].dfpt.params["rfphon"] = 1
# If one of rfphon, rfddk, rfelfd, or rfstrs is non-zero, while optdriver is not defined in the input file,
# ABINIT will set optdriver to 1 automatically(means for response function calc)
# so we should not set them in the dataset 0 for the default setting.
# but rfatpol and rfdir can be set in the dataset 0 which will not affect default value of optdriver
self.dataset[0].dfpt.params["rfatpol"] = [
1, self.dataset[0].system.xyz.natom
]
self.dataset[0].dfpt.params["rfdir"] = [1, 1, 1]
self.dataset[0].electrons.use_tol(tol="tolvrs", value=1.0e-8)
# 1) ground state scf calculation
self.dataset[1].electrons.params["iscf"] = 7
self.dataset[1].electrons.use_tol(tol="tolvrs", value=1.0e-10)
self.dataset[1].electrons.kpoints.params["ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
# 2) calculate ddk wave functions (iscf = -3, rfelfd =2, qpt = 0 0 0, rfdir = 1 1 1)
self.dataset[2].electrons.use_tol(tol="tolwfr", value=1.0e-22)
self.dataset[2].electrons.params["getwfk"] = -1
self.dataset[2].electrons.kpoints.params["kptopt"] = 2
self.dataset[2].electrons.kpoints.params["ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
self.dataset[2].electrons.params["iscf"] = -3
self.dataset[2].dfpt.params["rfelfd"] = 2
self.dataset[2].dfpt.params["rfphon"] = 0
self.dataset[2].dfpt.params["nqpt"] = 1
self.dataset[2].dfpt.params["qpt"] = [0, 0, 0]
# 3) Response function calculation of Q=0 phonons and electric field pert.
self.dataset[3].electrons.params["getddk"] = 2
self.dataset[3].electrons.params["getwfk"] = 1
self.dataset[3].electrons.kpoints.params["kptopt"] = 2
self.dataset[3].electrons.kpoints.params["ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
self.dataset[3].dfpt.params["rfelfd"] = 3
self.dataset[3].dfpt.params["nqpt"] = 1
self.dataset[3].dfpt.params["qpt"] = [0, 0, 0]
self.dataset[3].electrons.use_tol(tol="tolvrs", value=1.0e-8)
# calculate for q point other than gamma in qpath
for i in range(4, self.ndtset + 1):
specialk = []
for kpoint in self.qpath:
if kpoint[3] not in specialk:
self.dataset[i].electrons.params["getwfk"] = 1
self.dataset[i].dfpt.params["qpt"] = kpoint[0:3]
self.dataset[i].electrons.use_tol(tol="tolvrs",
value=1.0e-8)
self.dataset[i].electrons.kpoints.params[
"ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
specialk.append(kpoint[3])
else:
pass
#
# generate pbs job submit script
#self.gen_pbs(directory=directory, script="dfpt-phonon.pbs", cmd="$PMF_ABINIT", jobname=self.run_params["jobname"], nodes=self.run_params["nodes"], ppn=self.run_params["ppn"], queue=self.run_params["queue"])
# generate local bash job run script
#self.gen_bash(directory=directory, script="dfpt-phonon.sh", cmd="$PMF_ABINIT", mpi=self.run_params["mpi"])
# llhpc jobsubmit script
with open(os.path.join(directory, "dfpt-phonon.slurm"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#SBATCH -p %s\n" % self.run_params["partition"])
fout.write("#SBATCH -N %d\n" % self.run_params["nodes"])
fout.write("#SBATCH -n %d\n" % self.run_params["ntask"])
fout.write("#SBATCH -J %s\n" % self.run_params["jobname"])
fout.write("#SBATCH -o %s\n" % self.run_params["stdout"])
fout.write("#SBATCH -e %s\n" % self.run_params["stderr"])
fout.write("cat > %s<<EOF\n" % self.files.main_in)
fout.write(self.to_string())
fout.write("EOF\n")
fout.write("cat > %s<<EOF\n" % self.files.name)
fout.write(self.files.to_string(system=self.dataset[0].system))
fout.write("EOF\n")
fout.write("yhrun %s < %s\n" %
("$PMF_ABINIT", self.files.name))
# use mrgddb and anaddb to analyse DDB file generated previously
fout.write("cat %s <<EOF\n" % "mrgddb.in")
fout.write("mrgddb.ddb.out\n")
fout.write("xxx\n")
fout.write("%d\n" % (self.ndtset - 2))
for i in range(3, self.ndtset + 1):
fout.write("dfpt-phonon-o_DS%d_DDB\n" % i)
fout.write("EOF\n")
fout.write("yhrun $PMF_MRGDDB < mrgddb.in\n")
# anaddb
fout.write("cat > %s <<EOF\n" % "anaddb.in")
fout.write("ifcflag 1\n")
fout.write("ifcout 0\n")
fout.write("! wavevector grid\n")
fout.write("brav 2\n")
fout.write("ngqpt 3 3 3\n")
fout.write("! effective charge\n")
fout.write("chneut 1\n")
fout.write("! interatomic force constant info\n")
fout.write("dipdip 1\n")
fout.write("! Phonon band structure output for band2eps\n")
fout.write("eivec 4\n")
fout.write("! wavevector list\n")
fout.write("EOF\n")
#with open(os.path.join(directory, "anaddb.files"), 'w') as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.files")
fout.write("anaddb.in\n")
fout.write("anaddb.out\n")
fout.write("%s_DS3_DDB\n" % self.files.wavefunc_out)
fout.write("dummy_moldyn\n")
fout.write("dummy_GKK\n")
fout.write("dummy_epout\n")
fout.write("dummy_ddk\n")
fout.write("EOF\n")
#fout.write("yhrun %s < %s\n" % ("$PMF_ANADDB", "anaddb.files"))
# pbs jobsubmit script
with open(os.path.join(directory, "dfpt-phonon.pbs"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" %
(self.run_params["nodes"], self.run_params["ppn"]))
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write("cat > %s<<EOF\n" % self.files.main_in)
fout.write(self.to_string())
fout.write("EOF\n")
fout.write("cat > %s<<EOF\n" % self.files.name)
fout.write(self.files.to_string(system=self.dataset[0].system))
fout.write("EOF\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE %s < %s\n" %
("$PMF_ABINIT", self.files.name))
# use mrgddb and anaddb to analyse DDB file generated previously
fout.write("cat %s <<EOF\n" % "mrgddb.in")
fout.write("mrgddb.ddb.out\n")
fout.write("xxx\n")
fout.write("%d\n" % (self.ndtset - 2))
for i in range(3, self.ndtset + 1):
fout.write("dfpt-phonon-o_DS%d_DDB\n" % i)
fout.write("EOF\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE $PMF_MRGDDB < mrgddb.in\n"
)
# anaddb
fout.write("cat > %s <<EOF\n" % "anaddb.in")
fout.write("ifcflag 1\n")
fout.write("ifcout 0\n")
fout.write("! wavevector grid\n")
fout.write("brav 2\n")
fout.write("ngqpt 3 3 3\n")
fout.write("! effective charge\n")
fout.write("chneut 1\n")
fout.write("! interatomic force constant info\n")
fout.write("dipdip 1\n")
fout.write("! Phonon band structure output for band2eps\n")
fout.write("eivec 4\n")
fout.write("! wavevector list\n")
fout.write("EOF\n")
#with open(os.path.join(directory, "anaddb.files"), 'w') as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.files")
fout.write("anaddb.in\n")
fout.write("anaddb.out\n")
fout.write("%s_DS3_DDB\n" % self.files.wavefunc_out)
fout.write("dummy_moldyn\n")
fout.write("dummy_GKK\n")
fout.write("dummy_epout\n")
fout.write("dummy_ddk\n")
fout.write("EOF\n")
#fout.write("mpirun -np $NP -machinefile $PBS_NODEFILE %s < %s\n" % ("$PMF_ANADDB", "anaddb.files"))
# local bash script
with open(os.path.join(directory, "dfpt-phonon.sh"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("cat > %s<<EOF\n" % self.files.main_in)
fout.write(self.to_string())
fout.write("EOF\n")
fout.write("cat > %s<<EOF\n" % self.files.name)
fout.write(self.files.to_string(system=self.dataset[0].system))
fout.write("EOF\n")
fout.write(
"%s %s < %s\n" %
(self.run_params["mpi"], "$PMF_ABINIT", self.files.name))
# use mrgddb and anaddb to analyse DDB file generated previously
fout.write("cat %s <<EOF\n" % "mrgddb.in")
fout.write("mrgddb.ddb.out\n")
fout.write("xxx\n")
fout.write("%d\n" % (self.ndtset - 2))
for i in range(3, self.ndtset + 1):
fout.write("dfpt-phonon-o_DS%d_DDB\n" % i)
fout.write("EOF\n")
fout.write("%s $PMF_MRGDDB < mrgddb.in\n" %
self.run_params["mpi"])
# anaddb
fout.write("cat > %s <<EOF\n" % "anaddb.in")
fout.write("ifcflag 1\n")
fout.write("ifcout 0\n")
fout.write("! wavevector grid\n")
fout.write("brav 2\n")
fout.write("ngqpt 3 3 3\n")
fout.write("! effective charge\n")
fout.write("chneut 1\n")
fout.write("! interatomic force constant info\n")
fout.write("dipdip 1\n")
fout.write("! Phonon band structure output for band2eps\n")
fout.write("eivec 4\n")
fout.write("! wavevector list\n")
fout.write("EOF\n")
#with open(os.path.join(directory, "anaddb.files"), 'w') as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.files")
fout.write("anaddb.in\n")
fout.write("anaddb.out\n")
fout.write("%s_DS3_DDB\n" % self.files.wavefunc_out)
fout.write("dummy_moldyn\n")
fout.write("dummy_GKK\n")
fout.write("dummy_epout\n")
fout.write("dummy_ddk\n")
fout.write("EOF\n")
#fout.write("%s %s < %s\n" % (self.run_params["mpi"], "$PMF_ANADDB", "anaddb.files"))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash dfpt-phonon.sh")
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="dfpt-phonon",
server=self.run_params["server"])
def turbo_davidson(self,
directory="tmp-qe-static",
inpname1="turbo-davidson.in",
output1="turbo-davidson.out",
inpname2="turbo-spectrum-davidson.in",
output2="turbo-spectrum-davidson.out",
runopt="gen",
auto=0):
"""
references:
https://gitlab.com/qef/material-for-ljubljana-qe-summer-school/blob/master/day-3/handson-day3-tddfpt.pdf
turbo_davidson.x:
calculate adsorption spectra of molecules using time-dependent
density functinal perturbation theory(tddfpt).
if if_dft_spectrum is set to .true. the result will be the same
as calculated using epsilon.x, where there is no interaction.
so set if_dft_spectrum to .false. to turn on the interaction.
and you will get a shift of the peak compared to results calculated
using epsilon.x or turbo_davidson.x(with if_dft_spectrum = .true.).
when if_dft_spectrum is set to .true. turbo_davidson.x will produce
a prefix-dft.eigen file, while a prefix.eigen file is produced if
if_dft_spectrum is set to .false.
we can also calculate absorption spectra using psudo-potential
designed for b3lyp functional with turbo_davidson.x
this way, we should set input_dft = 'b3lyp' in scf calcualtion
and set d0psi_rs = .true. in input file for turbo_davidson.x
turbo_spectrum.x:
post-processing calculation of the spectrum
note:
turbotddft is not extended to metals, so we can only
deal with insulators or semiconductors with turbo now.
ltetra are not implemented now
"""
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" warning !!!\n")
print("===================================================\n")
print("turbo_davidson calculation:\n")
print(
" directory of previous scf or nscf calculattion not found!\n"
)
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
with open(os.path.join(directory, inpname1), 'w') as fout:
fout.write("&lr_input\n")
fout.write("prefix = '%s'\n" % self.lr_input_td["prefix"])
fout.write("outdir = '%s'\n" % self.lr_input_td["outdir"])
#fout.write("wfcdir = ''")
fout.write("/\n")
fout.write("\n")
fout.write("&lr_dav\n")
fout.write("if_dft_spectrum = %s\n" %
self.lr_dav_td["if_dft_spectrum"])
fout.write("num_eign = %d\n" % self.lr_dav_td["num_eign"])
fout.write("num_init = %d\n" % self.lr_dav_td["num_init"])
fout.write("num_basis_max = %d\n" %
self.lr_dav_td["num_basis_max"])
fout.write("residue_conv_thr = %f\n" %
self.lr_dav_td["residue_conv_thr"])
fout.write("start = %f\n" % self.lr_dav_td["start"])
fout.write("finish = %f\n" % self.lr_dav_td["finish"])
fout.write("step = %f\n" % self.lr_dav_td["step"])
fout.write("broadening = %f\n" % self.lr_dav_td["broadening"])
fout.write("reference = %f\n" % self.lr_dav_td["reference"])
fout.write("/\n")
fout.write("\n")
with open(os.path.join(directory, inpname2), 'w') as fout:
fout.write("&lr_input\n")
fout.write("prefix = '%s'\n" % self.lr_input_ts["prefix"])
fout.write("outdir = %s\n" % self.lr_input_ts["outdir"])
fout.write("td = 'davidson'\n")
fout.write("epsil = %f\n" % self.lr_input_ts["epsil"])
fout.write("start = %f\n" % self.lr_input_ts["start"])
fout.write("end = %f\n" % self.lr_input_ts["end"])
fout.write("increment = %f\n" % self.lr_input_ts["increment"])
fout.write("eign_file = '%s'\n" % "pwscf.eigen")
fout.write("/\n")
fout.write("\n")
# gen yh job submit script
with open(os.path.join(directory, "turbo-davidson.sub"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("yhrun -N 1 -n 24 turbo_davidson.x < %s > %s\n" %
(inpname1, output1))
fout.write("yhrun -N 1 -n 24 turbo_spectrum.x < %s > %s\n" %
(inpname2, output2))
# gen pbs job submit script
with open(os.path.join(directory, "turbo-davidson.pbs"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" %
(self.run_params["nodes"], self.run_params["ppn"]))
if "queue" in self.run_params and self.run_params[
"queue"] != None:
fout.write("#PBS -q %s\n" % self.run_params["queue"])
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE turbo_davidson.x < %s > %s\n"
% (inpname1, output1))
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE turbo_spectrum.x < %s > %s\n"
% (inpname2, output2))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s turbo_davidson.x < %s | tee %s" %
(self.run_params["mpi"], inpname1, output1))
os.system("%s turbo_spectrum.x < %s | tee %s" %
(self.run_params["mpi"], inpname2, output2))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="turbo-davidson",
server=self.params["server"])
def converge_ecut(self, emin, emax, step, directory="tmp-abinit-ecut", runopt="gen", auto=0):
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.system("cp *.psp8 %s/" % directory)
os.system("cp %s %s/" % (self.dataset[0].system.xyz.file, directory))
os.chdir(directory)
n_test = int((emax - emin) / step)
for i in range(n_test + 1):
cutoff = int(emin + i * step)
inp_name = "ecut-%d.in" % cutoff
files_name = "ecut-%d.files" % cutoff
with open(files_name, 'w') as fout:
fout.write(inp_name)
fout.write("\n")
fout.write("ecut-%d.out\n" % cutoff)
fout.write("ecut-%d-dataset[0]\n" % cutoff)
fout.write("ecut-%d-output\n" % cutoff)
fout.write("temp\n")
for element in self.dataset[0].system.xyz.specie_labels:
fout.write("%s\n" % (element + ".psp8"))
#
self.dataset[0].electrons.params["ecut"] = cutoff
with open(inp_name, 'w') as fout:
#self.dataset[0].electrons.to_dataset[0](fout)
#self.dataset[0].system.to_dataset[0](fout)
fout.write(self.dataset[0].electrons.to_string())
fout.write(self.dataset[0].system.to_string())
os.chdir("../")
# generate llhpc script files
with open(os.path.join(directory, "converge-ecut.slurm"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#SBATCH -p %s\n" % self.run_params["partition"])
fout.write("#SBATCH -N %d\n" % self.run_params["nodes"])
fout.write("#SBATCH -n %d\n" % self.run_params["ntask"])
fout.write("#SBATCH -J %s\n" % self.run_params["jobname"])
fout.write("#SBATCH -o %s\n" % self.run_params["stdout"])
fout.write("#SBATCH -e %s\n" % self.run_params["stderr"])
for i in range(n_test + 1):
cutoff = int(emin + i * step)
#inp_name = "ecut-%d.in" % cutoff
files_name = "ecut-%d.files" % cutoff
fout.write("yhrun %s < %s\n" % ("$PMF_ABINIT", files_name))
# generate pbs script files
with open(os.path.join(directory, "converge-ecut.pbs"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" % (self.run_params["nodes"], self.run_params["ppn"]))
if "queue" in self.run_params and self.run_params["queue"] != None:
fout.write("#PBS -q %s\n" %self.run_params["queue"])
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
for i in range(n_test + 1):
cutoff = int(emin + i * step)
#inp_name = "ecut-%d.in" % cutoff
files_name = "ecut-%d.files" % cutoff
fout.write("mpirun -np $NP -machinefile $PBS_NODEFILE %s < %s\n" % ("$PMF_ABINIT", files_name))
# generate the result analsysis scripts
os.system("mkdir -p %s/post-processing" % directory)
with open(os.path.join(directory, "post-processing/analysis-ecut.sh"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("\n")
for i in range(n_test + 1):
cutoff = int(emin + i * step)
out_f_name = "ecut-%d.out" % cutoff
#fout.write("cat ../%s | grep 'Etotal=' >> energy-ecut.data" % out_f_name)
fout.write("energy=`cat ../%s | grep \'Etotal=\' | cut -d \"=\" -f 2 `\n" % out_f_name)
fout.write("cat >> energy-ecut.data<<EOF\n")
fout.write("%d ${energy}\n" % cutoff)
fout.write("EOF\n")
fout.write("\n")
fout.write("cat >> ecut-energy.gp<<EOF\n")
fout.write("set term gif\n")
fout.write("set output 'energy-ecut.gif'\n")
fout.write("set title 'Ecut Converge Test'\n")
fout.write("set xlabel 'Ecut()'\n")
fout.write("set ylabel 'Total Energy()'\n")
fout.write("plot 'energy-ecut.data' w l\n")
fout.write("EOF\n")
fout.write("\n")
fout.write("gnuplot ecut-energy.gp")
#
if runopt == "run" or runopt == "genrun":
# run the simulation
os.chdir(directory)
for i in range(n_test + 1):
cutoff = int(emin + i * step)
files_name = "ecut-%d.files" % cutoff
os.system("abinit < %s" % (files_name))
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="converge-ecut", server=self.run_params["server"])
def turbo_lanczos(self,
directory="tmp-qe-static",
inpname1="turbo-lanczos.in",
output1="turbo-lanczos.out",
inpname2="turbo-spectrum-lanczos.in",
output2="turbo-spectrum-lanczos.out",
runopt="gen",
auto=0):
"""
references:
https://gitlab.com/qef/material-for-ljubljana-qe-summer-school/blob/master/day-3/handson-day3-tddfpt.pdf
turbo_lanczos.x:
allows us to calculate absorption spectra of molecules using
time-dependent density functional perturbation theory (TDDFPT)
without computing empty states!
turbo_lanczos.x allows us to obtain the absorption spectrum in a wide frequency
range just by repeating a post-processing calculation using turbo_spectrum.x in a
larger frequency range. This cannot be done with turbo_davidson.x
turnbo_spectrum.x:
post-processing calculation of the spectrum
Note:
turboTDDFT is not extended to metals
ltetra are not implemented now
"""
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("turbo_lanczos calculation:\n")
print(
" directory of previous scf or nscf calculattion not found!\n"
)
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
with open(os.path.join(directory, inpname1), 'w') as fout:
fout.write("&lr_input\n")
fout.write("prefix = '%s'\n" % self.lr_input_tl["prefix"])
fout.write("outdir = '%s'\n" % self.lr_input_tl["outdir"])
fout.write("restart_step = %d\n" %
self.lr_input_tl["restart_step"])
fout.write("restart = %s\n" % self.lr_input_tl["restart"])
fout.write("/\n")
fout.write("\n")
fout.write("&lr_control\n")
fout.write("itermax = %d\n" % self.lr_control_tl["itermax"])
fout.write("ipol = %d\n" % self.lr_control_tl["ipol"])
fout.write("/\n")
fout.write("\n")
with open(os.path.join(directory, inpname2), 'w') as fout:
fout.write("&lr_input\n")
fout.write("prefix = '%s'\n" % self.lr_input_ts["prefix"])
fout.write("outdir = %s\n" % self.lr_input_ts["outdir"])
fout.write("intermax0 = %d\n" % self.lr_input_ts["intermax0"]
) # Number of calculated Lanczos coefficient
fout.write("intermax = %d\n" % self.lr_input_ts["intermax"]
) # umber of extrapolated Lanczos coefficient
fout.write("extrapolation = '%s'\n" %
self.lr_input_ts["extrapolation"]
) # Type of extrapolation (bi-constant)
fout.write("epsil = %f\n" % self.lr_input_ts["epsil"]
) # The value of Lorenzian smearing in Ry
fout.write("start = %f\n" % self.lr_input_ts["start"]
) # Minimum value of frequencies for a plot in Ry
fout.write("end = %f\n" % self.lr_input_ts["end"]
) # Maximum value of frequencies for a plot in Ry
fout.write(
"increment = %f\n" %
self.lr_input_ts["increment"]) # Frequency step in Ry
fout.write(
"ipol = %d\n" % self.lr_input_ts["ipol"]
) # Polarization direction (same as in turbo_lanczos.x)
fout.write("/\n")
fout.write("\n")
# gen yh job submit script
with open(os.path.join(directory, "turbo-lanczos.sub"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("yhrun -N 1 -n 24 turbo_lanczos.x < %s > %s\n" %
(inpname1, output1))
fout.write("yhrun -N 1 -n 24 turbo_spectrum.x < %s > %s\n" %
(inpname2, output2))
# gen pbs job submit script
with open(os.path.join(directory, "turbo-lanczos.pbs"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" %
(self.run_params["nodes"], self.run_params["ppn"]))
if "queue" in self.run_params and self.run_params[
"queue"] != None:
fout.write("#PBS -q %s\n" % self.run_params["queue"])
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE turbo_lanczos.x < %s > %s\n"
% (inpname1, output1))
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE turbo_spectrum.x < %s > %s\n"
% (inpname2, output2))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s turbo_lanczos.x < %s | tee %s" %
(self.run_params["mpi"], inpname1, output1))
os.system("%s turbo_spectrum.x < %s | tee %s" %
(self.run_params["mpi"], inpname2, output2))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="turbo-lanczos",
server=self.params["server"])
fout.write("set title Energy Latconst\n")
fout.write("set xlabel 'latconst(a)'\n")
fout.write("set ylabel 'Energy'\n")
fout.write("plot 'energy-latconst.data' w l\n")
fout.write("EOF\n")
else:
if args.nc >= 2:
fout.write("for c in `seq -w %f %f %f`\n" % (c-args.nc/2*args.stepc, args.stepc, c+args.nc/2*args.stepc))
fout.write("do\n")
fout.write(" energy=`cat ../relax-${c}/optimization.out | grep 'Total =' | tail -n -1 | cut -d \"=\" -f 2`\n")
fout.write(" cat >> energy-latconst.data <<EOF\n")
fout.write("${c} ${energy}\n")
fout.write("EOF\n")
fout.write("done\n")
fout.write("cat > energy-latconst.gp<<EOF\n")
fout.write("set term gif\n")
fout.write("set output 'energy-latconst.gif'\n")
fout.write("set title Energy Latconst\n")
fout.write("set xlabel 'latconst(c)'\n")
fout.write("set ylabel 'Energy'\n")
fout.write("plot 'energy-latconst.data' w l\n")
fout.write("EOF\n")
else:
# nothing to do
pass
#os.system("cd post-processing; bash get_energy.sh; cd ../")
os.chdir("../")
server_handle(auto=args.auto, directory=args.directory, jobfilebase="opt-hexagonal", server=args.server)
# ==========================================================
args = parser.parse_args()
params = {}
params["FORCE_EVAL-DFT-LS_SCF"] = args.ls_scf
params["FORCE_EVAL-DFT-QS-METHOD"] = args.qs_method
params["FORCE_EVAL-DFT-MGRID-CUTOFF"] = args.cutoff
params["FORCE_EVAL-DFT-MGRID-REL_CUTOFF"] = args.rel_cutoff
params["FORCE_EVAL-DFT-XC-XC_FUNCTIONAL"] = args.xc_functional
params["FORCE_EVAL-DFT-SCF-EPS_SCF"] = args.eps_scf
params["FORCE_EVAL-DFT-SCF-ADDED_MOS"] = args.added_mos
params["FORCE_EVAL-DFT-SCF-SMEAR"] = args.smear
params["FORCE_EVAL-DFT-SCF-SMEAR-METHOD"] = args.smear_method
params[
"FORCE_EVAL-DFT-SCF-SMEAR-ELECTRONIC_TEMPERATURE"] = args.electronic_temp
params["FORCE_EVAL-DFT-SCF-SMEAR-WINDOW_SIZE"] = args.window_size
params["FORCE_EVAL-DFT-SCF-DIAGONALIZATION"] = args.diag
params["FORCE_EVAL-DFT-SCF-OT"] = args.ot
params["FORCE_EVAL-DFT-SCF-MIXING-ALPHA"] = args.alpha
params["FORCE_EVAL-DFT-KPOINTS-SCHEME"] = args.kpoints_scheme
task = md_run()
task.get_xyz(args.file)
#task.vib(directory=args.directory, runopt=args.runopt, force_eval=force_eval, motion=motion, jobname=args.jobname, nodes=args.nodes, ppn=args.ppn)
server_handle(auto=args.auto,
directory=args.directory,
jobfilebase="md-vib",
server=args.server)
fout.write("# format: a energy(eV)\n")
fout.write("EOF\n")
# end
fout.write("for a in `seq -w %f %f %f`\n" %
(a - args.na / 2 * args.stepa, args.stepa,
a + args.na / 2 * args.stepa))
fout.write("do\n")
fout.write(
" energy=`cat ../relax-${a}/optimization.out | grep 'Total =' | tail -n -1 | cut -d \"=\" -f 2`\n"
)
fout.write(" cat >> energy-latconst.data <<EOF\n")
fout.write("${a} ${energy}\n")
fout.write("EOF\n")
fout.write("done\n")
fout.write("cat > energy-latconst.gp<<EOF\n")
fout.write("set term gif\n")
fout.write("set output 'energy-latconst.gif'\n")
fout.write("set title Energy Latconst\n")
fout.write("set xlabel 'latconst(a)'\n")
fout.write("set ylabel 'Energy'\n")
fout.write("plot 'energy-latconst.data' w l\n")
fout.write("EOF\n")
#os.system("cd post-processing; bash get_energy.sh; cd ../")
os.chdir("../")
server_handle(auto=args.auto,
directory=args.directory,
jobfilebase="opt-cubic",
server=args.server)
def epsilon(self,
directory="tmp-qe-static",
inpname="epsilon.in",
output="epsilon.out",
runopt="gen",
auto=0):
"""
References:
https://gitlab.com/QEF/material-for-ljubljana-qe-summer-school/blob/master/Day-3/handson-day3-TDDFPT.pdf
epsilon.x:
calculation of absorption spectra in IPA(Independent Particle
Approximation).
Note:
USPP rea not implemented now
"""
# first check whether there is a previous scf running
if not os.path.exists(directory):
print("===================================================\n")
print(" Warning !!!\n")
print("===================================================\n")
print("epsilon.x calculation:\n")
print(
" directory of previous scf or nscf calculattion not found!\n"
)
sys.exit(1)
if runopt == "gen" or runopt == "genrun":
with open(os.path.join(directory, inpname), 'w') as fout:
fout.write("&INPUTPP\n")
fout.write("calculation = '%s'\n" %
self.inputpp_epsilon["calculation"])
fout.write("prefix = '%s'\n" % self.inputpp_epsilon["prefix"])
fout.write("outdir = '%s'\n" % self.inputpp_epsilon["outdir"])
fout.write("/\n")
fout.write("\n")
fout.write("&ENERGY_GRID\n")
fout.write("smeartype = '%s'\n" %
self.energy_grid_epsilon["smeartype"]
) # type of smearing of the spectrum
fout.write("intersmear = %f\n" %
self.energy_grid_epsilon["intersmear"]
) # the valus of smearing in eV
fout.write("wmin = %f\n" % self.energy_grid_epsilon["wmin"]
) # minimum value of frequencies for a plot in eV
fout.write("wmax = %f\n" % self.energy_grid_epsilon["wmax"]
) # maximum value of frequencies for a plot in eV
fout.write("nw = %f\n" % self.energy_grid_epsilon["nw"]
) # number of points between wmin and wmax
fout.write("/\n")
fout.write("\n")
# gen yh job submit script
with open(os.path.join(directory, "epsilon.sub"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("yhrun -N 1 -n 24 epsilon.x < %s > %s\n" %
(inpname, output))
# gen pbs job submit script
with open(os.path.join(directory, "epsilon.pbs"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" %
(sel.frun_params["nodes"], self.run_params["ppn"]))
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE epsilon.x < %s > %s\n"
% (inpname, output))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("%s epsilon.x < %s | tee %s" %
(self.run_params["mpi"], inpname, output))
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="epsilon",
server=self.params["server"])
def dfpt(self, directory="tmp-vasp-static", runopt="gen", mode=0, auto=0):
"""
directory: a place for all the generated files
mode:
0: a brand new calculation, will create a new directory
and start a brand new dfpt including brand new scf.
1: there is already a scf calculation, and we will change
to the existing directory and read the previous data
and do the dfpt(the original INCAR if exists wil be backup
as INCAR.old). this will reduce the time needed to
do the scf calculation.
dfpt run is based scf ground calculation. but in vasp,
you can specify scf running and dfpt running in the smame
INCAR and do them in a single run.
thus we we will inspect whether there exist a previous scf
running. if there is, we will not remove the directory but
just check in and backup the original INCAR to INCAR.old
and generate the dfpt running INCAR.
Note:
"""
if runopt == "gen" or runopt == "genrun":
if mode == 0:
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
os.system("cp %s %s/" % (self.poscar.xyz.file, directory))
elif mode == 1:
if not os.path.exists(directory):
print("================================================\n")
print(" Warning !!!\n")
print("================================================\n")
print("vasp.dfpt_run.dfpt\n")
print("when mode = 1\n")
print("there must exists the previous running directory\n")
print("but it is not there\n")
sys.exit(1)
#
if os.path.exists(os.path.join(directory, "INCAR")):
os.rename(os.path.join(directory, "INCAR"),
os.path.join(directory, "INCAR.old"))
shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
os.system("cp %s %s/" % (self.poscar.xyz.file, directory))
#
with open(os.path.join(directory, "POSCAR"), 'w') as fout:
self.poscar.to_poscar(fout)
# gen llhpc script
self.gen_llhpc(directory=directory,
cmd="$PMF_VASP_STD",
scriptname="dfpt.slurm")
# gen pbs script
self.gen_pbs(directory=directory,
cmd="$PMF_VASP_STD",
scriptname="dfpt.pbs",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
# gen local bash script
self.gen_bash(directory=directory,
cmd="$PMF_VASP_STD",
scriptname="dfpt.sh")
# gen lsf_sz script
self.gen_lsf_sz(directory=directory,
cmd="$PMF_VASP_STD",
scriptname="dfpt.lsf_sz",
np=self.run_params["nodes"] *
self.run_params["ppn"],
np_per_node=self.run_params["ppn"])
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
#os.system("vasp")
os.system("bash dfpt.sh")
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="dfpt",
server=self.run_params["server"])
def phonopy(self, directory="tmp-qe-phonopy", pos_inpname="pos.in", head_inpname="head.in", mpi="", runopt="gen", auto=0):
"""
:param directory: a place for all the generated files
"""
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
#os.system("cp *.UPF %s/" % directory)
#os.system("cp %s %s/" % (self.arts.xyz.file, directory))
# do not copy too many files at the same time or it will be slow
# so we do not copy all UPF files in the directory but just copy
# those used in the calculation.
shutil.copyfile(self.arts.xyz.file, os.path.join(directory, os.path.basename(self.arts.xyz.file)))
#all_upfs = [s for s in os.listdir() if s.split(".")[-1] == "UPF"]
all_file = os.listdir()
for element in self.arts.xyz.specie_labels:
for item in all_file:
#if re.match("(%s)(.*)(upf)" % element, item, re.IGNORECASE):
#if item.split(".")[0].lower() == element.lower() or item.split("_")[0].lower() == element.lower():
if re.match("(%s)(.*)(upf)" % element, item, re.IGNORECASE) or re.match("(%s)(_*)(upf)" % element, item, re.IGNORECASE):
shutil.copyfile(item, os.path.join(directory, item))
break
self.arts.pseudo.dir = os.path.abspath(directory)
self.control.set_params({"pseudo_dir": os.path.abspath(directory)})
#
with open(os.path.join(directory, head_inpname), 'w') as fout:
self.control.to_in(fout)
self.system.to_in(fout)
self.electrons.to_in(fout)
self.arts.write_kpoints(fout)
# set up the Phonopy calculation
os.chdir(directory)
os.system("cat %s > %s" % (head_inpname, pos_inpname))
with open(pos_inpname, 'a') as fout:
self.arts.to_in(fout, coordtype="crystal")
os.system("phonopy --qe -d --dim='%d %d %d' -c %s" % (self.supercell_n[0], self.supercell_n[1], self.supercell_n[2], pos_inpname))
os.system("ls | grep 'supercell-' > pos.data")
disp_dirs = []
with open("pos.data", 'r') as fin:
for line in fin:
disp_dirs.append(line.split(".")[0].split("-")[1])
# IMPORTANT:
# we need to overwrite the head_inpname file, reasons are bellow
# here we must pay attention to system.params["nat"]
# as system.params["nat"] is the value of the original structure
# but after phonopy build the supercell the number of atoms changes
# accordingly. so we must change the value of system.params["nat"]
# according to self.supercell_n
self.system.params["nat"] = self.system.params["nat"] * self.supercell_n[0] * self.supercell_n[1] * self.supercell_n[2]
with open(head_inpname, 'w') as fout:
self.control.to_in(fout)
self.system.to_in(fout)
self.electrons.to_in(fout)
self.arts.write_kpoints(fout)
#
for disp in disp_dirs:
os.system("cat %s supercell-%s.in > supercell-%s-full.in" % (head_inpname, disp, disp))
os.system("rm supercell-%s.in" % disp)
os.chdir("../")
# end build the phonopy
# gen yhbatch script
with open(os.path.join(directory, "phonopy-job.slurm"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#SBATCH -p %s\n" % self.run_params["partition"])
fout.write("#SBATCH -N %d\n" % self.run_params["nodes"])
fout.write("#SBATCH -n %d\n" % self.run_params["ntask"])
fout.write("#SBATCH -J %s\n" % self.run_params["jobname"])
fout.write("#SBATCH -o %s\n" % self.run_params["stdout"])
fout.write("#SBATCH -e %s\n" % self.run_params["stderr"])
fout.write("\n")
for disp in disp_dirs:
fout.write("yhrun $PMF_PWX < supercell-%s-full.in > supercell-%s.out\n" % (disp, disp))
# gen pbs script
with open(os.path.join(directory, "phonopy-job.pbs"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" % (self.run_params["nodes"], self.run_params["ppn"]))
if "queue" in self.run_params and self.run_params["queue"] != None:
fout.write("#PBS -q %s\n" %self.run_params["queue"])
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write("\n")
for disp in disp_dirs:
fout.write("mpirun -np $NP -machinefile $PBS_NODEFILE $PMF_PWX < supercell-%s-full.in > supercell-%s.out\n" % (disp, disp))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
# run the dft
disp_dirs = []
with open("pos.data", 'r') as fin:
for line in fin:
disp_dirs.append(line.split(".")[0].split("-")[1])
for disp in disp_dirs:
os.system("%s $PMF_PWX < supercell-%s-full.in | tee supercell-%s.out" % (self.run_params["mpi"], disp, disp))
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="phonopy-job", server=self.run_params["server"])
def phonopy(self, directory="tmp-cp2k-phonopy", runopt="gen", auto=0):
self.force_eval.check_spin()
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.chdir(directory)
shutil.copyfile(self.force_eval.subsys.xyz.file, "%s" % os.path.basename(self.force_eval.subsys.xyz.file))
inp_name = "phonon.inp"
with open(inp_name, 'w') as fout:
self.glob.to_input(fout)
#fout.write("\n")
fout.write("&FORCE_EVAL\n")
fout.write("\tMETHOD Quickstep\n")
# subsys
self.to_subsys_phonopy(inp_name)
# end subsys
with open(inp_name, 'a') as fout:
# dft
self.force_eval.dft.to_input(fout)
# end dft
fout.write("&END FORCE_EVAL\n")
# build the phonopy running files
os.system("phonopy --cp2k -c %s -d --dim='%d %d %d'" % (inp_name, self.supercell_n[0], self.supercell_n[1], self.supercell_n[2]))
# now phonon-supercell-00x.inp is generated which will be used to construct input for cp2k
# in the past the above command will generate the supercell-00x.inp which can not be the
# input file of cp2k directly, and need us to construct the final input for cp2k for every
# displacement. but after an update of phonopy to version 2.4.2. the enerated phonon-supercell-00x.inp
# can be run by cp2k directly! so we comment those old code for constructing the final input file.
os.system("ls | grep 'phonon-supercell-' > geo.data")
disps = []
with open("geo.data", 'r') as fin:
for line in fin:
disps.append(line.split(".")[0].split("-")[2])
#for disp in disps:
# in_name = "phonon-supercell-%s.inp" % disp
# if os.path.exists(in_name) is not True:
# break
# tmp_file = "phonon-supercell-%s.tmp.txt" % disp
# shutil.copyfile(in_name, tmp_file)
# # important: different disp calculation should have different PROJECT name
# self.glob.params["PROJECT"] = "abinitio" + "-supercell-" + disp
# with open(in_name, 'w') as fout:
# self.glob.to_input(fout)
# fout.write("\n")
# fout.write("&FORCE_EVAL\n")
# fout.write("\tMETHOD Quickstep\n")
# fout.write("\t&SUBSYS\n")
# self.print_kinds(in_name)
# os.system("cat %s | sed '1d;2d;3d;4d;5d;6d;7d' | sed '$d' | sed '$d' | sed '$d' | sed '$d' | sed '$d' >> %s" % (tmp_file, in_name))
# with open(in_name, 'a') as fout:
# fout.write("\t&END SUBSYS\n")
# # dft
# self.force_eval.dft.to_input(fout)
# # end dft
# fout.write("\t&PRINT\n")
# fout.write("\t\t&FORCES\n")
# fout.write("\t\t\tFILENAME forces\n")
# fout.write("\t\t&END FORCES\n")
# fout.write("\t&END PRINT\n")
# fout.write("&END FORCE_EVAL\n")
os.chdir("../")
#
# generate yhbatch file
with open(os.path.join(directory, "phonopy-job.slurm"), 'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#SBATCH -p %s\n" % self.run_params["partition"])
fout.write("#SBATCH -N %d\n" % self.run_params["nodes"])
fout.write("#SBATCH -n %d\n" % self.run_params["ntask"])
fout.write("#SBATCH -J %s\n" % self.run_params["jobname"])
fout.write("#SBATCH -o %s\n" % self.run_params["stdout"])
fout.write("#SBATCH -e %s\n" % self.run_params["stderr"])
for disp in disps:
fout.write("yhrun -N 1 -n 24 $PMF_CP2K -in phonon-supercell-%s.inp > phonon-supercell-%s.inp.out\n" % (disp, disp))
# generate pbs file
with open(os.path.join(directory, "phonopy-job.pbs"), 'w') as fout:
fout.write("#!/bin/bash\n\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" % (self.run_params["nodes"], self.run_params["ppn"]))
if "queue" in self.run_params and self.run_params["queue"] != None:
fout.write("#PBS -q %s\n" %self.run_params["queue"])
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
for disp in disps:
fout.write("mpirun -np $NP -machinefile $PBS_NODEFILE $PMF_CP2K -in phonon-supercell-%s.inp > phonon-supercell-%s.inp.out\n" % (disp, disp))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
disps = []
with open("geo.data", 'r') as fin:
for line in fin:
disps.append(line.split(".")[0].split("-")[2])
for disp in disps:
in_name = "supercell-%s.inp" % disp
os.system("%s $PMF_CP2K -in phonon-supercell-%s.inp | tee phonon-supercell-%s.inp.out" % (self.run_params["mpi"], disp, disp))
os.chdir("../")
server_handle(auto=auto, directory=directory, jobfilebase="phonopy-job", server=self.run_params["server"])
def run(self,
directory="tmp-abinit-dfpt-elastic-piezo-dielec",
runopt="gen",
auto=0):
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
os.system("cp *.psp8 %s/" % directory)
os.system("cp *.GGA_PBE-JTH.xml %s/" % directory)
os.system("cp %s %s/" %
(self.dataset[0].system.xyz.file, directory))
self.files.name = "dfpt-elastic-piezo.files"
self.files.main_in = "dfpt-elastic-piezo.in"
self.files.main_out = "dfpt-elastic-piezo.out"
self.files.wavefunc_in = "dfpt-elastic-piezo-i"
self.files.wavefunc_out = "dfpt-elastic-piezo-o"
self.files.tmp = "tmp"
self.dataset[0].dfpt.status = True
self.dataset[1].dfpt.status = True
self.dataset[2].dfpt.status = True
self.dataset[3].dfpt.status = True
# overall defaultg dataset 0
#self.dataset[0].electrons.set_scf_nscf("scf")
# 1) ground state scf calculation
self.dataset[1].electrons.use_tol(tol="tolvrs", value=1.0e-10)
self.dataset[1].electrons.kpoints.params["ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
# 2) calculate ddk wave functions (iscf = -3, rfelfd =2, qpt = 0 0 0, rfdir = 1 1 1)
# note here rfelfd = 2 means we only calculate perturbation to dk and
# perturbation to electric field is not accounted! see https://docs.abinit.org/tutorial/elastic/
self.dataset[2].electrons.use_tol(tol="tolwfr", value=1.0e-22)
self.dataset[2].electrons.params["getwfk"] = -1
self.dataset[2].electrons.kpoints.params["kptopt"] = 2
self.dataset[2].electrons.kpoints.params["ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
self.dataset[2].electrons.params["iscf"] = -3
self.dataset[2].dfpt.params[
"rfelfd"] = 2 # here we only do ddk calculation, no electric field perturbation
self.dataset[2].dfpt.params["rfdir"] = [1, 1, 1]
self.dataset[2].dfpt.params["nqpt"] = 1
self.dataset[2].dfpt.params["qpt"] = [0, 0, 0]
# 3) calculate 2DTE for elastic and piezoelectric tensors (rfphon = 1, rfatpol, rfdir = 1 1 1, rfstrs = 3)
self.dataset[3].electrons.use_tol(tol="tolvrs", value=1.0e-10)
self.dataset[3].electrons.kpoints.params["kptopt"] = 2
self.dataset[3].electrons.kpoints.params["ngkpt"] = self.dataset[
0].electrons.kpoints.params["ngkpt"]
self.dataset[3].electrons.params["getddk"] = -1
self.dataset[3].electrons.params["getwfk"] = -2
self.dataset[3].dfpt.params["nqpt"] = 1
self.dataset[3].dfpt.params["qpt"] = [0, 0, 0]
self.dataset[3].dfpt.params["rfphon"] = 1
# in dataset 2 we only do the ddk calculation, and int the output file you can only find Effective charge
# (from phonon response). now we can do electric field perturbation using rfelfd=3,
# this way Born effective charge (from electric fiedl perturbation) will also be print out to the abinit output
# and output of anaddb will contains information of Effective charge.
# plus the output can be analysed further by anaddb and dielectric tensor can be calculated.
self.dataset[3].dfpt.params[
"rfelfd"] = 3 # you can also set it to None, if you want no perturbation to electric field
self.dataset[3].dfpt.params["rfatpol"] = [
1, self.dataset[0].system.xyz.natom
]
self.dataset[3].dfpt.params["rfdir"] = [1, 1, 1]
self.dataset[3].dfpt.params["rfstrs"] = 3
# llhpc jobsubmit script
with open(
os.path.join(directory, "dfpt-elastic-piezo-dielec.slurm"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#SBATCH -p %s\n" % self.run_params["partition"])
fout.write("#SBATCH -N %d\n" % self.run_params["nodes"])
fout.write("#SBATCH -n %d\n" % self.run_params["ntask"])
fout.write("#SBATCH -J %s\n" % self.run_params["jobname"])
fout.write("#SBATCH -o %s\n" % self.run_params["stdout"])
fout.write("#SBATCH -e %s\n" % self.run_params["stderr"])
fout.write("cat > %s<<EOF\n" % self.files.main_in)
fout.write(self.to_string())
fout.write("EOF\n")
fout.write("cat > %s<<EOF\n" % self.files.name)
fout.write(self.files.to_string(system=self.dataset[0].system))
fout.write("EOF\n")
fout.write("yhrun %s < %s\n" %
("$PMF_ABINIT", self.files.name))
# use anaddb to analyse DDB file generated previously
#with open(os.path.join(directory, "anaddb.in"), "w") as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.in")
fout.write("elaflag 3\n")
fout.write("piezoflag 7\n")
# piezoflag = 7 means calculate all the possible piezoelectric tensors, including e (clamped and relaxed ion), d, g and h tensors
# if g and h tensor are to be calculated must set dieflag to 3 or 4, or it will print the wrong value
# but the calculation will continue
fout.write("instrflag 1\n")
fout.write("chneut 1\n")
fout.write("dieflag 1\n")
fout.write(
"# if ecut and kmesh is not sufficient, the calc of dielectric tensor might collapse\n"
)
# The frequency-dependent dielectric tensor is calculated
# see https://docs.abinit.org/variables/anaddb/#dieflag
# if ecut and kmesh is not sufficient, the calc of dielectric tensor might collapse
fout.write("EOF\n")
#with open(os.path.join(directory, "anaddb.files"), 'w') as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.files")
fout.write("anaddb.in\n")
fout.write("anaddb.out\n")
fout.write("%s_DS3_DDB\n" % self.files.wavefunc_out)
fout.write("dummy_moldyn\n")
fout.write("dummy_GKK\n")
fout.write("dummy_epout\n")
fout.write("dummy_ddk\n")
fout.write("EOF\n")
fout.write("yhrun %s < %s\n" % ("$PMF_ANADDB", "anaddb.files"))
# pbs jobsubmit script
with open(os.path.join(directory, "dfpt-elastic-piezo-dielec.pbs"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("#PBS -N %s\n" % self.run_params["jobname"])
fout.write("#PBS -l nodes=%d:ppn=%d\n" %
(self.run_params["nodes"], self.run_params["ppn"]))
fout.write("\n")
fout.write("cd $PBS_O_WORKDIR\n")
fout.write("NP=`cat $PBS_NODEFILE | wc -l`\n")
fout.write("cat > %s<<EOF\n" % self.files.main_in)
fout.write(self.to_string())
fout.write("EOF\n")
fout.write("cat > %s<<EOF\n" % self.files.name)
fout.write(self.files.to_string(system=self.dataset[0].system))
fout.write("EOF\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE %s < %s\n" %
("$PMF_ABINIT", self.files.name))
# use anaddb to analyse DDB file generated previously
#with open(os.path.join(directory, "anaddb.in"), "w") as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.in")
fout.write("elaflag 3\n")
fout.write("piezoflag 7\n")
# piezoflag = 7 means calculate all the possible piezoelectric tensors, including e (clamped and relaxed ion), d, g and h tensors
# if g and h tensor are to be calculated must set dieflag to 3 or 4, or it will print the wrong value
# but the calculation will continue
fout.write("instrflag 1\n")
fout.write("chneut 1\n")
fout.write("dieflag 1\n")
fout.write(
"# if ecut and kmesh is not sufficient, the calc of dielectric tensor might collapse\n"
)
# The frequency-dependent dielectric tensor is calculated
# see https://docs.abinit.org/variables/anaddb/#dieflag
# if ecut and kmesh is not sufficient, the calc of dielectric tensor might collapse
fout.write("EOF\n")
#with open(os.path.join(directory, "anaddb.files"), 'w') as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.files")
fout.write("anaddb.in\n")
fout.write("anaddb.out\n")
fout.write("%s_DS3_DDB\n" % self.files.wavefunc_out)
fout.write("dummy_moldyn\n")
fout.write("dummy_GKK\n")
fout.write("dummy_epout\n")
fout.write("dummy_ddk\n")
fout.write("EOF\n")
fout.write(
"mpirun -np $NP -machinefile $PBS_NODEFILE %s < %s\n" %
("$PMF_ANADDB", "anaddb.files"))
# local bash script
with open(os.path.join(directory, "dfpt-elastic-piezo-dielec.sh"),
'w') as fout:
fout.write("#!/bin/bash\n")
fout.write("cat > %s<<EOF\n" % self.files.main_in)
fout.write(self.to_string())
fout.write("EOF\n")
fout.write("cat > %s<<EOF\n" % self.files.name)
fout.write(self.files.to_string(system=self.dataset[0].system))
fout.write("EOF\n")
fout.write(
"%s %s < %s\n" %
(self.run_params["mpi"], "$PMF_ABINIT", self.files.name))
# use anaddb to analyse DDB file generated previously
#with open(os.path.join(directory, "anaddb.in"), "w") as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.in")
fout.write("elaflag 3\n")
fout.write("piezoflag 7 \n")
# piezoflag = 7 means calculate all the possible piezoelectric tensors, including e (clamped and relaxed ion), d, g and h tensors
# if g and h tensor are to be calculated must set dieflag to 3 or 4, or it will print the wrong value
# but the calculation will continue
fout.write("instrflag 1\n")
fout.write("chneut 1\n")
fout.write("dieflag 1\n")
fout.write(
"# if ecut and kmesh is not sufficient, the calc of dielectric tensor might collapse\n"
)
# The frequency-dependent dielectric tensor is calculated
# see https://docs.abinit.org/variables/anaddb/#dieflag
# if ecut and kmesh is not sufficient, the calc of dielectric tensor might collapse
fout.write("EOF\n")
#with open(os.path.join(directory, "anaddb.files"), 'w') as fout:
fout.write("cat > %s <<EOF\n" % "anaddb.files")
fout.write("anaddb.in\n")
fout.write("anaddb.out\n")
fout.write("%s_DS3_DDB\n" % self.files.wavefunc_out)
fout.write("dummy_moldyn\n")
fout.write("dummy_GKK\n")
fout.write("dummy_epout\n")
fout.write("dummy_ddk\n")
fout.write("EOF\n")
fout.write(
"%s %s < %s\n" %
(self.run_params["mpi"], "$PMF_ANADDB", "anaddb.files"))
if runopt == "run" or runopt == "genrun":
os.chdir(directory)
os.system("bash dfpt-elastic-piezo-dielec.sh")
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="dfpt-elastic-piezo-dielec",
server=self.run_params["server"])
def neb(self,
directory="tmp-vasp-neb-vtst",
runopt="gen",
properties={},
auto=0):
"""
directory: a place for all the generated files
"""
self.incar.params["IMAGES"] = self.nimage
# in NEB calc you must set NSW manually, or it will default to 0
# and the optimization will actually be scf
# so we make a check here
if "NSW" not in self.incar.params or self.incar.params["NSW"] == None:
self.incar.params[
"NSW"] = 100 # set to 100 by default if it is not set
if runopt == "gen" or runopt == "genrun":
if os.path.exists(directory):
shutil.rmtree(directory)
os.mkdir(directory)
shutil.copyfile("POTCAR", os.path.join(directory, "POTCAR"))
for image in self.poscars:
os.system("cp %s %s/" % (image.xyz.file, directory))
#self.incar.properties.set_params(properties)
# =======================================
# Constructing the input file for VASP
# =======================================
# using nebmake.pl to build images
os.chdir(directory)
os.mkdir("./is")
os.mkdir("./fs")
with open("./is/POSCAR", 'w') as fout:
self.poscars[0].to_poscar(
fout, coordtype="Direct"
) # use Direct here for better interpolation of images
with open("./fs/POSCAR", 'w') as fout:
self.poscars[-1].to_poscar(fout, coordtype="Direct")
if self.nebmake.lower() == "nebmake.pl":
os.system("nebmake.pl is/POSCAR fs/POSCAR %d" % self.nimage)
elif self.nebmake.lower() == "nebmake.py":
cmd = "nebmake.py --images is/POSCAR fs/POSCAR --nimage %d --moving-atom " % (
self.nimage)
for item in self.moving_atom:
cmd += " %d" % item
os.system(cmd)
os.chdir("../")
# 对每个镜像进行几何优化时可以用vasp的优化器也可以用vtst的
# 设置IOPT为0就使用vasp的优化器, 需要通过IBRION和POTIM来指定
# 否者就可以通过设置IBRION = 3, POTIM = 0来关闭vasp的优化器
# 然后设置IOPT= 1或者2来使用VTST的优化器
# 当设置IOPT > 0，的时候也要注意需要明确设置EDIFFG < 0
# gen llhpc script
self.gen_llhpc(directory=directory,
cmd="$PMF_VASP_STD_NEB",
scriptname="neb.slurm")
# gen pbs script
self.gen_pbs(directory=directory,
cmd="$PMF_VASP_STD_NEB",
scriptname="neb.pbs",
jobname=self.run_params["jobname"],
nodes=self.run_params["nodes"],
ppn=self.run_params["ppn"],
queue=self.run_params["queue"])
# gen local bash script
self.gen_bash(directory=directory,
cmd="$PMF_VASP_STD_NEB",
scriptname="neb.sh")
# gen lsf_sz script
self.gen_lsf_sz(directory=directory,
cmd="$PMF_VASP_STD_NEB",
scriptname="neb.lsf_sz",
np=self.run_params["nodes"] *
self.run_params["ppn"],
np_per_node=self.run_params["ppn"],
queue=self.run_params["queue"])
# gen lsf_sustc script
self.gen_lsf_sustc(directory=directory,
cmd="$PMF_VASP_STD",
scriptname="neb.lsf_sustc",
jobname=self.run_params["jobname"],
np=self.run_params["nodes"] *
self.run_params["ppn"],
np_per_node=self.run_params["ppn"],
queue=self.run_params["queue"])
if runopt == "run" or runopt == "genrun":
# run the neb calculation
# each image on one core
os.chdir(directory)
#os.system("%s vasp" % mpi)
os.system("bash neb.sh")
os.chdir("../")
server_handle(auto=auto,
directory=directory,
jobfilebase="neb",
server=self.run_params["server"])
