ocelot.schema package

Submodules

ocelot.schema.configuration module

class ocelot.schema.configuration.Config(molconformers, unwrap_clean_pstructure: pymatgen.core.structure.Structure, occu=1.0)

Bases: object

__init__(molconformers, unwrap_clean_pstructure: pymatgen.core.structure.Structure, occu=1.0)

Parameters

unwrap_clean_pstructure – Structure without disorder

as_dict(dimermaxfold=2)

keys are

pymatgen_structure, mols, mcs, z, dimers_dict_array, occu

classmethod from_cifstring(string)

classmethod from_dict(d)

keys are

pymatgen_structure

classmethod from_file(filename, assign_siteids=True)

classmethod from_labeled_clean_pstructure(pstructure: pymatgen.core.structure.Structure, occu=1.0)

classmethod from_pstructure(pstructure: pymatgen.core.structure.Structure, occu=1.0, assign_siteids=False)

get_bone_config()

Returns

a configuration that has only terminated backbones a pmg structure that has only terminated backbones a list of pmg molecules

get_dimers_array(maxfold=2, fast=False, symm=False)

Parameters

• fast –

• symm –

• maxfold – translation vector in fc can be [h, h, h] where maxfold <= h <= maxfold

Returns

dimers_array, z x z x n array, dimers[i][j][k] is the dimer of omols[i], omols[j] with translation vector as transv_fcs[k] transv_fcs

hashconfig(hashmethod=<built-in function openssl_sha256>)

molconformers: [MolConformer] = None

molconformers_all_legit()

molgraph_set()

ocelot.schema.conformer module

class ocelot.schema.conformer.BasicConformer(sites, siteids=False)

Bases: ocelot.schema.conformer.SiteidOperation

__init__(sites, siteids=False)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

as_dict()

property atomic_numbers

List of atomic numbers.

property bondmat

property can_rdmol

property cart_coords

compare(other)

get similarity based on rmsd, return inf if two different molecules

property composition

property distmat

classmethod from_dict(d: dict)

classmethod from_file(filename)

classmethod from_pmgmol(m: pymatgen.core.structure.Molecule, siteids=False)

classmethod from_siteids(siteids, sites, copy=False)

build up a ring based on a list of siteid and a list of sites

the sites should have been assigned siteids

classmethod from_sites(sites, siteids=False)

we use this as the parent constructor

classmethod from_str(input_string, fmt)

property geoc

geometric center

Returns

3x1 np array

static get_bondmat(sites, distmat, co=1.3)

Bij = whether there is a bond between si and sj, i is NOT bonded with itself

if site is not a legit atom (e.g. bq in nics), it cannot have any bond

Parameters

• sites –

• distmat –

• co – coefficient for cutoff, default 1.3, based on covalent rad

Returns

bool matrix

get_bondmat_based_on_siteid(co=1.3)

get_closest_sites(other)

other_sites – self_border_site — distmin — other_border_site – other_sites

this can be used to see if a dimer is interesting or not

Parameters

other (AtomList) –

Returns

i, j, distmin

conformer[i] is self_border_site, conformer[j] is other_border_site,

static get_distmat(coordmat)

distanct matrix

Parameters

coordmat – coordinates matrix nx3

Returns

distmat[i][j] is the euclid distance between coordmat[i] and coordmat[j]

static get_nbrmap(bmat)

Parameters

bmat (np.ndarray) – bool bond matrix, i is not bonded to itself

Returns

nbmap[i] is the index list of i’s neighbors

get_nbrmap_based_on_siteid(co=1.3)

get_site_by_coords(coords, tol=1e-05)

will only return one site

Parameters

• coords –

• tol –

Returns

property index2siteid

intersection(other, copy=False)

Parameters

• other –

• copy (bool) – whether generate a list of deepcopied sites or not

Returns

a list of sites in conformer that belong to both

is_missing_hydrogen()

issubset(other)

Parameters

other –

Return type

bool

property nbrmap

orient(pqo, origin='geoc')

p, q, o are 3 orthonormal vectors in x, y, z basis

basis transformation from xyz to pqo, notice sites are deepcopied

Parameters

• pqo – 3x3 array

• origin – default geoc, otherwise a 3d coord

property pmgmol

