Ejemplo n.º 1
0
    def prep_run_file(self, next_run='next_run.sh'):
        """
        run_fileを修正してnext_run.shを作成
        run_listの実行したjobをコメントアウト
        """
        work_path, fname_exe = self.run_list[0]
        key = "cd $PBS_O_WORKDIR\n"
        # work_pathが相対pathの場合、絶対pathに修正する
        if work_path[0] == '/':
            alt = "cd {0}\n".format(os.path.join(work_path))
        else:
            alt = "cd {0}\n".format(os.path.join(os.getcwd(), work_path))

        lines = Cabinet.read_file(fname_exe)

        # $PBS_O_WORKDIRの記述が無い場合errorメッセージを出力
        try:
            pos = lines.index(key)
        except ValueError:
            print("{0}に'cd $PBS_O_WORKDIR'の記述がありません".format(fname_exe))
            exit()
        lines[pos] = alt
        Cabinet.write_file(next_run, lines)

        finished = self.run_list.pop(0)
        finished[0] = '#' + finished[0]
        self.finished_list.append(finished)
        tmp_list = self.finished_list + self.run_list
        all_list = [" ".join(x) + "\n" for x in tmp_list]
        Cabinet.write_file(self.list_run_file, all_list)
Ejemplo n.º 2
0
 def write_potcar(self, path, fname='POTCAR'):
     """
     Make a combined single POTCAR file
     """
     fname = os.path.join(path, fname)
     out_lines = [x for y in self.potentials_lines for x in y]
     Cabinet.write_file(fname, out_lines)
Ejemplo n.º 3
0
 def __init__(self, poscar='POSCAR'):
     if type(poscar) is str:
         try:
             poscar_lines = Cabinet.read_file(poscar)
         except IOError:
             print("error: vaspy.Poscar could not "
                   "find '{0}' file !!!".format(poscar))
             exit()
     elif type(poscar) is list:
         poscar_lines = poscar
     elif poscar is None:
         print("POSCAR was not read !!! (Template POSCAR is loaded !!!)")
         poscar = os.path.join(MODULE_DIR,
                               '../sorce/originalsVASP', 'poscar')
         poscar_lines = Cabinet.read_file(poscar)
     self.poscar_title = poscar_lines[0]
     self.cell_scale = float(poscar_lines[1])
     self.cell_lattices = Cabinet.conv_lines2array(poscar_lines[2:5])
     # self.cell_latticesはarrayとして読み込む
     if poscar_lines[5].split()[0].isdigit():  # vasp4
         self.elements = None
         self.num_atoms = [int(x) for x in poscar_lines[5].split()]
         i = sum(self.num_atoms)
         sites = [[float(x) for x in y.split()[0:3]]
                  for y in poscar_lines[7:7+i]]
         self.cell_sites = np.array(sites)
         self.vasp_version = 4
     else:
         self.elements = poscar_lines[5].split()  # vasp5
         self.num_atoms = [int(x) for x in poscar_lines[6].split()]
         i = sum(self.num_atoms)
         sites = [[float(x) for x in y.split()[0:3]]
                  for y in poscar_lines[8:8+i]]
         self.cell_sites = np.array(sites)
         self.vasp_version = 5
Ejemplo n.º 4
0
 def write_poscar(self, poscar='POSCAR'):
     """
     write_poscar(path)
     Make a 'POSCAR' file at 'path'
     """
     Cabinet.reserve_file(poscar)
     Cabinet.write_file(poscar, str(self))
Ejemplo n.º 5
0
def make_list(keys, run_file='run.sh'):
    """
    current directory中のkeyで引っ掛かるpathを
    list_run.txtに書き出す
    """
    path_list = []
    for key in keys:
        path_list += glob.glob(key)
    path_list = sorted(set(path_list))
    Cabinet.make_list_run(path_list, run_file)
Ejemplo n.º 6
0
 def run_job_and_get_id(self, fname_exe='next_run.sh'):
     """
     jobを走らせる
     走らせるファイルはnext_run.sh
     """
     cmd = ['qsub', fname_exe]
     job_id = Popen(cmd, stdout=PIPE).communicate()[0]
     add_line = job_id.split('.')[0] + b'\n'
     self.running_jobs.append(add_line)
     Cabinet.write_file(self.running_jobs_file, self.running_jobs)
