catkit.hub package

Subpackages

• catkit.hub.ase_tools package
  • Submodules
  • catkit.hub.ase_tools.gas_phase_references module
  • Module contents

Submodules

catkit.hub.ase_connect module

catkit.hub.ase_connect.main()

catkit.hub.cathubsqlite module

class catkit.hub.cathubsqlite.CathubSQLite(filename)

Class for managing SQLite3 database for reaction energies, publications and atomic structures. Builds on top of the ASE database for atomic strucutres https://wiki.fysik.dtu.dk/ase/ase/db/db.html with four additional tables:

publication: publication info

publication_system: one-to-many mapping between publication table and

systems table in ASE database

reaction: reaction energies for surfaces

reaction_system: mamy-to-many mapping between reaction table and

systems table in ASE database

Connect to a database object:

db = CathubSQLite(‘yourdbfile.db’)

Set up a connection for several manipulations:

with db as CathubSQLite(‘yourdbfile.db’):

Do your work…

Parameters:filename (str) – name of database file

check(chemical_composition, reaction_energy)

Check if entry with same surface and energy is allready written to database file :param chemcial_composition: :type chemcial_composition: str :param reaction_energy: :type reaction_energy: str :param Returns id or None:

check_publication(pub_id)

check_publication_structure(pub_id, ase_id)

check_reaction_on_surface(chemical_composition, reactants, products)

Check if entry with same surface and reaction is allready written to database file

Parameters:

• chemcial_composition (str) –
• reactants (dict) –
• products (dict) –
• id or None (Returns) –

get_last_id(cur, table='reaction')

Get the id of the last written row in table

Parameters:

• cur (database connection()cursor() object) –
• table (str) – ‘reaction’, ‘publication’, ‘publication_system’, ‘reaction_system’
• Returns (id) –

read(id, table='reaction')

Return an entire row of a table :param id: row integer :type id: int :param table: ‘reaction’, ‘publication’, ‘publication_system’, ‘reaction_system’ :type table: str

update(id, values, key_names='all')

Update reaction info for a selected row

Parameters:

• id (int) – row integer
• values (dict) – See write() method for details
• key_names (list or 'all') – list with name of columns to update. Should match the keys-value pairs in values. default is ‘all’

write(values, data=None)

Write reaction info to db file

Parameters:

• values (dict) –
• values dict can include (The) –
• {'chemical_composition' (str (chemical composition on empty slab) ,) –
• 'surface_composition' (str (reduced chemical composition or) – shortname),
• 'facet' (str) –
• 'sites' (dict) – adsorption sites of species. f.ex: {‘OH’: ‘ontop’, ‘O’: ‘hollow’}
• 'coverages' (dict) – coverage of adsorbates relative to the unit cell f.ex. {‘OH’: 0.25, ‘O’: 0.5})
• 'products' ('reactants'/) – keys with name of chemical species folloved by phase (gas, *) values are the prefactor in the reaction. For reaction H2Ogas -> 2Hstar + O star you would write: ‘reactants’: {OHstar: 1, Hstar: 2} ‘products’: {OHstar: 1, Hstar: 2}
• 'reaction_energy' (float) –
• 'activation_energy' (float) –
• 'dft_code' (str) –
• 'dft_functional' (str) –
• 'username' (str) –
• 'pub_id' (str) – Should match the pub_id of the corresponding publications
• } –

write_publication(values)

Write publication info to db

Parameters:values (dict with entries) – {‘pub_id’: str (short name for publication), ‘authors’: list of str () ‘journal’: str, ‘volume’: str, ‘number’: str, ‘pages’: ‘str’ ‘year’: int, ‘publisher’: str, ‘doi’: str, ‘tags’: list of str}

catkit.hub.cathubsqlite.check_ase_ids(values, ase_ids)

catkit.hub.cathubsqlite.get_key_value_list(key_list, values, table='reaction')

catkit.hub.cathubsqlite.get_key_value_str(values)

catkit.hub.cathubsqlite.get_value_strlist(value_list)

catkit.hub.cli module

catkit.hub.convert_traj module

catkit.hub.convert_traj.main(base)

catkit.hub.create_user module

catkit.hub.create_user.main(user)

catkit.hub.db2server module

catkit.hub.db2server.main(dbfile, start_id=1, write_reaction=True, write_ase=True, write_publication=True, write_reaction_system=True, block_size=1000, start_block=0, db_user='catroot', db_password=None)