rotate_along(theta, end1, end2, unit='degree')

for each site, rotate the vector defined by (site.coords - end1) along (end2 - end1) and add this vector to site.coords

end1 - end2 | site

notice the coords are changed in-place

Parameters

• theta – angle of rotation

• end1 – 3x1 float list/array

• end2 – 3x1 float list/array

• unit (str) – degree/radian

static rotate_along_de_matrix(theta, end1, end2, unit='degree')

rotation matrix rotate_along()

rotate_along_with_matrix(matrix, end1)

a quicker version rotate_along if we konw the rotation matrix, end2 is included in the matrix

property siteid2index

sort_by_siteid()

property symbols

to(fmt, filename)

to_graph(nodename='siteid', graphtype='MolGraph', partition_scheme=None, joints: dict = None)

get a Graph, default siteid –> nodename

otherwise nodename is assigned based on the order in self.sites

to_rdmol(charge=0, sani=True, charged_fragments=None, force_single=False, expliciths=True)

generate a rdmol obj with current conformer

siteid –dict–> atomidx in rdmol == index in conformer

Parameters

• charge –

• sani –

• charged_fragments –

• force_single –

• expliciths –

Returns

property volume_slow

http://wiki.bkslab.org/index.php/Calculate_volume_of_the_binding_site_and_molecules

First, Lay a grid over the spheres.

Count the number or points contained in the spheres (Ns).

Count the number of points in the grid box (Ng).

Calculate the volume of the grid box (Vb).

don’t use this as it’s slow…

Returns

volume in A^3

class ocelot.schema.conformer.BondConformer(sites, siteids=False)

Bases: ocelot.schema.conformer.BasicConformer

__init__(sites, siteids=False)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

property length

class ocelot.schema.conformer.BoneConformer(sites, siteids=False, conformer_properties=None, graph: ocelot.schema.graph.BackboneGraph = None)

Bases: ocelot.schema.conformer.FragConformer

__init__(sites, siteids=False, conformer_properties=None, graph: ocelot.schema.graph.BackboneGraph = None)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

calculate_conformer_properties()

classmethod from_dict(d: dict)

classmethod from_sites(sites, graph=None, siteids=False, conformer_properties=None)

we use this as the parent constructor

property lp

maxdiff( (s.coord - ref) proj at vp )

Returns

short axis length

property lq

maxdiff( (s.coord - ref) proj at vq )

Returns

long axis length

class ocelot.schema.conformer.ConformerDimer(conformer_ref: ocelot.schema.conformer.MolConformer, conformer_var: ocelot.schema.conformer.MolConformer, label='')

Bases: object

__init__(conformer_ref: ocelot.schema.conformer.MolConformer, conformer_var: ocelot.schema.conformer.MolConformer, label='')

basically 2 conformers

Parameters

• conformer_ref –

• conformer_var –

• label (str) – mainly used to distinguish

Attributes:

vslip: slip vector in cart vslipnorm: normalized vslip pslip: projection of vslip along vp qslip: projection of vslip along vq oslip: projection of vslip along vo pangle: angle btw vps qangle: angle btw vps oangle: angle btw vps, always acute jmol: jmol draw arrow string in console

as_dict()

keys are

vslipnorm, pslip, qslip, oslip, pangle, qangle, oangle, jmol, label, omol_ref, omol_var

bone_overlap(algo='concave')

project var backbone onto the plane of ref backbone as there’s the problem of alpha value in concave hull generation, maybe I should set default to convex, see hull_test

Parameters

algo – concave/convex

Returns

area of the overlap, ref omol area, var omol area

classmethod from_dict(d)

keys are

omol_ref, omol_var, label

property is_bone_close

use to identify whether this dimer can have minimum wf overlap, ONLY consider bone distance

this should be called is_not_faraway…

Parameters

cutoff – minbonedist less than which will be considered close

Returns

bool

property is_close

use to identify whether this dimer can have minimum wf overlap

this should be called is_not_faraway…

Parameters

cutoff –

Returns

bool

property is_identical

whether two omols are identical, based on norm(vslip) < 1e-5

property is_not_identical

property minbonedist

Returns

minimum dist between sites on different bones

property mindist

Returns

minimum dist between sites on different bones