Ejemplo n.º 7
0
 def write_kpoints(self, fname='KPOINTS', mode='M'):
     """Write KPOINTS file using self.kpoints"""
     if mode == 'M':
         mline = "Monkhorst Pack"
     elif mode == 'G':
         mline = "Gamma"
     kp_lines = ("Automatic mesh\n0\n{0}\n"
                 "  {1[0]}  {1[1]}  {1[2]}\n  0.  0.  0.\n"
                 .format(mline, self.kpoints))
     Cabinet.write_file(fname, kp_lines)
Ejemplo n.º 8
0
 def make_list_run(self, run_file):
     """
     next.py用のlist_run.txtを作成
     """
     lines = ""
     for param in self.series:
         path = param['path']
         run_file = os.path.abspath(run_file)
         lines += "{0}    {1}\n".format(path, run_file)
     Cabinet.write_file('list_run', lines)
Ejemplo n.º 9
0
 def append_list_run(self, run_file):
     """
     next.py用のlist_run.txtを追加
     """
     lines = ""
     for param in self.series:
         path = os.path.abspath(param['path'])
         run_file = os.path.abspath(run_file)
         lines += "{0}    {1}\n".format(path, run_file)
     Cabinet.append_file('list_run', lines)
Ejemplo n.º 10
0
def std(src='POSCAR'):
    """
    conventional standard cell に変換
    """
    srcpos = Poscar.from_file(src)
    finder = SpacegroupAnalyzer(srcpos.structure)
    std_str = finder.get_conventional_standard_structure()
    dstpos = Poscar(std_str)
    dst = 'POSCAR_std'
    Cabinet.reserve_file(dst)
    dstpos.write_file(dst)
Ejemplo n.º 11
0
def prim(src):
    """
    primitive cell に変換
    """
    srcpos = Poscar.from_file(src)
    finder = SpacegroupAnalyzer(srcpos.structure)
    prim_str = finder.get_primitive_standard_structure()
    dstpos = Poscar(prim_str)
    dst = 'POSCAR_prim'
    Cabinet.reserve_file(dst)
    dstpos.write_file(dst)
Ejemplo n.º 12
0
def standard(src="POSCAR"):
    """
    standardに変換
    """
    srcpos = Poscar.from_file(src)
    finder = SpacegroupAnalyzer(srcpos.structure)
    std = finder.get_conventional_standard_structure()
    dstpos = Poscar(std)
    dst = "POSCAR_std"
    Cabinet.reserve_file(dst)
    dstpos.write_file(dst)
Ejemplo n.º 13
0
def refined(src="POSCAR"):
    """
    refined poscar を 作成する
    """
    srcpos = Poscar.from_file(src)
    finder = SpacegroupAnalyzer(srcpos.structure, symprec=5e-1, angle_tolerance=8)
    std = finder.get_refined_structure()
    dstpos = Poscar(std)
    dst = "POSCAR_refined"
    Cabinet.reserve_file(dst)
    dstpos.write_file(dst)
Ejemplo n.º 14
0
def primitive(src="POSCAR"):
    """
    primitiveに変換
    """
    srcpos = Poscar.from_file(src)
    finder = SpacegroupAnalyzer(srcpos.structure)
    prim = finder.get_primitive_standard_structure()
    dstpos = Poscar(prim)
    dst = "POSCAR_prim"
    Cabinet.reserve_file(dst)
    dstpos.write_file(dst)
Ejemplo n.º 15
0
def make_list(keys, is_file=False, run_file="run.sh"):
    """
    current directory中のkeyで引っ掛かるpathを
    list_run.txtに書き出す
    """
    path_list = []
    for key in keys:
        path_list += glob.glob(key)
    path_list = sorted(set(path_list))
    if is_file:
        path_list = [os.path.dirname(x) for x in path_list]
    Cabinet.make_list_run(path_list, run_file)
