def print_results(self, structure, file_name='convergence_results'): """ print a summary of the convergence results to file """ data = GWConvergenceData(spec=self, structure=structure) nodata = False if data.read_conv_res_from_file( os.path.join( s_name(structure) + '.res', s_name(structure) + '.conv_res')): s = '%s %s %s ' % (s_name(structure), str(data.conv_res['values']['ecuteps']), str(data.conv_res['values']['nscf_nbands'])) else: s = '%s 0.0 0.0 ' % s_name(structure) nodata = True con_dat = self.code_interface.read_convergence_data( s_name(structure) + '.res') if con_dat is not None: s += '%s ' % con_dat['gwgap'] else: s += '0.0 ' s += '\n' f = open(file_name, 'a') f.write(str(s)) f.close() if nodata: raise RuntimeError('no convergence data found')
def test_VaspSingle(self): spec = GWSpecs() spec.data['code'] = 'VASP' work = SingleVaspGWWork(structure=structure, spec=spec, job='prep') work.create_input() print(os.listdir('.')) for f in ['INCAR', 'POTCAR', 'POSCAR', 'KPOINTS', 'INCAR.DIAG']: self.assertIn(f, os.listdir(path=s_name(structure))) work.create_job_script(add_to_collection=False) self.assertIn('job', os.listdir(path=s_name(structure))) work.create_job_script(mode='slurm', add_to_collection=False) self.assertIn('job', os.listdir(path=s_name(structure)))
def set_status(self, structure): self._grid = 0 self._all_done = False self._workdir = None self._converged = is_converged(False, structure) try: self._grid = read_grid_from_file(s_name(structure) + ".full_res")['grid'] self._all_done = read_grid_from_file( s_name(structure) + ".full_res")['all_done'] self._workdir = os.path.join(s_name(structure), 'work_' + str(self.grid)) except (IOError, OSError): pass
def get_work_dir(self): name = s_name(self.structure) if not self.all_converged: return str(name) + '_' + str(self.option['test']) + '_' + str( self.option['value']) else: return str(name)
def __init__(self, structure, spec, option=None): self.structure = structure self.spec = spec if option is not None: option.pop('gap', None) option['nscf_nbands'] = option['nbands'] option.pop('nbands', None) self.option = option print('option:', option) self.bands_fac = 1 self.tests = self.__class__.get_defaults_tests() self.convs = self.__class__.get_defaults_convs() self.response_models = self.__class__.get_response_models() if self.option is None: self.all_converged = False elif len(self.option) == len(self.convs): self.all_converged = True else: self.all_converged = False path_add = '.conv' if self.all_converged else '' self.work_dir = s_name(self.structure) + path_add try: abi_pseudo = os.environ['ABINIT_PS_EXT'] abi_pseudo_dir = os.environ['ABINIT_PS'] except KeyError: abi_pseudo = None abi_pseudo_dir = None pseudos = [] for element in self.structure.composition.element_composition: pseudo = os.path.join(abi_pseudo_dir, str(element) + abi_pseudo) pseudos.append(pseudo) self.pseudo_table = PseudoTable(pseudos)
def __init__(self, structure, spec): self.structure = structure self.spec = spec self.data = {} self.code_interface = get_code_interface(spec['code']) self.conv_res = {'control': {}, 'values': {}, 'derivatives': {}} self.full_res = {'all_done': False, 'grid': 0} self.final_values = () if structure is not None: self.name = s_name(structure) else: self.name = 'notknown' self.type = { 'parm_scr': False, 'full': False, 'single': False, 'test': False }
def test_SiC_conv(self): """ Testing a full convergence calculation cycle on SiC using precomupted data. """ # the current version uses refence data from a run using the production version on zenobe # once all checks out the run should be done using the input generated using this version to replace the # reference wdir = tempfile.mkdtemp() os.chdir(wdir) temp_ABINIT_PS_EXT = os.environ.get('ABINIT_PS_EXT', None) temp_ABINIT_PS = os.environ.get('ABINIT_PS', None) os.environ['ABINIT_PS_EXT'] = '.psp8' os.environ['ABINIT_PS'] = wdir reference_dir = os.path.join(__reference_dir__, 'SiC_test_case') if not os.path.isdir(reference_dir): raise RuntimeError('py.test needs to be started in the HTGW root, ' '%s does not exist' % __reference_dir__) # copy input print(wdir) self.assertTrue(os.path.isdir(reference_dir)) src_files = os.listdir(reference_dir) for file_name in src_files: full_file_name = os.path.join(reference_dir, file_name) if os.path.isfile(full_file_name): shutil.copy(full_file_name, wdir) self.assertEqual(len(os.listdir(wdir)), 6) print(os.listdir(wdir)) structure = Structure.from_file('SiC.cif') structure.item = 'SiC.cif' print(' ==== generate flow === ') gwsetup(update=False) self.assertTrue(os.path.isdir(os.path.join(wdir, 'SiC_SiC.cif'))) print(os.listdir(os.path.join(wdir))) print(os.listdir(os.path.join(wdir, 'SiC_SiC.cif'))) self.assertTrue(os.path.isfile(os.path.join(wdir, 'SiC_SiC.cif', '__AbinitFlow__.pickle'))) self.assertEqual(len(os.listdir(os.path.join(wdir, 'SiC_SiC.cif', 'w0'))), 48) print(' ==== copy reference results from first calculation === ') shutil.rmtree(os.path.join(wdir, 'SiC_SiC.cif')) shutil.copytree(os.path.join(reference_dir, 'ref_res', 'SiC_SiC.cif'), os.path.join(wdir, 'SiC_SiC.cif')) self.assertTrue(os.path.isdir(os.path.join(wdir, 'SiC_SiC.cif'))) self.assertEqual(len(os.listdir(os.path.join(wdir, 'SiC_SiC.cif', 'w0'))), 68) print(' ==== process output === ') gwoutput() print(os.listdir('.')) self.assertTrue(os.path.isfile('plot-fits')) self.assertTrue(os.path.isfile('plots')) self.assertEqual(is_converged(hartree_parameters=True, structure=structure, return_values=True), {u'ecut': 44.0, u'ecuteps': 4.0, u'gap': 6.816130591466406, u'nbands': 60}) self.assertTrue(os.path.isfile('SiC_SiC.cif.full_res')) print(' ==== generate next flow === ') print(' version with bandstructure and dos ') gwsetup(update=False) self.assertTrue(os.path.isdir('SiC_SiC.cif.conv')) print(os.listdir(os.path.join(wdir, 'SiC_SiC.cif.conv', 'w0'))) self.assertEqual(len(os.listdir(os.path.join(wdir, 'SiC_SiC.cif.conv', 'w0'))), 15) print(' ==== copy reference from second flow === ') time.sleep(1) # the .conv directory should be older than the first one shutil.rmtree(os.path.join(wdir, 'SiC_SiC.cif.conv')) shutil.copytree(os.path.join(reference_dir, 'ref_res', 'SiC_SiC.cif.conv'), os.path.join(wdir, 'SiC_SiC.cif.conv')) self.assertTrue(os.path.isdir(os.path.join(wdir, 'SiC_SiC.cif.conv'))) self.assertEqual(len(os.listdir(os.path.join(wdir, 'SiC_SiC.cif.conv', 'w0'))), 13) print(' ==== process output === ') backup = sys.stdout sys.stdout = StringIO() # capture output gwoutput() out = sys.stdout.getvalue() # release output sys.stdout.close() # close the stream sys.stdout = backup # restore original stdout print('=== *** ====\n'+out+'=== *** ====\n') gap = 0 for l in out.split('\n'): if 'values' in l: gap = float(l.split(' ')[6]) self.assertEqual(gap, 7.114950664158926) print(os.listdir('.')) print('processed') self.assertTrue(os.path.isfile('SiC_SiC.cif.full_res')) full_res = read_grid_from_file(s_name(structure)+'.full_res') self.assertEqual(full_res, {u'all_done': True, u'grid': 0}) self.assertTrue(os.path.isdir(os.path.join(wdir, 'SiC_SiC.cif.res'))) self.assertEqual(len(os.listdir(os.path.join(wdir, 'SiC_SiC.cif.res'))), 5) print(os.listdir(os.path.join(wdir, 'SiC_SiC.cif.res'))) msrf = MySigResFile(os.path.join(wdir, 'SiC_SiC.cif.res', 'out_SIGRES.nc')) self.assertEqual(msrf.h**o, 6.6843830378711786) self.assertEqual(msrf.lumo, 8.0650328308487982) self.assertEqual(msrf.homo_gw, 6.2325949743130034) self.assertEqual(msrf.lumo_gw, 8.2504215095164763) self.assertEqual(msrf.fundamental_gap('ks'), msrf.lumo - msrf.h**o) self.assertEqual(msrf.fundamental_gap('gw'), msrf.lumo_gw - msrf.homo_gw) self.assertAlmostEqual(msrf.fundamental_gap('gamma'), gap, places=3) # since we now have a mysigresfile object we test the functionality msrf.get_scissor() # return self.qplist_spin[0].build_scissors(domains=[[-200, mid], [mid, 200]], k=1, plot=False) res = msrf.get_scissor_residues() self.assertEqual(res, [0.05322754684319431, 0.34320373172956475]) # return sc.residues #msrf.plot_scissor(title='') #msrf.plot_qpe(title='') # to be continued if temp_ABINIT_PS is not None: os.environ['ABINIT_PS_EXT'] = temp_ABINIT_PS_EXT os.environ['ABINIT_PS'] = temp_ABINIT_PS
def create(self): """ create single abinit G0W0 flow """ # manager = 'slurm' if 'ceci' in self.spec['mode'] else 'shell' # an AbiStructure object has an overwritten version of get_sorted_structure that sorts according to Z # this could also be pulled into the constructor of Abistructure # abi_structure = self.structure.get_sorted_structure() from abipy import abilab item = copy.copy(self.structure.item) self.structure.__class__ = abilab.Structure self.structure = self.structure.get_sorted_structure_z() self.structure.item = item abi_structure = self.structure manager = TaskManager.from_user_config() # Initialize the flow. flow = Flow(self.work_dir, manager, pickle_protocol=0) # kpoint grid defined over density 40 > ~ 3 3 3 if self.spec['converge'] and not self.all_converged: # (2x2x2) gamma centered mesh for the convergence test on nbands and ecuteps # if kp_in is present in the specs a kp_in X kp_in x kp_in mesh is used for the convergence study print('== here ===') print(self.spec.__class__) json.dumps(self.spec.data, indent=2) if 'kp_in' in self.spec.data.keys(): if self.spec['kp_in'] > 9: print( 'WARNING:\nkp_in should be < 13 to generate an n x n x n mesh\nfor larger values a grid with ' 'density kp_in will be generated') kppa = self.spec['kp_in'] else: kppa = 2 else: # use the specified density for the final calculation with the converged nbands and ecuteps of other # stand alone calculations kppa = self.spec['kp_grid_dens'] gamma = True # 'standard' parameters for stand alone calculation scf_nband = self.get_bands(self.structure) + 20 # additional bands to accommodate for nbdbuf and a bit extra nscf_nband = [10 * self.get_bands(self.structure)] nksmall = None ecuteps = [8] extra_abivars = dict() # read user defined extra abivars from file 'extra_abivars' should be dictionary extra_abivars.update(read_extra_abivars()) # self.bands_fac = 0.5 if 'gwcomp' in extra_abivars.keys() else 1 # self.convs['nscf_nbands']['test_range'] = # tuple([self.bands_fac*x for x in self.convs['nscf_nbands']['test_range']]) ecut = extra_abivars.pop('ecut', 44) ecutsigx = extra_abivars.pop('ecutsigx', 44) # if npfft is too large or if npfft changes between the nscf calcualtion and the screening / sigma calulations # strange things can happen if 'npfft' not in extra_abivars: extra_abivars['npfft'] = 3 if ecutsigx > ecut: raise RuntimeError('ecutsigx can not be larger than ecut') if ecutsigx < max(ecuteps): raise RuntimeError('ecutsigx < ecuteps this is not realistic') response_models = ['godby'] if 'ppmodel' in extra_abivars.keys(): response_models = [extra_abivars.pop('ppmodel')] if self.option is not None: for k in self.option.keys(): if k == 'ecut': ecut = self.option[k] if k in ['ecuteps', 'nscf_nbands']: pass else: extra_abivars.update({k: self.option[k]}) try: grid = read_grid_from_file(s_name(self.structure) + ".full_res")['grid'] all_done = read_grid_from_file( s_name(self.structure) + ".full_res")['all_done'] workdir = os.path.join(s_name(self.structure), 'w' + str(grid)) except (IOError, OSError): grid = 0 all_done = False workdir = None if not all_done: if (self.spec['test'] or self.spec['converge']) and not self.all_converged: if self.spec['test']: print('| setting test calculation') tests = SingleAbinitGWWork(self.structure, self.spec).tests response_models = [] else: if grid == 0: print('| setting convergence calculations for grid 0') # tests = SingleAbinitGWWorkFlow(self.structure, self.spec).convs tests = self.convs else: print('| extending grid') # tests = expand(SingleAbinitGWWorkFlow(self.structure, self.spec).convs, grid) tests = expand(self.convs, grid) ecuteps = [] nscf_nband = [] for test in tests: if tests[test]['level'] == 'scf': if self.option is None: extra_abivars.update( {test + '_s': tests[test]['test_range']}) elif test in self.option: extra_abivars.update({test: self.option[test]}) else: extra_abivars.update( {test + '_s': tests[test]['test_range']}) else: for value in tests[test]['test_range']: if test == 'nscf_nbands': nscf_nband.append( value * self.get_bands(self.structure)) # scr_nband takes nscf_nbands if not specified # sigma_nband takes scr_nbands if not specified if test == 'ecuteps': ecuteps.append(value) if test == 'response_model': response_models.append(value) elif self.all_converged: print( '| setting up for testing the converged values at the high kp grid ' ) # add a bandstructure and dos calculation if os.path.isfile('bands'): nksmall = -30 # negative value > only bandstructure else: nksmall = 30 # in this case a convergence study has already been performed. # The resulting parameters are passed as option ecuteps = [ self.option['ecuteps'], self.option['ecuteps'] + self.convs['ecuteps']['test_range'][1] - self.convs['ecuteps']['test_range'][0] ] nscf_nband = [ self.option['nscf_nbands'], self.option['nscf_nbands'] + self.convs['nscf_nbands']['test_range'][1] - self.convs['nscf_nbands']['test_range'][0] ] # for option in self.option: # if option not in ['ecuteps', 'nscf_nband']: # extra_abivars.update({option + '_s': self.option[option]}) else: print('| all is done for this material') return logger.info('ecuteps : %s ' % str(ecuteps)) logger.info('extra : %s ' % str(extra_abivars)) logger.info('nscf_nb : %s ' % str(nscf_nband)) inputs = g0w0_convergence_inputs(abi_structure, self.pseudo_table, kppa, nscf_nband, ecuteps, ecutsigx, scf_nband, ecut, accuracy="normal", spin_mode="unpolarized", smearing=None, response_models=response_models, charge=0.0, gw_qprange=2, gamma=gamma, nksmall=nksmall, extra_abivars=extra_abivars) work = G0W0Work(scf_inputs=inputs[0], nscf_inputs=inputs[1], scr_inputs=inputs[2], sigma_inputs=inputs[3]) # work = g0w0_extended_work(abi_structure, self.pseudo_table, kppa, nscf_nband, ecuteps, ecutsigx, scf_nband, # accuracy="normal", spin_mode="unpolarized", smearing=None, response_models=response_models, # charge=0.0, sigma_nband=None, scr_nband=None, gamma=gamma, nksmall=nksmall, **extra_abivars) print(workdir) flow.register_work(work, workdir=workdir) return flow.allocate()
def execute_flow(self, structure, spec_data): """ execute spec prepare input/jobfiles or submit to fw for a given structure for vasp the different jobs are created into a flow todo this should actually create and execute a VaspGWWorkFlow(GWWorkflow) """ # general part for the base class grid = 0 all_done = False converged = is_converged(False, structure) try: grid = read_grid_from_file(s_name(structure) + ".full_res")['grid'] all_done = read_grid_from_file(s_name(structure) + ".full_res")['all_done'] except (IOError, OSError): pass if all_done: print('| all is done for this material') return # specific part if spec_data['mode'] == 'fw': fw_work_flow = VaspGWFWWorkFlow() else: fw_work_flow = [] if spec_data['test'] or spec_data['converge']: if spec_data['test']: tests_prep = GWscDFTPrepVaspInputSet(structure, spec_data).tests tests_prep.update( GWDFTDiagVaspInputSet(structure, spec_data).tests) elif spec_data['converge'] and converged: tests_prep = self.get_conv_res_test(spec_data, structure)['tests_prep'] else: tests_prep = GWscDFTPrepVaspInputSet(structure, spec_data).convs tests_prep.update( GWDFTDiagVaspInputSet(structure, spec_data).convs) if grid > 0: tests_prep = expand(tests=tests_prep, level=grid) print(tests_prep) for test_prep in tests_prep: print('setting up test for: ' + test_prep) for value_prep in tests_prep[test_prep]['test_range']: print("**" + str(value_prep) + "**") option = {'test_prep': test_prep, 'value_prep': value_prep} self.create_job(spec_data, structure, 'prep', fw_work_flow, converged, option) for job in spec_data['jobs'][1:]: if job == 'G0W0': if spec_data['test']: tests = GWG0W0VaspInputSet( structure, spec_data).tests elif spec_data['converge'] and converged: tests = self.get_conv_res_test( spec_data, structure)['tests'] else: tests = GWG0W0VaspInputSet( structure, spec_data).convs if grid > 0: tests = expand(tests=tests, level=grid) print(tests) if job in ['GW0', 'scGW0']: input_set = GWG0W0VaspInputSet( structure, spec_data) input_set.gw0_on() if spec_data['test']: tests = input_set.tests else: tests = input_set.tests for test in tests: print(' setting up test for: ' + test) for value in tests[test]['test_range']: print(" **" + str(value) + "**") option.update({'test': test, 'value': value}) self.create_job(spec_data, structure, job, fw_work_flow, converged, option)
def insert_in_database(self, structure, clean_on_ok=False, db_name='GW_results', collection='general'): """ insert the convergence data and the 'sigres' in a database """ data = GWConvergenceData(spec=self, structure=structure) success = data.read_conv_res_from_file( os.path.join( s_name(structure) + '.res', s_name(structure) + '.conv_res')) con_dat = self.code_interface.read_convergence_data( s_name(structure) + '.res') try: with open('extra_abivars', mode='r') as f: extra = json.load(fp=f) except (OSError, IOError): extra = None ps = self.code_interface.read_ps_dir() results_file = os.path.join( s_name(structure) + '.res', self.code_interface.gw_data_file) ksbands_file = os.path.join( s_name(structure) + '.res', self.code_interface.ks_bands_file) data_file = os.path.join( s_name(structure) + '.res', s_name(structure) + '.data') if success and con_dat is not None: query = { 'system': s_name(structure), 'item': structure.item, 'spec_hash': hash(self), 'extra_vars_hash': hash(None) if extra is None else hash(frozenset(extra.items())), 'ps': ps } print('query:', query) entry = copy.deepcopy(query) entry.update({ 'conv_res': data.conv_res, 'spec': self.to_dict(), 'extra_vars': extra, 'structure': structure.as_dict(), 'gw_results': con_dat, 'results_file': results_file, 'ksbands_file': ksbands_file, 'data_file': data_file }) # generic section that should go into the base class like # insert_in_database(query, entry, db_name, collection, server="marilyn.pcpm.ucl.ac.be") local_serv = pymongo.Connection("marilyn.pcpm.ucl.ac.be") try: user = os.environ['MAR_USER'] except KeyError: user = input('DataBase user name: ') try: pwd = os.environ['MAR_PAS'] except KeyError: pwd = input('DataBase pwd: ') db = local_serv[db_name] db.authenticate(user, pwd) col = db[collection] print(col) gfs = gridfs.GridFS(db) count = col.find(query).count() if count == 0: try: with open(entry['results_file'], 'r') as f: entry['results_file'] = gfs.put(f.read()) except IOError: print(entry['results_file'], 'not found') try: with open(entry['ksbands_file'], 'r') as f: entry['ksbands_file'] = gfs.put(f.read()) except IOError: print(entry['ksbands_file'], 'not found') try: with open(entry['data_file'], 'r') as f: entry['data_file'] = gfs.put(f.read()) except IOError: print(entry['data_file'], 'not found') col.insert(entry) print('inserted', s_name(structure)) elif count == 1: new_entry = col.find_one(query) try: print('removing file ', new_entry['results_file'], 'from db') gfs.remove(new_entry['results_file']) except: print('remove failed') try: print('removing file ', new_entry['ksbands_file'], 'from db') gfs.remove(new_entry['ksbands_file']) except: print('remove failed') try: print('removing file ', new_entry['data_file'], 'from db') gfs.remove(new_entry['data_file']) except: print('remove failed') new_entry.update(entry) print('adding', new_entry['results_file'], new_entry['data_file']) try: with open(new_entry['results_file'], 'r') as f: new_entry['results_file'] = gfs.put(f) except IOError: print(new_entry['results_file'], 'not found') try: with open(new_entry['ksbands_file'], 'r') as f: new_entry['ksbands_file'] = gfs.put(f) except IOError: print(new_entry['ksbands_file'], 'not found') try: with open(new_entry['data_file'], 'r') as f: new_entry['data_file'] = gfs.put(f) except IOError: print(new_entry['data_file'], 'not found') print('as ', new_entry['results_file'], new_entry['data_file']) col.save(new_entry) print('updated', s_name(structure)) else: print('duplicate entry ... ') local_serv.disconnect() else: raise RuntimeError('no data found to insert in db')
def process_data(self, structure): """ Process the data of a set of GW calculations: for 'single' and 'test' calculations the data is read and outputted for the parameter scanning part of a convergence calculation the data is read and parameters that provide converged results are determined for the 'full' part of a convergence calculation the data is read and it is tested if the slopes are in agreement with the scanning part """ data = GWConvergenceData(spec=self, structure=structure) if self.data['converge']: done = False try: data.read_full_res_from_file() if data.full_res['all_done']: done = True print('| no action needed al is done already') except (IOError, OSError, SyntaxError): pass data.set_type() while not done: if data.type['parm_scr']: data.read() if len(data.data) == 0: print('| parm_scr type calculation but no data found.') break if len(data.data) < 9: # todo this should be calculated print( '| parm_scr type calculation but no complete data found,' ' check if all calculations are done.') break if data.find_conv_pars_scf('ecut', 'full_width', self['tol'])[0]: print( '| parm_scr type calculation, converged scf values found' ) print(data.conv_res) else: print( '| parm_scr type calculation, no converged scf values found' ) data.full_res.update({ 'remark': 'No converged SCf parameter found. Continue anyway.' }) data.conv_res['values'].update( {'ecut': 44 / eV_to_Ha}) # internally we work in eV data.conv_res['control'].update({'ecut': True}) # if ecut is provided in extra_abivars overwrite in any case .. this is done at input generation # if 'ecut' in read_extra_abivars().keys(): # data.conv_res['values'].update({'ecut': read_extra_abivars()['ecut']}) # should be in eV # if converged ok, if not increase the grid parameter of the next set of calculations extrapolated = data.find_conv_pars(self['tol']) if data.conv_res['control']['nbands']: print( '| parm_scr type calculation, converged values found, extrapolated value: %s' % extrapolated[4]) else: print( '| parm_scr type calculation, no converged values found, increasing grid' ) data.full_res['grid'] += 1 data.print_full_res() data.print_conv_res() # plot data: print_gnuplot_header('plots', s_name(structure) + ' tol = ' + str(self['tol']), filetype=None) data.print_gnuplot_line('plots') data.print_plot_data() done = True elif data.type['full']: if not data.read_conv_res_from_file( s_name(structure) + '.conv_res'): print( '| Full type calculation but the conv_res file is not available, trying to reconstruct' ) data.read() data.find_conv_pars(self['tol']) data.print_conv_res() data.read(subset='.conv') if len(data.data) == 0: print('| Full type calculation but no data found.') break if len(data.data) < 4: print( '| Full type calculation but no complete data found.' ) for item in data.data: print(item) break if data.test_full_kp_results(tol_rel=1, tol_abs=0.0015): print( '| Full type calculation and the full results agree with the parm_scr.' ' All_done for this compound.') data.full_res.update({'all_done': True}) data.print_full_res() done = True # data.print_plot_data() self.code_interface.store_results( name=s_name(structure)) else: print( '| Full type calculation but the full results do not agree with the parm_scr.' ) print( '| Increase the tol to find better converged parameters and test the full grid again.' ) print('| TODO') data.full_res.update({ 'remark': 'no agreement at high dens kp mesh,', 'all_done': True }) # read the system specific tol for System.conv_res # if it's not there create it from the global tol # reduce tol # set data.type to convergence # loop done = True else: done = True elif self.data['test']: data.read() data.set_type() data.print_plot_data() else: data.read() data.set_type() data.print_plot_data()
def loop_structures(self, mode='i'): """ reading the structures specified in spec, add special points, and excecute the specs mode: i: loop structures for input generation o: loop structures for output parsing w: print all results """ ok, not_ok = 0, 0 print('loop structures mode ', mode) try: mp_key = os.environ['MP_KEY'] except KeyError: mp_key = None mp_list_vasp = [ 'mp-149', 'mp-2534', 'mp-8062', 'mp-2469', 'mp-1550', 'mp-830', 'mp-1986', 'mp-10695', 'mp-66', 'mp-1639', 'mp-1265', 'mp-1138', 'mp-23155', 'mp-111' ] if self.data['source'] == 'mp-vasp': items_list = mp_list_vasp elif self.data['source'] in ['poscar', 'cif']: files = [ f for f in os.listdir('.') if os.path.isfile(os.path.join('.', f)) ] items_list = [f for f in files if f[-3:] == 'cif'] elif self.data['source'] == 'mar_exp': items_list = [] local_serv = pymongo.Connection("marilyn.pcpm.ucl.ac.be") local_db_gaps = local_serv.band_gaps pwd = os.environ['MAR_PAS'] local_db_gaps.authenticate("setten", pwd) for c in local_db_gaps.exp.find(): name = Structure.from_dict(c['icsd_data']['structure']).composition.reduced_formula, c['icsd_id'],\ c['MP_id'] print(name) # Structure.from_dict(c['icsd_data']['structure']).to(fmt='cif',filename=name) items_list.append({ 'name': 'mp-' + c['MP_id'], 'icsd': c['icsd_id'], 'mp': c['MP_id'] }) else: items_list = [line.strip() for line in open(self.data['source'])] for item in items_list: print('\n') # special case, this should be encaptulated if self.data['source'] == 'mar_exp': print('structure from marilyn', item['name'], item['icsd'], item['mp']) exp = local_db_gaps.exp.find({'MP_id': item['mp']})[0] structure = Structure.from_dict(exp['icsd_data']['structure']) structure = refine_structure(structure) structure.to(fmt='cif', filename=item['name']) try: kpts = local_db_gaps.GGA_BS.find({'transformations.history.0.id': item['icsd']})[0]\ ['calculations'][-1]['band_structure']['kpoints'] except (IndexError, KeyError): kpts = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] structure.kpts = kpts print('kpoints:', structure.kpts[0], structure.kpts[1]) structure.item = item['name'] else: if item.startswith('POSCAR_'): structure = structure.from_file(item) comment = Poscar.from_file(item).comment # print comment if comment.startswith("gap"): structure.vbm_l = comment.split(" ")[1] structure.vbm = (comment.split(" ")[2], comment.split(" ")[3], comment.split(" ")[4]) structure.cbm_l = comment.split(" ")[5] structure.cbm = (comment.split(" ")[6], comment.split(" ")[7], comment.split(" ")[8]) else: # print "no bandstructure information available, adding GG as 'gap'" structure = add_gg_gap(structure) elif 'cif' in item: structure = Structure.from_file(item) structure = add_gg_gap(structure) elif item.startswith('mp-'): with MPRester(mp_key) as mp_database: print('structure from mp database', item) structure = mp_database.get_structure_by_material_id( item, final=True) try: bandstructure = mp_database.get_bandstructure_by_material_id( item) structure.vbm_l = bandstructure.kpoints[ bandstructure.get_vbm()['kpoint_index'] [0]].label structure.cbm_l = bandstructure.kpoints[ bandstructure.get_cbm()['kpoint_index'] [0]].label structure.cbm = tuple( bandstructure.kpoints[bandstructure.get_cbm( )['kpoint_index'][0]].frac_coords) structure.vbm = tuple( bandstructure.kpoints[bandstructure.get_vbm( )['kpoint_index'][0]].frac_coords) except (MPRestError, IndexError, KeyError) as err: print(err.message) structure = add_gg_gap(structure) else: continue structure.kpts = [list(structure.cbm), list(structure.vbm)] structure.item = item print(item, s_name(structure)) modes = { 'i': { 'action': self.execute_flow, 'fail_msg': 'input generation failed' }, 'w': { 'action': self.print_results, 'fail_msg': 'writing output failed' }, 's': { 'action': self.insert_in_database, 'fail_msg': 'database insertion failed' }, 'o': { 'action': self.process_data, 'fail_msg': 'output parsing failed' } } errors = {} try: action = modes[mode]['action'] action(structure) ok += 1 except Exception as exc: print('%s\n exception: %s %s' % (modes[mode]['fail_msg'], exc.__class__, exc)) not_ok += 1 errors[s_name(structure)] = exc.args[0] """ if mode == 'i': try: self.execute_flow(structure) except Exception as exc: print('input generation failed') print(exc) elif mode == 'w': try: self.print_results(structure) except Exception as exc: print('writing output failed') print(exc) elif mode == 's': try: self.insert_in_database(structure) except Exception as exc: print('database insertion failed') print(exc) elif mode == 'o': try: self.process_data(structure) except Exception as exc: print('output parsing failed') print(exc) """ if 'ceci' in self.data['mode'] and mode == 'i': os.chmod("job_collection", stat.S_IRWXU) return ok, not_ok, errors
def create_job_script(self, add_to_collection=True, mode='pbspro'): if mode == 'slurm': """ Create job script for ceci. """ npar = GWscDFTPrepVaspInputSet( self.structure, self.spec, functional=self.spec['functional']).get_npar(self.structure) if self.option is not None: option_prep_name = str(self.option['test_prep']) + str( self.option['value_prep']) if 'test' in self.option.keys(): option_name = str('.') + str(self.option['test']) + str( self.option['value']) else: option_prep_name = option_name = '' # npar = int(os.environ['NPARGWCALC']) header = ("#!/bin/bash \n" "## standard header for Ceci clusters ## \n" "#SBATCH [email protected] \n" "#SBATCH --mail-type=ALL\n" "#SBATCH --time=2-24:0:0 \n" "#SBATCH --cpus-per-task=1 \n" "#SBATCH --mem-per-cpu=4000 \n") path_add = '' if self.spec['converge'] and self.converged: path_add = '.conv' if self.job == 'prep': path = os.path.join( s_name(self.structure) + path_add, option_prep_name) # create this job job_file = open(os.path.join(path, 'job'), mode='w') job_file.write(header) job_file.write('#SBATCH --job-name=' + s_name(self.structure) + self.job + '\n') job_file.write('#SBATCH --ntasks=' + str(npar) + '\n') job_file.write('module load vasp \n') job_file.write('mpirun vasp \n') job_file.write('cp OUTCAR OUTCAR.sc \n') job_file.write('cp INCAR.DIAG INCAR \n') job_file.write('mpirun vasp \n') job_file.write('cp OUTCAR OUTCAR.diag \n') job_file.close() os.chmod(os.path.join(path, 'job'), stat.S_IRWXU) if add_to_collection: job_file = open("job_collection", mode='a') job_file.write('cd ' + path + ' \n') job_file.write('sbatch job \n') job_file.write('cd .. \n') job_file.close() os.chmod("job_collection", stat.S_IRWXU) if self.job in ['G0W0', 'GW0', 'scGW0']: path = os.path.join( s_name(self.structure) + path_add, option_prep_name, self.job + option_name) # create this job job_file = open(os.path.join(path, 'job'), mode='w') job_file.write(header) job_file.write('#SBATCH --job-name=' + s_name(self.structure) + self.job + '\n') job_file.write('#SBATCH --ntasks=' + str(npar) + '\n') job_file.write('module load vasp/5.2_par_wannier90 \n') job_file.write('cp ../CHGCAR ../WAVECAR ../WAVEDER . \n') job_file.write('mpirun vasp \n') job_file.write('rm W* \n') #job_file.write('workon pymatgen-GW; get_gap > gap; deactivate') #job_file.write('echo '+path+'`get_gap` >> ../../gaps.dat') job_file.close() os.chmod(path + '/job', stat.S_IRWXU) path = os.path.join( s_name(self.structure) + path_add, option_prep_name) # 'append submission of this job script to that of prep for this structure' if add_to_collection: job_file = open(os.path.join(path, 'job'), mode='a') job_file.write('cd ' + self.job + option_name + ' \n') job_file.write('sbatch job \n') job_file.write('cd .. \n') job_file.close() elif mode == 'pbspro': """ Create job script for pbse pro Zenobe. """ npar = GWscDFTPrepVaspInputSet( self.structure, self.spec, functional=self.spec['functional']).get_npar(self.structure) #npar = 96 if self.option is not None: option_prep_name = str(self.option['test_prep']) + str( self.option['value_prep']) if 'test' in self.option.keys(): option_name = str('.') + str(self.option['test']) + str( self.option['value']) else: option_prep_name = option_name = '' # npar = int(os.environ['NPARGWCALC']) header = str("#!/bin/bash \n" + "## standard header for zenobe ## \n" + "#!/bin/bash \n" + "#PBS -q main\n" + "#PBS -l walltime=24:0:00\n" + "#PBS -r y \n" + "#PBS -m abe\n" + "#PBS -M [email protected]\n" + "#PBS -W group_list=naps\n" + "#PBS -l pvmem=1900mb\n") path_add = '' if self.spec['converge'] and self.converged: path_add = '.conv' if self.job == 'prep': path = os.path.join( s_name(self.structure) + path_add, option_prep_name) abs_path = os.path.abspath(path) # create this job print(os.path.join(path, 'job')) job_file = open(os.path.join(path, 'job'), mode='w') job_file.write(header) job_file.write( "#PBS -l select=%s:ncpus=1:vmem=1900mb:mpiprocs=1:ompthreads=1\n" % str(npar)) job_file.write( '#PBS -o %s/queue.qout\n#PBS -e %s/queue.qerr\ncd %s\n' % (abs_path, abs_path, abs_path)) job_file.write('mpirun -n %s vasp \n' % str(npar)) job_file.write('cp OUTCAR OUTCAR.sc \n') job_file.write('cp INCAR.DIAG INCAR \n') job_file.write('mpirun -n %s vasp \n' % str(npar)) job_file.write('cp OUTCAR OUTCAR.diag \n') job_file.close() os.chmod(os.path.join(path, 'job'), stat.S_IRWXU) if add_to_collection: job_file = open("job_collection", mode='a') job_file.write('cd ' + path + ' \n') job_file.write('qsub job \n') job_file.write('cd ../.. \n') job_file.close() os.chmod("job_collection", stat.S_IRWXU) if self.job in ['G0W0', 'GW0', 'scGW0']: path = os.path.join( s_name(self.structure) + path_add, option_prep_name, self.job + option_name) abs_path = os.path.abspath(path) # create this job job_file = open(os.path.join(path, 'job'), mode='w') job_file.write(header) job_file.write( "#PBS -l select=%s:ncpus=1:vmem=1000mb:mpiprocs=1:ompthreads=1\n" % str(npar)) job_file.write( '#PBS -o %s/queue.qout\n#PBS -e %s/queue.qerr\ncd %s\n' % (abs_path, abs_path, abs_path)) job_file.write('cp ../CHGCAR ../WAVECAR ../WAVEDER . \n') job_file.write('mpirun -n %s vasp \n' % str(npar)) job_file.write('rm W* \n') #job_file.write('workon pymatgen-GW; get_gap > gap; deactivate') #job_file.write('echo '+path+'`get_gap` >> ../../gaps.dat') job_file.close() os.chmod(os.path.join(path, 'job'), stat.S_IRWXU) path = os.path.join( s_name(self.structure) + path_add, option_prep_name) # 'append submission of this job script to that of prep for this structure' if add_to_collection: job_file = open(os.path.join(path, 'job'), mode='a') job_file.write('cd ' + self.job + option_name + ' \n') job_file.write('qsub job \n') job_file.write('cd .. \n') job_file.close()
def create_input(self): """ create vasp input """ option_name = '' path_add = '' if self.spec['converge'] and self.converged: path_add = '.conv' if self.option is None: path = s_name(self.structure) else: path = os.path.join( s_name(self.structure) + path_add, str(self.option['test_prep']) + str(self.option['value_prep'])) if 'test' in self.option.keys(): option_name = '.' + str(self.option['test']) + str( self.option['value']) if self.job == 'prep': inpset = GWscDFTPrepVaspInputSet( self.structure, self.spec, functional=self.spec['functional']) if self.spec['converge'] and not self.converged: spec_tmp = self.spec.copy() spec_tmp.update({'kp_grid_dens': 2}) inpset = GWscDFTPrepVaspInputSet( self.structure, spec_tmp, functional=self.spec['functional']) inpset.user_incar_settings.update({"ENCUT": 800}) if self.spec['test'] or self.spec['converge']: if self.option[ 'test_prep'] in GWscDFTPrepVaspInputSet.get_defaults_convs( ).keys() or self.option[ 'test_prep'] in GWscDFTPrepVaspInputSet.get_defaults_tests( ).keys(): inpset.set_test(self.option['test_prep'], self.option['value_prep']) if self.spec["prec"] == "h": inpset.set_prec_high() inpset.write_input(path) inpset = GWDFTDiagVaspInputSet(self.structure, self.spec, functional=self.spec['functional']) if self.spec["prec"] == "h": inpset.set_prec_high() if self.spec['converge'] and not self.converged: spec_tmp = self.spec.copy() spec_tmp.update({'kp_grid_dens': 2}) inpset = GWDFTDiagVaspInputSet( self.structure, spec_tmp, functional=self.spec['functional']) inpset.user_incar_settings.update({"ENCUT": 800}) if self.spec['test'] or self.spec['converge']: inpset.set_test(self.option['test_prep'], self.option['value_prep']) inpset.incar.write_file(os.path.join(path, 'INCAR.DIAG')) if self.job == 'G0W0': inpset = GWG0W0VaspInputSet(self.structure, self.spec, functional=self.spec['functional']) if self.spec['converge'] and not self.converged: spec_tmp = self.spec.copy() spec_tmp.update({'kp_grid_dens': 2}) inpset = GWG0W0VaspInputSet(self.structure, spec_tmp, functional=self.spec['functional']) inpset.user_incar_settings.update({"ENCUT": 800}) if self.spec['test'] or self.spec['converge']: inpset.set_test(self.option['test_prep'], self.option['value_prep']) inpset.set_test(self.option['test'], self.option['value']) if self.spec["prec"] == "h": inpset.set_prec_high() if self.spec['kp_grid_dens'] > 20: #inpset.wannier_on() inpset.write_input(self.structure, os.path.join(path, 'G0W0' + option_name)) #w_inpset = Wannier90InputSet(self.spec) #w_inpset.write_file(self.structure, os.path.join(path, 'G0W0'+option_name)) else: inpset.write_input(self.structure, os.path.join(path, 'G0W0' + option_name)) if self.job == 'GW0': inpset = GWG0W0VaspInputSet(self.structure, self.spec, functional=self.spec['functional']) if self.spec['converge'] and not self.converged: spec_tmp = self.spec.copy() spec_tmp.update({'kp_grid_dens': 2}) inpset = GWG0W0VaspInputSet(self.structure, spec_tmp, functional=self.spec['functional']) inpset.user_incar_settings.update({"ENCUT": 800}) if self.spec['test'] or self.spec['converge']: inpset.set_test(self.option['test_prep'], self.option['value_prep']) inpset.set_test(self.option['test'], self.option['value']) if self.spec["prec"] == "h": inpset.set_prec_high() inpset.gw0_on() if self.spec['kp_grid_dens'] > 20: #inpset.wannier_on() inpset.write_input(self.structure, os.path.join(path, 'GW0' + option_name)) #w_inpset = Wannier90InputSet(self.spec) #w_inpset.write_file(self.structure, os.path.join(path, 'GW0'+option_name)) else: inpset.write_input(self.structure, os.path.join(path, 'GW0' + option_name)) if self.job == 'scGW0': inpset = GWG0W0VaspInputSet(self.structure, self.spec, functional=self.spec['functional']) if self.spec['converge'] and not self.converged: spec_tmp = self.spec.copy() spec_tmp.update({'kp_grid_dens': 2}) inpset = GWG0W0VaspInputSet(self.structure, spec_tmp, functional=self.spec['functional']) inpset.user_incar_settings.update({"ENCUT": 800}) if self.spec['test'] or self.spec['converge']: inpset.set_test(self.option['test_prep'], self.option['value_prep']) inpset.set_test(self.option['test'], self.option['value']) if self.spec["prec"] == "h": inpset.set_prec_high() inpset.gw0_on(qpsc=True) if self.spec['kp_grid_dens'] > 20: inpset.wannier_on() inpset.write_input(self.structure, os.path.join(path, 'scGW0' + option_name)) w_inpset = Wannier90InputSet(self.spec) w_inpset.write_file(self.structure, os.path.join(path, 'scGW0' + option_name)) else: inpset.write_input(self.structure, os.path.join(path, 'scGW0' + option_name))