mol_overlap(algo='concave')

project var mol onto the plane of ref mol

Parameters

algo – concave/convex

Returns

area of the overlap, ref omol area, var omol area

plt_bone_overlap(algo='convex', output='bone_overlap.eps')

plot a 2d graph of how backbones overlap

using concave or convex hull

Parameters

• algo – concave/convex

• output – output filename

property sites

to_xyz(fn, center_label=False)

to_xyzstring(center_label=False)

exception ocelot.schema.conformer.ConformerError

Bases: Exception

class ocelot.schema.conformer.DimerCollection(dimers: [<class 'ocelot.schema.conformer.ConformerDimer'>])

Bases: object

__init__(dimers: [<class 'ocelot.schema.conformer.ConformerDimer'>])

just a list of dimers, they should share the same ref_mol

get_xyz_string(lalabel=False)

Returns

xyz string to be written

to_xyz(fn, lalabel=False)

Parameters

• lalabel –

• fn – xyz file name, with extension

class ocelot.schema.conformer.FragConformer(sites, siteids=False, conformer_properties=None, graph: Union[ocelot.schema.graph.FragmentGraph, ocelot.schema.graph.BackboneGraph, ocelot.schema.graph.SidechainGraph] = None)

Bases: ocelot.schema.conformer.BasicConformer

__init__(sites, siteids=False, conformer_properties=None, graph: Union[ocelot.schema.graph.FragmentGraph, ocelot.schema.graph.BackboneGraph, ocelot.schema.graph.SidechainGraph] = None)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

as_dict()

calculate_conformer_properties()

classmethod from_dict(d: dict)

classmethod from_pmgmol(m: pymatgen.core.structure.Molecule, siteids=False, conformer_properties=None, graph=None)

classmethod from_siteids(siteids, sites, graph=None, copy=False, conformer_properties=None)

build up a ring based on a list of siteid and a list of sites

the sites should have been assigned siteids

classmethod from_sites(sites, graph=None, siteids=False, conformer_properties=None)

we use this as the parent constructor

get_rings()

class ocelot.schema.conformer.MolConformer(sites, siteids=False, prop=None, graph: ocelot.schema.graph.MolGraph = None, rdmol: rdkit.Chem.rdchem.Mol = None, smiles: str = None, siteid2atomidx: dict = None, atomidx2siteid: dict = None, backbone: ocelot.schema.conformer.BoneConformer = None, sccs: [<class 'ocelot.schema.conformer.SidechainConformer'>] = None, backbone_graph: ocelot.schema.graph.BackboneGraph = None, scgs: [<class 'ocelot.schema.graph.SidechainGraph'>] = None, coplane_cutoff=30.0, chrombone: ocelot.schema.conformer.FragConformer = None, chromsccs: [<class 'ocelot.schema.conformer.FragConformer'>] = None, chrombone_graph: ocelot.schema.graph.FragmentGraph = None, chromscgs: [<class 'ocelot.schema.graph.FragmentGraph'>] = None)

Bases: ocelot.schema.conformer.BasicConformer

__init__(sites, siteids=False, prop=None, graph: ocelot.schema.graph.MolGraph = None, rdmol: rdkit.Chem.rdchem.Mol = None, smiles: str = None, siteid2atomidx: dict = None, atomidx2siteid: dict = None, backbone: ocelot.schema.conformer.BoneConformer = None, sccs: [<class 'ocelot.schema.conformer.SidechainConformer'>] = None, backbone_graph: ocelot.schema.graph.BackboneGraph = None, scgs: [<class 'ocelot.schema.graph.SidechainGraph'>] = None, coplane_cutoff=30.0, chrombone: ocelot.schema.conformer.FragConformer = None, chromsccs: [<class 'ocelot.schema.conformer.FragConformer'>] = None, chrombone_graph: ocelot.schema.graph.FragmentGraph = None, chromscgs: [<class 'ocelot.schema.graph.FragmentGraph'>] = None)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

as_dict()

calculate_conformer_properties()

static chrom_partition(mc: ocelot.schema.conformer.BasicConformer, rdmol, atomidx2siteid, molgraph: ocelot.schema.graph.MolGraph, withhalogen=True)

classmethod from_dict(d: dict)