Ejemplo n.º 16
0
    def plt_double(self, combipara, in_dir1, in_dir2, out_dir):
        """2種の結果のlattice依存性をプロット"""
        combi = Combinatorial(*combipara)
        combi.set_formula(2, 1)
        for composition in combi.compositions:
            formula = composition['formula']
            formula = ''.join(formula.split('2'))
            total_elem = ['Fe'] + composition['elements']
            total_num_atoms = [1] + composition['num_atoms']
            print(formula)

            all_dir_list = glob.glob(os.path.join(in_dir1, formula, 'fixed_*'))
            regular = collect_vasp.Energy(all_dir_list, 'POSCAR', 'OSZICAR')
            regular['c/a'] /= 2 ** 0.5

            fixed_elem = [total_elem[1], total_elem[0], total_elem[2]]
            fixed_elem = np.array([fixed_elem] * len(regular['elements']))

            regular['elements'] = fixed_elem
            regular.set_enthalpy()
            regular.set_mae('OSZICAR_SOC001', 'OSZICAR_SOC100')

            all_dir_list = glob.glob(os.path.join(in_dir2, formula, 'fixed_*'))
            inverse = collect_vasp.Energy(all_dir_list, 'POSCAR', 'OSZICAR')
            inverse['c/a'] /= 2 ** 0.5
            inverse['elements'] = fixed_elem
            inverse.set_enthalpy()
            inverse.set_mae('OSZICAR_SOC001', 'OSZICAR_SOC100')

            rlines = [str(regular)]
            ilines = [str(inverse)]
            fname_reg = "Fe2{0[0]}{0[1]}_reg.txt".format(composition['elements'])
            fname_inv = "Fe2{0[0]}{0[1]}_inv.txt".format(composition['elements'])
            Cabinet.write_file(os.path.join(out_dir, 'text', fname_reg), rlines)
            Cabinet.write_file(os.path.join(out_dir, 'text', fname_inv), ilines)


            def plot():
                plt = grapy.Vertical(3)
                plt.set_title("Heusler Fe$_2${0[0]}{0[1]}"
                                .format(composition['elements']))
                plt.set_style('blue')
                plt.set123(regular, 'c/a', 'enthalpy', 'mag', 'mae')
                plt.set_style('magenta')
                plt.set123(inverse, 'c/a', 'enthalpy', 'mag', 'mae')

                plt.adjust_auto()
                plt.ax2.set_ylim(-0.5, 3)
                plt.plot('show')
                #fname = "Fe2{0[0]}{0[1]}.eps".format(composition['elements'])
                #plt.plot(os.path.join(out_dir, fname))
            plot()
Ejemplo n.º 17
0
def for_FeB_witoutB(): #pylint: disable=C0103
    """
    for_FeBのBのサイトを0にして計算
    """
    fname = os.path.join('.', 'extended_convex_hull_POSCARS')
    poscars = uspex.POSCARS(fname)

    poscars.restrict_fractions(0, 0.5)
    poscars.restrict_fractions(1, 0.0)
    poscars.remove_elements(1)
    poscars.expand_poscars(['Fe'])
    path_list = [x['ID'] for x in poscars.poscars]
    Cabinet.make_list_run(path_list, 'run.sh')
Ejemplo n.º 18
0
def for_FeB(): #pylint: disable=C0103
    """
    FeBのUSPEXの計算結果(POSCARS)を展開する
    Feが50-100percentの範囲
    """
    fname = os.path.join('.', 'extended_convex_hull_POSCARS')
    poscars = uspex.POSCARS(fname)

    poscars.restrict_fractions(0, 0.5)
    poscars.restrict_fractions(1, 0.0)
    poscars.expand_poscars(['Fe', 'B'])
    path_list = [x['ID'] for x in poscars.poscars]
    Cabinet.make_list_run(path_list, 'run.sh')
Ejemplo n.º 19
0
 def __fix_dict(incar_dict):
     """
     読み込んだincar_dictをintやfloat形式に修正
     """
     for key, value in incar_dict.items():
         if len(value) > 1:
             fixed_val = [Cabinet.conv_str(x) for x in value]
         else:
             fixed_val = Cabinet.conv_str(value[0])
         if fixed_val == '.TRUE.':
             fixed_val = True
         elif fixed_val == '.FALSE.':
             fixed_val = False
         incar_dict.update({key: fixed_val})
Ejemplo n.º 20
0
    def __init__(self, num_run=1, fname_run='list_run',
                 fname_running='running_jobs'):
        self.num_run = num_run
        self.list_run_file = fname_run
        self.running_jobs_file = fname_running

        lines = Cabinet.read_file(fname_run)
        self.finished_list = [x.split() for x in lines if x[0] == '#']
        self.run_list = [x.split() for x in lines if x[0] != '#']
        try:
            lines = Cabinet.read_file(fname_running)
            self.running_jobs = [x for x in lines if x != '\n']
        except IOError:
            self.running_jobs = []
