molSimplify 1.7.4__py3-none-any.whl

molSimplify/Scripts/tsgen.py

@@ -0,0 +1,295 @@
+# @file tsgen.py
+#  Generates transition state guess structures based on a user-specified complex (core), substrate and automatically identified reaction class.
+#
+#  Written by Terry Gani for HJK Group
+#
+#  Dpt of Chemical Engineering, MIT
+
+from numpy import log
+
+from molSimplify.Classes.mol3D import (mol3D)
+from molSimplify.Classes.atom3D import atom3D
+from molSimplify.Classes.rundiag import (run_diag)
+from molSimplify.Scripts.geometry import (alignPtoaxis,
+                                          distance,
+                                          rotate_around_axis,
+                                          rotation_params,
+                                          vecangle,
+                                          vecdiff)
+from molSimplify.Scripts.io import getinputargs
+from molSimplify.Scripts.structgen import (PointTranslateSph,
+                                           align_lig_centersym,
+                                           check_rotate_linear_lig,
+                                           check_rotate_symm_lig,
+                                           ffopt,
+                                           getconnection,
+                                           rotate_MLaxis_minimize_steric)
+
+# XY sum cov rad coefficient
+XYcoeff = 1.1
+# Mode 1 (oxidative addition) MXY angle
+MXYang = 135
+# Mode 1 (oxidative addition) MX sum cov rad coefficient
+MXdistcoeff = 0.9
+# Mode 3 (abstraction) ABX angle
+ABXang = 140
+
+# Gets all possible substrate connecting points (X in A-B...X-Y).
+#
+#  Given a fixed ABX angle and AB distance, these lie on a circle.
+#
+#  Due to limitations of geometry routines, we sample the sphere and keep points within ~1 deg of the circle.
+#  @param core mol3D of core
+#  @param catom Connecting atom to core
+#  @param Midx Core reference metal index
+#  @param BL Target B-X distance
+#  @param ABXang Target A-B-X angle
+#  @return List of discretized possible connecting points
+
+
+def getconnections(core, catom, Midx, BL, ABXang):
+    Ocoords = core.getAtom(catom).coords()
+    Mcoords = core.getAtom(Midx).coords()
+    backbcoords = alignPtoaxis(Ocoords, Ocoords, vecdiff(Ocoords, Mcoords), BL)
+    am = atom3D('C', backbcoords)
+    connPts = []
+    for iphi in range(1, 359, 10):
+        for itheta in range(1, 179, 1):
+            P = PointTranslateSph(Ocoords, backbcoords, [BL, iphi, itheta])
+            am.setcoords(P)
+            ang = 180-vecangle(vecdiff(Ocoords, Mcoords), vecdiff(P, Ocoords))
+            if abs(ang - ABXang) < 1:
+                connPts.append(P)
+    return connPts
+
+# Cheap method for determining optimal connecting point by empirically maximizing distances.
+#  @param core mol3D of core
+#  @param connPts List of possible connecting points
+#  @param catom Connecting atom to core
+#  @return Optimal substrate connecting point
+
+
+def substplacecheap(core, connPts, catom):
+    corerem = mol3D()
+    corerem.copymol3D(core)
+    corerem.deleteatom(catom)  # complex less O atom
+    mdist = -1
+    cpoint = [0, 0, 0]
+    for P in connPts:
+        if corerem.mindisttopoint(P) < 1:  # auto-reject if too close
+            d0 = -2
+        else:
+            d0 = distance(core.centermass(), P)+0.5 * \
+                log(corerem.mindisttopoint(P)-1)
+        if d0 > mdist:
+            mdist = d0
+            cpoint = P
+    return cpoint
+
+# Aligns substrate to connecting point while minimizing sterics (abstraction version)
+#  @param core mol3D of core
+#  @param substr mol3D of substrate
+#  @param substreact Index of substrate reacting atom
+#  @param compreact Index of core reacting atom
+#  @param cpoint Coordinates of connecting point
+#  @param args Namespace of arguments
+#  @param connected List of connecting atoms for FF optimization
+#  @param frozenats Indices of atoms frozen in FF optimization
+#  @return Name of files generated, error messages, run diagnostic info
+
+
+def substplaceff_mode3(core, substr, substreact, compreact, cpoint, args, connected, frozenats):
+    enc = 0
+    # align substrate according to connection atom and shadow atom
+    substr.alignmol(substr.getAtom(substreact), atom3D('H', cpoint))
+    # perform rotations
+    Bcoords = core.getAtomCoords(compreact)
+    if substr.natoms > 1:
+        # align ligand center of symmetry
+        substr = align_lig_centersym(Bcoords, substr, substreact, core, False)
+    if substr.natoms > 2:
+        # check for linear molecule and align
+        substr = check_rotate_linear_lig(Bcoords, substr, substreact)
+        # check for symmetric molecule
+        substr = check_rotate_symm_lig(Bcoords, substr, substreact, core)
+        # rotate around M-L axis to minimize steric repulsion
+        substr = rotate_MLaxis_minimize_steric(
+            Bcoords, substr, substreact, core)
+    # distort substrate molecule
+    adjsidx = substr.getBondedAtoms(substreact)[0]
+    XYBL = XYcoeff*(substr.getAtom(substreact).rad +
+                    substr.getAtom(adjsidx).rad)
+    substr.BCM(adjsidx, substreact, XYBL)
+    # combine molecules
+    ts3D = mol3D()
+    ts3D.copymol3D(core)
+    ts3D = ts3D.combine(substr)
+    ts3D.charge += substr.charge
+    if 'a' in args.ffoption or args.substplaceff:
+        ts3D, enc = ffopt(args.ff, ts3D, connected, 1,
+                          frozenats, False, [], 'Adaptive')
+    return ts3D, enc
+
+# Aligns substrate to connecting point while minimizing sterics (oxidative addition version)
+#  @param core mol3D of core
+#  @param substr mol3D of substrate
+#  @param substreact Index of substrate reacting atom
+#  @param compreact Index of core reacting atom
+#  @param cpoint Coordinates of distal ligand atom connecting point
+#  @param ligalignpt Coordinates of proximal ligand atom connecting point
+#  @param args Namespace of arguments
+#  @param connected List of connecting atoms for FF optimization
+#  @param frozenats Indices of atoms frozen in FF optimization
+#  @return Name of files generated, error messages, run diagnostic info
+
+
+def substplaceff_mode1(core, substr, substreact, compreact, cpoint, ligalignpt, args, connected, frozenats):
+    enc = 0
+    Mcoords = core.getAtomCoords(compreact)
+    adjsidx = substr.getBondedAtoms(substreact)[0]
+    theta, u = rotation_params(
+        substr.getAtomCoords(adjsidx), cpoint, ligalignpt)
+    substr = rotate_around_axis(substr, cpoint, u, 180-theta)
+    if substr.natoms > 2:
+        # same as aligning an equilibrium ligand
+        substr = check_rotate_linear_lig(Mcoords, substr, substreact)
+        substr = check_rotate_symm_lig(Mcoords, substr, substreact, core)
+        substr = rotate_MLaxis_minimize_steric(
+            Mcoords, substr, substreact, core)
+    ts3D = mol3D()
+    ts3D.copymol3D(core)
+    ts3D = ts3D.combine(substr)
+    if 'a' in args.ffoption or args.substplaceff:
+        print('FF optimizing remainder of substrate')
+        ts3D, enc = ffopt(args.ff, ts3D, connected, 1,
+                          frozenats, False, [], 'Adaptive')
+    return ts3D, enc
+
+# Main transition state generation routine
+#  @param mode TS generation mode (rungen.py)
+#  @param args Namespace of arguments
+#  @param rootdir Root directory
+#  @param core mol3D of core
+#  @param substr mol3D of substrate
+#  @param compreact Index of core reacting atom
+#  @param substreact Index of substrate reacting atom
+#  @param globs Global variables
+#  @return Name of files generated, error messages, run diagnostic info
+
+
+def tsgen(mode, args, rootdir, core, substr, compreact, substreact, globs):
+    emsg = False
+    ts3D = mol3D()
+    this_diag = run_diag()
+    strfiles = []
+    adjsidx = substr.getBondedAtoms(substreact)[0]
+    adjcidx = core.getBondedAtoms(compreact)[0]
+    # initialize connecting and frozen atoms for FF opt
+    frozenats = []
+    for i in range(0, core.natoms):
+        frozenats.append(i)
+    # also freeze the abstracted atom and the heavy atom bonded to it
+    frozenats.append(core.natoms+substreact)
+    frozenats.append(core.natoms+adjsidx)
+    connected = [core.natoms+substreact]
+    # START FUNCTIONALIZING
+    sanity = False
+    if mode == 2:
+        emsg = 'Sorry, this mode is not supported yet. Exiting...'
+        return strfiles, emsg, this_diag
+    elif mode == 1:  # oxidative addition of a single group
+        # get first connecting point
+        MXBL = MXdistcoeff*(core.getAtom(compreact).rad +
+                            substr.getAtom(substreact).rad)
+        cpoint = getconnection(core, compreact, MXBL)
+        # distort substrate molecule
+        XYBL = XYcoeff*(substr.getAtom(substreact).rad +
+                        substr.getAtom(adjsidx).rad)
+        substr.BCM(adjsidx, substreact, XYBL)
+        # align substrate molecule
+        substr.alignmol(substr.getAtom(substreact), atom3D('H', cpoint))
+        tmp3D = mol3D()
+        tmp3D.copymol3D(core)
+        tmp3D.addAtom(atom3D('Cl', cpoint))
+        ligalignpts = getconnections(
+            tmp3D, tmp3D.natoms-1, compreact, XYBL, MXYang)
+        if args.substplaceff:
+            # full FF substrate placement
+            print('Full FF-based substrate placement specified.')
+            en_min = 1e6
+            for n, P in enumerate(ligalignpts):
+                print(('Evaluating FF energy of point ' +
+                       str(n+1)+' of '+str(len(ligalignpts))))
+                coretmp = mol3D()
+                coretmp.copymol3D(core)
+                substrtmp = mol3D()
+                substrtmp.copymol3D(substr)
+                ts3Dtmp, enc = substplaceff_mode1(
+                    coretmp, substrtmp, substreact, compreact, cpoint, P, args, connected, frozenats)
+                if enc < en_min:
+                    en_min = enc
+                    ts3D = mol3D()
+                    ts3D.copymol3D(ts3Dtmp)
+        else:
+            # cheap substrate placement
+            print('Cheap substrate placement')
+            ligalignpt = substplacecheap(core, ligalignpts, compreact)
+            ts3D, enc = substplaceff_mode1(
+                core, substr, substreact, compreact, cpoint, ligalignpt, args, connected, frozenats)
+    elif mode == 3:  # abstraction
+        # distort A-B bond
+        ABBL = distance(core.getAtomCoords(compreact), core.getAtomCoords(
+            adjcidx)) + 0.05*(core.getAtom(compreact).rad + core.getAtom(adjcidx).rad)
+        core.BCM(compreact, adjcidx, ABBL)
+        # set B-X distance
+        BXBL = 1.1*(substr.getAtom(substreact).rad +
+                    core.getAtom(compreact).rad)
+        # get possible connecting points
+        connPts = getconnections(core, compreact, adjcidx, BXBL, ABXang)
+        if args.substplaceff:
+            # full FF substrate placement
+            print('Full FF-based substrate placement specified.')
+            en_min = 1e6
+            for n, P in enumerate(connPts):
+                print(('Evaluating FF energy of point ' +
+                       str(n+1)+' of '+str(len(connPts))))
+                coretmp = mol3D()
+                coretmp.copymol3D(core)
+                substrtmp = mol3D()
+                substrtmp.copymol3D(substr)
+                ts3Dtmp, enc = substplaceff_mode3(
+                    coretmp, substrtmp, substreact, compreact, P, args, connected, frozenats)
+                if enc < en_min:
+                    en_min = enc
+                    ts3D = mol3D()
+                    ts3D.copymol3D(ts3Dtmp)
+        else:
+            # cheap substrate placement
+            print('Cheap substrate placement')
+            cpoint = substplacecheap(core, connPts, compreact)
+            ts3D, enc = substplaceff_mode3(
+                core, substr, substreact, compreact, cpoint, args, connected, frozenats)
+            if 'a' in args.ffoption:
+                print('FF optimized remainder of substrate')
+    ts3D.charge += substr.charge
+    # END FUNCTIONALIZING
+    fname = name_TS(rootdir, args.core, substr, args,  # noqa F821 function deprecated
+                    bind=args.bind, bsmi=args.nambsmi)
+    ts3D.writexyz(fname)
+    strfiles.append(fname)
+    getinputargs(args, fname)
+    pfold = rootdir.split('/', 1)[-1]
+    # check for molecule sanity
+    sanity, d0 = ts3D.sanitycheck(True)
+    if args.debug:
+        print(('setting sanity diag, min dist at ' +
+               str(d0) + ' (higher is better)'))
+    this_diag.set_sanity(sanity, d0)
+    this_diag.set_mol(ts3D)
+    this_diag.write_report(fname+'.report')
+    del ts3D
+    if sanity:
+        print(('WARNING: Generated complex is not good! Minimum distance between atoms:' +
+              "{0:.2f}".format(d0)+'A\n'))
+    print(('\nIn folder '+pfold+' generated 1 structure(s)!'))
+    return strfiles, emsg, this_diag

