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"])