Ejemplo n.º 21
0
 def get_enemag(oszicar='OSZICAR'):
     """
     Read energy and magnetic momentum from OSZICAR/OUTCAR.
     Judge file type from first line of the read file.
     """
     try:
         lines = Cabinet.read_file(oszicar)
     except IOError:
         lines = ['error']
     try:
         head = lines[0].split()[0]
     except IndexError:
         print(oszicar)
         exit()
     if head == 'N':  # OSZICAR
         output = vaspy.Oszicar(oszicar)
     elif head[0:4] == 'vasp':  # OUTCAR
         output = vaspy.Outcar(oszicar)
     else:
         print("I cannot read {0}".format(oszicar))
         return None, None, False
     if not output.results:
         print(oszicar)
         return None, None, False
     energy = output.results[-1]['energy']
     mag = output.results[-1]['mag']
     return energy, mag, True
Ejemplo n.º 22
0
    def get_results(cls, fname='OSZICAR'):
        """
        iterationの回数、nswの数、energy、magをdict形式でreturn
        緩和毎にlistに追加する
        """

        lines = Cabinet.read_file(fname)
        keywords = r"\s*([\d]+)\s+F=\s*([\d\-\.E\+]+)\s+E0=\s+.*\s+"
        meta = re.compile(keywords)
        keywords2 = r"\s*DAV:\s*([\d]+)\s+.*"
        meta2 = re.compile(keywords2)
        results = []
        for i in range(0, len(lines)):
            if meta.match(lines[i]):
                relax_num, energy, mag = cls.get_3values(lines[i])
                j = 1
                while not meta2.match(lines[i-j]):
                    j += 1
                iter_num = lines[i-j].split()[1]
                results.append({'iter_num': iter_num, 'nsw_num': relax_num,
                                'energy': energy, 'mag': mag})
        if not results:
            last_val = lines[-1].split()
            try:
                if math.fabs(float(last_val[3])) > 1e-5:
                    print("{0} is unfinished with error. ".format(fname))
                    return []
            except ValueError:
                    print("{0} is unfinished with error. ".format(fname))
                    return []
            print("{0} is unfinished but converged. "
                  "(val. of mag is false)".format(fname))
            results.append({'iter_num': int(last_val[1]), 'nsw_num': 1,
                            'energy': float(last_val[2]), 'mag': -100})
        return results
Ejemplo n.º 23
0
    def read_origin_file(fname):
        """
        self.individualsの作成に用いる
        (__init__()で実行)

        Originから読み取ったすべてのindividualの情報を
        dict形式でreturnする
        どの様に進化したか 'background'
        世代 'generation'
        親 'parents'
        子供 'children'(空)を要素に持つ
        またmake_family_tree()で使う'blood'(空)を定義
        """
        individuals = {}
        lines = Cabinet.read_file(fname)
        for line in lines:
            if line.split()[0] == '-' * 7:
                gene = int(line.split()[1].split('generation')[-1])
            else:
                line = line.split(None, 1)
                id_indiv = int(line[0])
                line = line[1].split(',')
                background = line[0].split('\n')[0]
                if background == 'random':
                    parents = None
                else:
                    line = line[1].split()
                    parents = [int(x) for x in line[2:]]
                individuals.update({id_indiv: {'background': background,
                                               'parents': parents,
                                               'generation': gene,
                                               'blood': None,
                                               'children': []}})
        return individuals