molSimplify/Scripts/uq_calibration.py

@@ -0,0 +1,69 @@
+from functools import partial
+import numpy as np
+from scipy.optimize import minimize
+from scipy.stats import norm
+
+
+def nlm(func, p0,
+        dists, epsilons,
+        varfun):
+    '''
+    non-linear optimization.
+    Usage: nlm(maximum_likelihood_loss, [1, 2], dists, epsilons, varfun=linear_variance_model)
+
+    :param func: objective function to be minimized
+    :param p0: initial guess of the parameters
+    :param dists: latent space distance (or other uq metric)
+    :param epsilons: errors for predictions
+    :param varfun: variance function for the final Gaussian distribution
+    :return: best parameters
+    '''
+    objective_func = partial(func,
+                             dists=dists,
+                             epsilons=epsilons,
+                             varfun=varfun)
+    m = minimize(objective_func, p0,
+                 method='Powell',
+                 jac=False,
+                 tol=1e-4,
+                 options={'maxiter': 1000, 'disp': True})
+    return m.x
+
+
+def linear_variance_model(dist, theta):
+    '''
+
+    :param dist: latent space distance (or other uq metric)
+    :param theta: parameters for the condition Gaussian distribution err(d) ~ N(0, theta_0^2 + d* theta_1^2)
+    :return: std for the conditional Gaussian distribution
+    '''
+    return theta[0] ** 2 + (theta[1] ** 2) * dist
+
+
+def zero_linear_variance_model(dist, theta):
+    '''
+
+    :param dist: latent space distance (or other uq metric)
+    :param theta: parameters for the condition Gaussian distribution err(d) ~ N(0, d* theta_0^2)
+    :return: std for the conditional Gaussian distribution
+    '''
+    return (theta[0] ** 2) * dist
+
+
+def maximum_likelihood_loss(theta, dists, epsilons, varfun=linear_variance_model):
+    '''
+
+    :param theta: parameters for the condition Gaussian distribution err(d) ~ N(0, theta_0^2 + d* theta_1^2)
+    :param dists: latent space distance (or other uq metric)
+    :param epsilons: errors for predictions
+    :param varfun: variance function for the final Gaussian distribution
+    :return: loss of the maximum likelihood.
+    '''
+    L = 0
+    for i in range(len(epsilons)):
+        epsilon = epsilons[i]
+        dist = dists[i]
+        this_var = varfun(dist, theta)
+        L += -np.log(norm.pdf(epsilon, 0, np.sqrt(this_var)))
+        # L += 0.5 * np.log(2 * np.pi * np.sqrt(this_var)) + 1. * (epsilon ** 2) / (2 * this_var)
+    return L

