def psml_family(generate_psml_data): """Create a pseudopotential family with PsmlData potentials from scratch.""" from aiida import plugins PsmlData = plugins.DataFactory('pseudo.psml') # pylint: disable=invalid-name PseudoPotentialFamily = plugins.GroupFactory('pseudo.family') # pylint: disable=invalid-name label = 'nc-sr-04_pbe_standard_psml' try: family = PseudoPotentialFamily.objects.get(label=label) except exceptions.NotExistent: pass else: return family with tempfile.TemporaryDirectory() as dirpath: for values in elements.values(): element = values['symbol'] upf = generate_psml_data(element) filename = os.path.join(dirpath, f'{element}.psml') with open(filename, 'w+b') as handle: with upf.open(mode='rb') as source: handle.write(source.read()) handle.flush() family = PseudoPotentialFamily.create_from_folder(dirpath, label, pseudo_type=PsmlData) return family
def has_unknown_species(self): """ Returns whether the cif contains atomic species that are not recognized by AiiDA. The known species are taken from the elements dictionary in `aiida.common.constants`, with the exception of the "unknown" placeholder element with symbol 'X', as this could not be used to construct a real structure. If any of the formula of the cif data contain species that are not in that elements dictionary, the function will return True and False in all other cases. If there is no formulae to be found, it will return None :returns: True when there are unknown species in any of the formulae, False if not, None if no formula found """ from aiida.common.constants import elements # Get all the elements known by AiiDA, excluding the "unknown" element with symbol 'X' known_species = [element['symbol'] for element in elements.values() if element['symbol'] != 'X'] for formula in self.get_formulae(): if formula is None: return None species = parse_formula(formula).keys() if any([specie not in known_species for specie in species]): return True return False
def sssp(aiida_profile, generate_upf_data): """Create an SSSP pseudo potential family from scratch.""" from aiida.common.constants import elements from aiida.plugins import GroupFactory aiida_profile.reset_db() SsspFamily = GroupFactory('pseudo.family.sssp') cutoffs = {} stringency = 'standard' with tempfile.TemporaryDirectory() as dirpath: for values in elements.values(): element = values['symbol'] upf = generate_upf_data(element) filename = os.path.join(dirpath, f'{element}.upf') with open(filename, 'w+b') as handle: with upf.open(mode='rb') as source: handle.write(source.read()) handle.flush() cutoffs[element] = { 'cutoff_wfc': 30.0, 'cutoff_rho': 240.0, } label = 'SSSP/1.1/PBE/efficiency' family = SsspFamily.create_from_folder(dirpath, label) family.set_cutoffs(cutoffs, stringency, unit='Ry') return family
def validate_element(cls, element: str): """Validate the given element symbol. :param element: the symbol of the element following the IUPAC naming standard. :raises ValueError: if the element symbol is invalid. """ if element not in [values['symbol'] for values in elements.values()]: raise ValueError(f'`{element}` is not a valid element.')
def _generate_structure(symbols=None): from aiida.plugins import DataFactory structure = DataFactory('structure')() valid_symbols = [value['symbol'] for value in elements.values()] if symbols is not None: for index, symbol in enumerate(symbols): if symbol not in valid_symbols: raise ValueError(f'symbol `{symbol}` is not a valid element.') structure.append_atom(position=(0. + index * 1, 0. + index * 1, 0. + index * 1), symbols=[symbol]) return structure
def pseudo_dojo(generate_jthxml_data): """Create a PseudoDojo pseudo potential family from scratch.""" from aiida import plugins PseudoDojoFamily = plugins.GroupFactory('pseudo.family.pseudo_dojo') # pylint: disable=invalid-name label = 'PseudoDojo/1.0/PBE/SR/standard/jthxml' try: family = PseudoDojoFamily.objects.get(label=label) except exceptions.NotExistent: pass else: return family cutoffs_dict = {'normal': {}} with tempfile.TemporaryDirectory() as dirpath: for values in elements.values(): element = values['symbol'] upf = generate_jthxml_data(element) filename = os.path.join(dirpath, f'{element}.jthxml') with open(filename, 'w+b') as handle: with upf.open(mode='rb') as source: handle.write(source.read()) handle.flush() cutoffs_dict['normal'][element] = {'cutoff_wfc': 30., 'cutoff_rho': 240.} family = PseudoDojoFamily.create_from_folder(dirpath, label, pseudo_type=plugins.DataFactory('pseudo.jthxml')) for stringency, cutoffs in cutoffs_dict.items(): family.set_cutoffs(cutoffs, stringency, unit='Eh') return family
def sssp(generate_upf_data): """Create an SSSP pseudo potential family from scratch.""" from aiida.plugins import GroupFactory SsspFamily = GroupFactory('pseudo.family.sssp') # pylint: disable=invalid-name label = 'SSSP/1.1/PBE/efficiency' try: family = SsspFamily.objects.get(label=label) except exceptions.NotExistent: pass else: return family cutoffs_dict = {'normal': {}} with tempfile.TemporaryDirectory() as dirpath: for values in elements.values(): element = values['symbol'] upf = generate_upf_data(element) filename = os.path.join(dirpath, f'{element}.upf') with open(filename, 'w+b') as handle: with upf.open(mode='rb') as source: handle.write(source.read()) handle.flush() cutoffs_dict['normal'][element] = {'cutoff_wfc': 30., 'cutoff_rho': 240.} family = SsspFamily.create_from_folder(dirpath, label) for stringency, cutoffs in cutoffs_dict.items(): family.set_cutoffs(cutoffs, stringency, unit='Ry') return family
def pseudo_dojo(aiida_profile, generate_psp8_data): """Create an PseudoDojo pseudo potential family from scratch.""" from aiida.common.constants import elements from aiida.plugins import GroupFactory, DataFactory aiida_profile.reset_db() PseudoDojo = GroupFactory('pseudo.family.pseudo_dojo') # pylint: disable=invalid-name Psp8Data = DataFactory('pseudo.psp8') cutoffs = {} stringency = 'standard' with tempfile.TemporaryDirectory() as dirpath: for values in elements.values(): element = values['symbol'] psp8 = generate_psp8_data(element) filename = os.path.join(dirpath, f'{element}.psp8') with open(filename, 'w+b') as handle: with psp8.open(mode='rb') as source: handle.write(source.read()) handle.flush() cutoffs[element] = { 'cutoff_wfc': 36.0, 'cutoff_rho': 144.0, } label = 'PseudoDojo/0.4/PBE/SR/standard/psp8' family = PseudoDojo.create_from_folder(dirpath, label, pseudo_type=Psp8Data) family.set_cutoffs(cutoffs, stringency, unit='Ry') return family
def has_unknown_species(self): """ Returns whether the cif contains atomic species that are not recognized by AiiDA. The known species are taken from the elements dictionary in aiida.common.constants. If any of the formula of the cif data contain species that are not in that elements dictionary, the function will return True and False in all other cases. If there is no formulae to be found, it will return None :returns: True when there are unknown species in any of the formulae, False if not, None if no formula found """ from aiida.common.constants import elements known_species = [element['symbol'] for element in elements.values()] for formula in self.get_formulae(): if formula is None: return None species = parse_formula(formula).keys() if any([specie not in known_species for specie in species]): return True return False