Ejemplo n.º 24
0
 def read_outcar(self, fname='OUTCAR_ibzkp'):
     """
     Read NGX, NGY, NGZ, NBANDS parameters from OUTCAR.
     """
     lines = Cabinet.read_file(fname)
     ngx_key = re.compile(r".*WARNING:.*NGX\s*to\s*(\d+)*")
     ngy_key = re.compile(r".*WARNING:.*NGY\s*to\s*(\d+)*")
     ngz_key = re.compile(r".*WARNING:.*NGZ\s*to\s*(\d+)*")
     nbands_key = re.compile(r".*NBANDS\s*=\s*(\d+)*")
     ngx_value = None
     ngy_value = None
     ngz_value = None
     for i in range(0, len(lines)):
         ngx_meta = ngx_key.match(lines[i])
         ngy_meta = ngy_key.match(lines[i])
         ngz_meta = ngz_key.match(lines[i])
         nbands_meta = nbands_key.match(lines[i])
         if ngx_meta:
             ngx_value = int(ngx_meta.group(1))
         elif ngy_meta:
             ngy_value = int(ngy_meta.group(1))
         elif ngz_meta:
             ngz_value = int(ngz_meta.group(1))
         elif nbands_meta:
             nbands_value = int(nbands_meta.group(1))
             nbands_value += nbands_value % 2  # alt to even
     return {'ngx': ngx_value, 'ngy': ngy_value, 'ngz': ngz_value,
             'nbands': nbands_value}
Ejemplo n.º 25
0
 def read_potcar(self):
     """
     Several POTCAR files lines are loaded based on self.psuedo_pot list.
     """
     path_list = [os.path.join(self.VASP_POT_DIR, x, 'POTCAR')
                  for x in self.psuedo_pot]
     potentials_lines = [Cabinet.read_file(x) for x in path_list]
     return potentials_lines
Ejemplo n.º 26
0
 def __init__(self, dos):
     DataBox.__init__(self, [])
     self.dos_lines = Cabinet.read_file(dos)
     self.num_atoms = self.get_num_atoms(self.dos_lines[0])
     (self.num_energy,
      self.fermi_energy) = self.get_parameters(self.dos_lines[5])
     print(self.get_parameters(self.dos_lines[5]))
     self.dos_data = self.__prep_dos_data(self.num_atoms,
                                          self.labels_orbital)
Ejemplo n.º 27
0
def change_conc():
    """
    concを変更する
    """
    list1 = [str(i*0.1) for i in range(0, 11)]
    list2 = ['001', '100']
    list3 = ['0.950', '1.000', '1.050', '1.100', '1.150',
             '1.200', '1.250', '1.300', '1.350', '1.400',
             '1.450', '1.500']
    combi = Combinatorial(list1, list2, list3)
#    print(combi.compositions)
    comp_list = [x['elements']
                 for x in combi.compositions]
    lines = ""
    for comp in comp_list:
        lines += "/".join(comp) + " run.sh\n"
    print(lines)
    Cabinet.write_file('list_run.txt', lines)
Ejemplo n.º 28
0
 def prep_one(cls, cif_file, dst_dir):
     """
     The dst_dir is current directory,
     this method search POSCAR and reserve it.
     If not, it will search whethre dst_dir already exist or not.
     If it already exist, this module will do nothing.
     If not, new directory make and prepare POSCAR file.
     """
     if dst_dir == '.':
         Cabinet.reserve_file('POSCAR')
     elif glob.glob(dst_dir):
         line = ("\'{0}\' directory is already exist.\n"
                 "Do Nothing...\n".format(dst_dir.split('/')[-1]))
         print(line)
         return
     else:
         Bash.mkdir(dst_dir)
     cls.conv2poscar(cif_file, dst_dir)
     shutil.copy(cif_file, dst_dir)
Ejemplo n.º 29
0
 def is_running(self):
     """
     jobが動作中かどうかcheckする
     終了していた場合、running_jobsから削除
     """
     cmd = ['qstat']
     jobs = Popen(cmd, stdout=PIPE).communicate()[0].split(b'\n')
     uname = getpass.getuser()
     still_run = []
     for job_id in self.running_jobs:
         key = r"{0}.*{1}.*".format(job_id[:-1], uname)
         meta = re.compile(key)
         judge = True
         for job in jobs:
             if meta.match(job):
                 judge = None
         if not judge:
             still_run.append(job_id)
     self.running_jobs = still_run
     Cabinet.write_file(self.running_jobs_file, self.running_jobs)
Ejemplo n.º 30
0
 def get_elements(path):
     """
     元素名を修得
     """
     lines = Cabinet.read_file(path)
     key = r"\s*There are 3 types of atoms in the system:\s+([\w\s]+)"
     meta = re.compile(key)
     for line in lines:
         if meta.match(line):
             elements = meta.match(line).group(1)
     return elements.split()