molSimplify/__main__.py

@@ -0,0 +1,197 @@
+# @file __main__.py
+# Gateway script to rest of program
+#
+# Written by Tim Ioannidis for HJK Group
+#
+# Dpt of Chemical Engineering, MIT
+
+# !/usr/bin/env python
+'''
+    Copyright 2017 Kulik Lab @ MIT
+
+    This file is part of molSimplify.
+    molSimplify is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published
+    by the Free Software Foundation, either version 3 of the License,
+    or (at your option) any later version.
+
+    molSimplify is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+    See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with molSimplify. If not, see http://www.gnu.org/licenses/.
+'''
+# fix OB bug: https://github.com/openbabel/openbabel/issues/1983
+import sys
+import argparse
+if not ('win' in sys.platform):
+    flags = sys.getdlopenflags()
+if not ('win' in sys.platform):
+    sys.setdlopenflags(flags)
+
+from molSimplify.Scripts.inparse import (parseinputs_advanced, parseinputs_slabgen,
+                                         parseinputs_db, parseinputs_inputgen,
+                                         parseinputs_postproc, parseinputs_random,
+                                         parseinputs_binding, parseinputs_tsgen,
+                                         parseinputs_customcore, parseinputs_naming,
+                                         parseinputs_ligdict, parseinputs_basic,
+                                         parseCLI)
+from molSimplify.Scripts.generator import startgen
+from molSimplify.Classes.globalvars import globalvars
+from molSimplify.utils.tensorflow import tensorflow_silence
+
+globs = globalvars()
+# Basic help description string
+DescString_basic = (
+    'Welcome to molSimplify. Only basic usage is described here.\n'
+    'For help on advanced modules, please refer to our documentation at '
+    'molsimplify.mit.edu or provide additional commands to -h, as below:\n'
+    '-h advanced: advanced structure generation help\n'
+    '-h slabgen: slab builder help\n'
+    # '-h chainb: chain builder help\n'
+    '-h autocorr: automated correlation analysis help\n'
+    '-h db: database search help\n'
+    '-h inputgen: quantum chemistry code input file generation help\n'
+    '-h postproc: post-processing help\n'
+    '-h random: random generation help\n'
+    '-h binding: binding species (second molecule) generation help\n'
+    '-h customcore: custom core functionalization help\n'
+    '-h tsgen: transition state generation help\n'
+    '-h naming: custom filename help\n'
+    '-h liganddict: ligands.dict help\n'
+)
+# Advanced help description string
+DescString_advanced = 'Printing advanced structure generation help.'
+# Slab builder help description string
+DescString_slabgen = 'Printing slab builder help.'
+# Chain builder help description string
+DescString_chainb = 'Printing chain builder help.'
+# Automated correlation analysis description string
+DescString_autocorr = 'Printing automated correlation analysis help.'
+# Database search help description string
+DescString_db = 'Printing database search help.'
+# Input file generation help description string
+DescString_inputgen = 'Printing quantum chemistry code input file generation help.'
+# Post-processing help description string
+DescString_postproc = 'Printing post-processing help.'
+# Random generation help description string
+DescString_random = 'Printing random generation help.'
+# Binding species placement help description string
+DescString_binding = 'Printing binding species (second molecule) generation help.'
+# Transition state generation help description string
+DescString_tsgen = 'Printing transition state generation help.'
+# Ligand replacement help description string
+DescString_customcore = 'Printing ligand replacement help.'
+# Custom file naming help description string
+DescString_naming = 'Printing custom filename help.'
+# Ligand dictionary help description string
+DescString_ligdict = 'Printing ligand dictionary help.'
+
+
+try:
+    from PyQt5.QtWidgets import QApplication
+    from molSimplify.Classes.mGUI import mGUI
+    qtflag = True
+except ImportError:
+    qtflag = False
+
+
+# Main function
+#  @param args Argument namespace
+def main(args=None):
+    # issue a call to test TF, this is needed to keep
+    # ordering between openbabel and TF calls consistent
+    # on some sytems
+    if globs.testTF():
+        print('TensorFlow connection successful')
+        tensorflow_silence()
+    else:
+        print('TensorFlow connection failed')
+
+    if args is None:
+        args = sys.argv[1:]
+    # ## run GUI by default ###
+    gui = True
+    if len(args) == 0 and not qtflag:
+        print("\nGUI not supported since PyQt5 can not be loaded. Please use commandline version.\n")
+        exit()
+    ####################################
+    # ## print help ###
+    elif '-h' in args or '-H' in args or '--help' in args:
+        if 'advanced' in args:
+            parser = argparse.ArgumentParser(description=DescString_advanced)
+            parseinputs_advanced(parser)
+        if 'slabgen' in args:
+            parser = argparse.ArgumentParser(description=DescString_slabgen)
+            parseinputs_slabgen(parser)
+        #    elif 'chainb' in args:
+        #        parser = argparse.ArgumentParser(description=DescString_chainb)
+        #        parseinputs_chainb(parser)
+        #    elif 'autocorr' in args:
+        #        parser = argparse.ArgumentParser(description=DescString_autocorr)
+        #        parseinputs_autocorr(parser)
+        elif 'db' in args:
+            parser = argparse.ArgumentParser(description=DescString_db)
+            parseinputs_db(parser)
+        elif 'inputgen' in args:
+            parser = argparse.ArgumentParser(description=DescString_inputgen)
+            parseinputs_inputgen(parser)
+        elif 'postproc' in args:
+            parser = argparse.ArgumentParser(description=DescString_postproc)
+            parseinputs_postproc(parser)
+        elif 'random' in args:
+            parser = argparse.ArgumentParser(description=DescString_random)
+            parseinputs_random(parser)
+        elif 'binding' in args:
+            parser = argparse.ArgumentParser(description=DescString_binding)
+            parseinputs_binding(parser)
+        elif 'tsgen' in args:
+            parser = argparse.ArgumentParser(description=DescString_tsgen)
+            parseinputs_tsgen(parser)
+        elif 'customcore' in args:
+            parser = argparse.ArgumentParser(description=DescString_customcore)
+            parseinputs_customcore(parser)
+        elif 'naming' in args:
+            parser = argparse.ArgumentParser(description=DescString_naming)
+            parseinputs_naming(parser)
+        elif 'liganddict' in args:
+            # The formatter class allows for the display of new lines.
+            parser = argparse.ArgumentParser(description=DescString_ligdict,
+                                             formatter_class=argparse.RawTextHelpFormatter)
+            parseinputs_ligdict(parser)
+        else:
+            # print basic help
+            parser = argparse.ArgumentParser(description=DescString_basic,
+                                             formatter_class=argparse.RawDescriptionHelpFormatter)
+            parseinputs_basic(parser)
+        return
+    # ## run with gui ###
+    elif gui and len(args) == 0:
+        print('molSimplify is starting!')
+        # ## create main application
+        app = QApplication(sys.argv)  # main application
+        _ = mGUI(app)  # main GUI class
+        app.processEvents()
+        app.exec_()
+    # ## if input file is specified run without GUI ###
+    elif '-i' in args:
+        print('Input file detected, reading arguments from input file')
+        print('molSimplify is starting!')
+        gui = False
+        # run from commandline
+        startgen(sys.argv, False, gui)
+    # ## grab from commandline arguments ###
+    else:
+        print('No input file detected, reading arguments from commandline')
+        print('molSimplify is starting!')
+        gui = False
+        # create input file from commandline
+        infile = parseCLI([_f for _f in args if _f])
+        args = ['main.py', '-i', infile]
+        startgen(args, False, gui)
+
+
+if __name__ == '__main__':
+    main()