catkit.hub.folder2db module

catkit.hub.folder2db.main(folder_name, debug=False, skip=[], goto_reaction=None, old=False)

catkit.hub.folder_check module

catkit.hub.folder_check.main(folder)

catkit.hub.folderreader module

class catkit.hub.folderreader.FolderReader(folder_name, debug=False, strict=True, verbose=False, update=True)

Class for reading data from organized folders and writing to local CathubSQLite database. Folders should be arranged with make_folders_template and are read in the order:

level:

0 folder_name 1 |– publication 2 |– dft_code 3 |– dft_functional 4 |– gas 4 |– metal1 5 |– facet 6 |– reaction

Parameters:

• foldername (str) –
• debug (bool) – default is False. Choose True if the folderreader should continue in spite of errors.
• update (bool) – Update data if allready present in database file. defalt is True

read(skip=[], goto_metal=None, goto_reaction=None)

Get reactions from folders.

Parameters:

• skip (list of str) – list of folders not to read
• goto_reaction (str) – Skip ahead to this metal
• goto_reaction – Skip ahead to this reacion

read_bulk(root, files)

read_energies(root, files)

read_gas(root)

read_pub(root)

read_reaction(root, files)

read_slab(root, files)

write(skip=[], goto_reaction=None)

write_publication(pub_data)

catkit.hub.folderreader.read_name_from_folder(root)

catkit.hub.maintain_server module

class catkit.hub.maintain_server.MaintainPostgres(user='catroot', password=None, stdin=<open file '<stdin>', mode 'r'>, stdout=<open file '<stdout>', mode 'w'>)

Bases: catkit.hub.postgresql.CathubPostgreSQL

delete_lost_systems()

fill_reaction_system()

catkit.hub.make_folders_template module

catkit.hub.organize module

catkit.hub.organize.collect_structures(foldername, options)

catkit.hub.organize.create_folders(options, structures, root='')

catkit.hub.organize.fuzzy_match(structures, options)

catkit.hub.organize.get_chemical_formula(atoms)

Compatibility function, return mode=metal, when available, mode=hill, when not (ASE <= 3.13)

catkit.hub.organize.main(options)

catkit.hub.organize.symbols(atoms)

catkit.hub.postgresql module

class catkit.hub.postgresql.CathubPostgreSQL(user='catroot', password=None, stdin=<open file '<stdin>', mode 'r'>, stdout=<open file '<stdout>', mode 'w'>)

Class for setting up the catalysis hub reaction energy database on postgreSQL server.

check(pub_id, chemical_composition, reactants, products, reaction_energy=None, strict=True)

create_user(user)

delete(authorlist, year, doi=None)

publication_status()

read(id, table='reaction')

remove_user(user)

status(table='reaction')

transfer(filename_sqlite, start_id=1, write_ase=True, write_publication=True, write_reaction=True, write_reaction_system=True, block_size=1000, start_block=0)

update(id, values, key_names='all')

update_publication(pub_dict)

write(values, table='reaction')

write_publication(pub_values)

catkit.hub.postgresql.get_key_value_str(values, table='reaction')

catkit.hub.psql_server_connect module

catkit.hub.psql_server_connect.main(user)

catkit.hub.query module

catkit.hub.query.convert(name)

catkit.hub.query.execute_graphQL(query_string)

catkit.hub.query.get_ase_db()

catkit.hub.query.get_atoms_by_id(unique_id)

catkit.hub.query.get_atomsrow_by_id(unique_id)

catkit.hub.query.get_publications(**kwargs)

catkit.hub.query.get_reactions(n_results=20, write_db=False, **kwargs)

Get reactions from server

Give key value strings as arguments

catkit.hub.query.graphql_query(table='reactions', subtables=[], columns=['chemicalComposition', 'reactants', 'products'], n_results=10, queries={})

catkit.hub.query.map_column_names(column)

catkit.hub.query.query(table='reactions', columns=['chemicalComposition', 'reactants', 'products'], subtables=[], n_results=10, queries={}, print_output=False)

catkit.hub.tools module

catkit.hub.tools.add_atoms(atoms_list)

catkit.hub.tools.check_reaction(reactants, products)

Check the stoichiometry and format of chemical reaction used for folder structure. list of reactants -> list of products

catkit.hub.tools.extract_atoms(molecule)

Return a string with all atoms in molecule

catkit.hub.tools.get_bases(folder_name)

catkit.hub.tools.get_catbase()

Module contents