classmethod from_sites(sites, siteids=False, prop=None, coplane_cutoff=30.0, withhalogen=True)

we use this as the parent constructor

static geo_partition(bc: ocelot.schema.conformer.BasicConformer, molgraph: ocelot.schema.graph.MolGraph, coplane_cutoff=30.0)

rings: List[RingConformer] = None

to_addhmol(bonescheme='geo')

add h and return pmg mol

Returns

class ocelot.schema.conformer.RingConformer(sites, siteids=False)

Bases: ocelot.schema.conformer.BasicConformer

__init__(sites, siteids=False)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

as_dict()

property bonds_in_ring

bond objects can be extracted from this ring e.g. for benzene the C-H bonds are NOT here

Returns

a list of bonds

static get_avg_norms(rings)

iscoplane_with(other, tol=20.0, tolunit='degree')

whether two rings are on the same plane with tol

Parameters

• other (Ring) –

• tol – degree default 20

• tolunit – degree/radian

Returns

bool

iscoplane_with_norm(v2, tol=20.0, tolunit='degree')

whether two rings are on the same plane with tol

Parameters

• v2 –

• tol – degree default 20

• tolunit – degree/radian

Returns

bool

normal_along(refnormal, tol=45.0)

get the n1 or n2 that is along the direction of refnormal within a certain tol this is useful to identify 2 plane normals for a partially-bent structure

Parameters

• refnormal – 3x1 array

• tol (float) – default 45 in degree

Returns

None if no normal along refnormal found

class ocelot.schema.conformer.SidechainConformer(sites, siteids=False, conformer_properties=None, graph: ocelot.schema.graph.SidechainGraph = None)

Bases: ocelot.schema.conformer.FragConformer

this can be considered as a special backbone with just one joint

__init__(sites, siteids=False, conformer_properties=None, graph: ocelot.schema.graph.SidechainGraph = None)

Parameters

• sites –

• siteids – a list of siteids, siteids[index]=siteid of self[index]

classmethod from_dict(d: dict)

classmethod from_sites(sites, graph=None, siteids=False, conformer_properties=None)

we use this as the parent constructor

exception ocelot.schema.conformer.SiteidError

Bases: Exception

class ocelot.schema.conformer.SiteidOperation(sites: [<class 'pymatgen.core.sites.Site'>])

Bases: object

__init__(sites: [<class 'pymatgen.core.sites.Site'>])

Initialize self. See help(type(self)) for accurate signature.

assign_siteid(siteids)

Parameters

siteids – default None means siteid = index, otherwise siteid = siteids[i]

Returns

checkstatus(*args)

get_site_byid(siteid)

Parameters

siteid (int) –

Returns

(a list of) msite obj

get_sites_byids(siteids, copy=False)

property sdict

property siteids

property status

check status based on conformer.siteids

Returns

ocelot.schema.conformer.conformer_addh(c: ocelot.schema.conformer.BasicConformer, joints=None, original: ocelot.schema.conformer.BasicConformer = None)

all sites will be deep copied

if we know nothing about the joints, we have to find the under-coordinated sites, then terminate them based on # of valence electrons

if we know the joints as a list or set of siteids but not the original conformer, we just terminate them based on # of valence electrons

if we know the joints as a dict but not the original conformer, we terminate them based on len(joints[siteid])

if we know the joints and the orginal conformer, we can terminate them based on # of bonds broken during fragmenting, in this case joints is a dict

Parameters

• c –

• joints –

• original –

Returns

d[siteid_of_the_joint] = a list of hydrogen sites

ocelot.schema.conformer.conformer_addhmol(c: ocelot.schema.conformer.BasicConformer, joints=None, original: ocelot.schema.conformer.BasicConformer = None)

ocelot.schema.graph module

class ocelot.schema.graph.BackboneGraph(graph, joints, partition_scheme='lgcr')

Bases: ocelot.schema.graph.FragmentGraph

__init__(graph, joints, partition_scheme='lgcr')

fragment is a BasicGraph with joints

I feel it’s not necessary to add parent BasicGraph as an attribute, but I maybe wrong

Parameters

• graph –

• joints – a dict, keys are nodes in the subgraph that have parent graph edges not in this subgraph

class ocelot.schema.graph.BasicGraph(graph: networkx.classes.graph.Graph)