molSimplify/ml/kernels.py

@@ -0,0 +1,36 @@
+from sklearn.gaussian_process.kernels import Kernel
+
+
+class Masking(Kernel):
+    def __init__(self, mask, kernel):
+        self.mask = mask
+        self.kernel = kernel
+
+    @property
+    def theta(self):
+        return self.kernel.theta
+
+    @theta.setter
+    def theta(self, theta):
+        self.kernel.theta = theta
+
+    @property
+    def bounds(self):
+        return self.kernel.bounds
+
+    def __call__(self, X, Y=None, eval_gradient=False):
+        if Y is None:
+            return self.kernel(X[:, self.mask], Y=None, eval_gradient=eval_gradient)
+        return self.kernel(
+            X[:, self.mask], Y=Y[:, self.mask], eval_gradient=eval_gradient
+        )
+
+    def diag(self, X):
+        return self.kernel.diag(X[:, self.mask])
+
+    def __repr__(self):
+        return "Masking({0})".format(self.kernel)
+
+    def is_stationary(self):
+        """Returns whether the kernel is stationary."""
+        return self.kernel.is_stationary()

molSimplify/ml/layers.py

@@ -0,0 +1,29 @@
+import tensorflow as tf
+from typing import List, Tuple
+
+
+class PermutationLayer(tf.keras.layers.Layer):
+
+    def __init__(self, permutations: List[Tuple[int]]):
+        super().__init__()
+        self.permutations = permutations
+
+    def call(self, inputs):
+        # Shape (batch_size, n_tmc_features)
+        tmc_inputs = inputs["tmc"]
+        # Shape (batch_size, n_ligands, n_ligand_features)
+        ligand_inputs = inputs["ligand"]
+        outputs = []
+        for p in self.permutations:
+            outputs.append(
+                tf.concat(
+                    [
+                        tmc_inputs,
+                    ]
+                    + [
+                        ligand_inputs[:, p_i, :] for p_i in p
+                    ],
+                    axis=-1,
+                )
+            )
+        return tf.stack(outputs, axis=1)

molSimplify/molscontrol/__init__.py

@@ -0,0 +1,14 @@
+"""
+MolsControl
+An automonous on-the-fly job control system for DFT geometry optimization aided by machine learning techniques.
+"""
+
+# Add imports here
+from molSimplify.molscontrol import *
+
+# Handle versioneer
+from ._version import get_versions
+versions = get_versions()
+__version__ = versions['version']
+__git_revision__ = versions['full-revisionid']
+del get_versions, versions