Bases: object

__init__(graph: networkx.classes.graph.Graph)

Initialize self. See help(type(self)) for accurate signature.

as_dict()

draw(output: str, dpi=600)

draw graph, using jmol color scheme for elements

Parameters

• output –

• dpi –

Returns

classmethod from_dict(d: dict)

classmethod from_rdmol(rdmol: rdkit.Chem.rdchem.Mol, atomidx2nodename=None)

Parameters

• rdmol –

• atomidx2nodename – the dict to convert atomidx in rdmol to graph node, atomidx2nodename[rdmolid] == nodename

if not None then nodename will be set just based on atomidx :return:

classmethod from_smiles(smiles: str)

graph_similarity(other)

calculate graph similarity (GED) between two MolGraphs

Parameters

other –

Returns

static hash_nxgraph(g: networkx.classes.graph.Graph)

static hash_via_smiles(mg)

is_subgraph(other)

True if other has a node-induced subgraph is isomorphic to self

property props_for_hash

see https://stackoverflow.com/questions/46999771/ use with caution…

property symbols

a dict s.t. symbols[node] gives symbol

to_rdmol(sani=True, charge=0, charged_fragments=None, force_single=False, expliciths=True)

convert to rdmol, it will first try to convert to a radical, if failed b/c of rdkit valence rules, it will try to convert to charged fragment

Parameters

• sani – switch to call default sanitizer of rdkit

• charge (int) – molecule charge

• charged_fragments (bool) – switch to assign atomic charge

• force_single (bool) – switch to force all single bonds in the resulting molecule

• expliciths (bool) – add hydrogen explicitly

Returns

a rdmol object, canonical smiles, atomidx2nodename, nodename2atomidx

class ocelot.schema.graph.FragmentGraph(graph: networkx.classes.graph.Graph, joints: dict, partition_scheme: str)

Bases: ocelot.schema.graph.BasicGraph

__init__(graph: networkx.classes.graph.Graph, joints: dict, partition_scheme: str)

fragment is a BasicGraph with joints

I feel it’s not necessary to add parent BasicGraph as an attribute, but I maybe wrong

Parameters

• graph –

• joints – a dict, keys are nodes in the subgraph that have parent graph edges not in this subgraph

as_dict()

classmethod from_dict(d: dict)

exception ocelot.schema.graph.GraphError

Bases: Exception

class ocelot.schema.graph.MolGraph(graph)

Bases: ocelot.schema.graph.BasicGraph

__init__(graph)

this is the schema for molecule with fused rings

Parameters

graph –

classmethod from_basicgraph(basicgraph: ocelot.schema.graph.BasicGraph)

static get_bone_and_frags_from_nxgraph(bone_graph: networkx.classes.graph.Graph, fragments: [<class 'networkx.classes.graph.Graph'>], scheme)

static get_chrom_and_frags_from_nxgraph(chrom_graph, fragments)

static get_joints_and_subgraph(subg1_nodes: [<class 'int'>], g: networkx.classes.graph.Graph)

we assume subg1 cap subg2 == empty and subg1 + subg2 == g

get_rings(k='nconnect', threshold=1)

get connected rings between which # of edges is larger than a threshold

Parameters

• k –

• threshold –

Returns

partition(bone_selection='lgfr', additional_ring_criteria=None, with_halogen=True)

parition the molecule into a backbone graph and a list of fragments (graphs)

Parameters

• with_halogen –

• bone_selection –

• additional_ring_criteria – this should be a function to check whether a ring (a set of siteids) meets additional conditions # this does nothing for chrom scheme

Returns

partition_to_bone_frags(bone_selection='lgfr', additional_criteria=None)

partition the molecule into backbone and a list of frags

the list of frags is reversely sorted by graph size

Parameters

• additional_criteria –

• bone_selection –

Returns

class ocelot.schema.graph.SidechainGraph(graph, joints, partition_scheme)

Bases: ocelot.schema.graph.FragmentGraph

__init__(graph, joints, partition_scheme)

it is not possible for a side chain to have two frag-joints connected to one bone-joint, as this should be already in backbone

side chain (frags) cannot have 2 side joints, each connected to one bone-joint as this would be a ring fused

to backbone (side chain is a connected component)

Variables

self.rankmap – this gives the rank for each node, rank is the shortest path length from the node to sc_joint

as_dict()

ocelot.schema.graph.draw_chemgraph(graph: networkx.classes.graph.Graph, output: str, dpi=600)

ocelot.schema.graph.hashstr2int(s, hashmethod=<built-in function openssl_sha256>)

ocelot.schema.graph.to_fracrgb(t)

ocelot.schema.rdfunc module

class ocelot.schema.rdfunc.RdFunc

Bases: object

static conf2xyz(conf: rdkit.Chem.rdchem.Conformer, outputname, atom_list: list, comment_line='')

static draw_mol(rdmol, fn='m.ps')

static draw_smiles(smiles, fn='m.ps')

static fingerprint(mol)

static fp_similarity(m1, m2, metric='Tanimoto')

use RDK fingerprint similarity based on different metrics

TODO add args to customize RDKfp, see https://www.rdkit.org/docs/source/rdkit.Chem.rdmolops.html#rdkit.Chem.rdmolops.RDKFingerprint

see Landrum2012 for more details

Parameters

• m1 –

• m2 –

• metric (str) – “Tanimoto”, “Dice”, “Cosine”, “Sokal”, “Russel”, “RogotGoldberg”, “AllBit”, “Kulczynski”, “McConnaughey”, “Asymmetric”, “BraunBlanquet”,

Returns

static from_string(fmt, string)

construct a rdmol

Parameters

• fmt – ‘smiles’, ‘hsmiles’, ‘smarts’, ‘inchi’

• string –

Returns

static get_3ddescriptors(mol)

using methods from rdkit

https://www.rdkit.org/docs/source/rdkit.Chem.Descriptors3D.html

Asphericity: 0 corresponds to spherical top molecules and 1 to linear molecules, For prolate (cigar-sh aped) molecules, ~ 0.25, whereas for oblate (disk-shaped) molecules, ~ 1.

Eccentricity: 0 corresponds to spherical top molecules and 1 to linear molecules.

RadiusOfGyration: a size descriptor based on the distribution of atomic masses in a molecule, a measure of molecular compactness for long-chain molecules and, specifically, small values are obtained when most o f the atoms are close to the center of mass

SpherocityIndex: spherosity index varies from zero for flat molecules, such as benzene, to unity for totally spherical molecules

Key

Asphericity, Eccentricity, InertialShapeFactor, NPR1, NPR2, PMI1, PMI2, PMI3, RadiusOfGyration, SpherocityIndex

Returns

dict

static get_aids(m: rdkit.Chem.rdchem.Mol)

static get_bond_order(m, atomidx1, atomidx2)

static get_conjugate_group(m: rdkit.Chem.rdchem.Mol)

static get_conjugate_group_with_halogen(m: rdkit.Chem.rdchem.Mol)

static get_sub_rdmol(m: rdkit.Chem.rdchem.Mol, atomids: [<class 'int'>])

static get_volume(m)

AllChem.ComputeMolVolume in rdkit

Returns

volume in A^3

static getmolweight(mol)

static mol2xyz_by_confid(molecule: rdkit.Chem.rdchem.Mol, prefix='rdmol', confid=0, comment_line='')

static mol_as_json(rdmol: rdkit.Chem.rdchem.Mol)

static mol_from_json(s: str)

static n_nonsignlebond_electrons(m)

static substructurematch(m1, m2)

substructure search with smarts, True if m2 has sub graph of m1

Parameters

• m1 – pattern used to search

• m2 –

Returns

static to_smarts(rdmol)

static unsaturation(m)

static vis_partition(m: rdkit.Chem.rdchem.Mol, fnprefix='m')

Module contents

this contains the schema for dealing with conjugate organics, molecules and beyond

Graph:

atom index: nodename

Molecule:

RdMol format: smiles, smarts, inchi atom index: atomidx

Conformer:

Dimer –> OrganicMolecule, Backbone, SideGroup, Ring –> BasicConformer format: xyz atom index: siteid

Configuration:

SuperCell –> UnitCell –> AsymmUnit –> Configuration format: cif, poscar atom index: siteid

graph <–> molecule <–> conformer <–> configuration

#TODO Granular Schema