Implement the interfaces between the coarse-grained model and the graph representation

[sikaoguo22]

[sikaoguo22]

This is how we build a Graph:

import networkx as nx

self.G = nx.Graph()
self.G.add_node(0, type="X")
self.G.add_node(1, type="X")
self.G.add_node(2, type="X")
self.G.add_node(3, type="X")

self.G.add_edge(0, 1, type="a")
self.G.add_edge(0, 2, type="b")
self.G.add_edge(0, 3, type="c")
self.G.add_edge(2, 3, type="a")
self.G.add_edge(1, 3, type="b")
self.G.add_edge(1, 2, type="c")

For a Corse Grained Model pdb_model, we has a pdb_model.molecule_list, which included the coarse grained information of each chain from the PDB (each chain is a molecule).

class CoarseGrainedMolecule:
    """
    Represents a coarse-grained molecule in NERDSS, potentially derived from a PDB chain.

    Attributes:
        name (str): Identifier of the molecule.
        my_template (MoleculeTemplate): Reference to the associated molecule template.
        coord (Coords): Center-of-mass coordinates.
        interface_list (list): List of binding interfaces.
        normal_point (list): Normal vector direction.
    """

    def __init__(self, name: str):
        """
        Initializes a CoarseGrainedMolecule.

        Args:
            name (str): Name/identifier of the molecule.
        """
        self.name = name
        self.my_template = None
        self.coord = None
        self.interface_list = []
        self.normal_point = None
        self.diffusion_translation = None
        self.diffusion_rotation = None
        self.radius = None

class MoleculeTemplate:
    """
    Represents a molecule type in NERDSS, including the molecule's center of mass (COM) 
    and a list of binding interfaces.

    Attributes:
        name (str): Identifier for the molecule type.
        interface_template_list (list): A list of BindingInterfaceTemplate objects that 
            describe the molecule’s binding sites.
        normal_point (list): Default normal vector direction.
    """

    def __init__(self, name: str):
        """
        Initializes a MoleculeTemplate.

        Args:
            name (str): Name/identifier of the molecule type.
        """
        self.name = name
        self.interface_template_list = []
        self.normal_point = [0,0,1]
        self.diffusion_translation = None
        self.diffusion_rotation = None
        self.radius = None

class BindingInterface:
    """
    Represents a binding interface between molecules.

    Attributes:
        name (str): Identifier of the binding interface.
        coord (Coords): Position of the interface.
        my_template (BindingInterfaceTemplate): Reference to the associated interface template.
        my_residues (list): Residues included in the interface.
        signature (dict): Stores interface geometry information.
    """

    def __init__(self, name: str):
        """
        Initializes a BindingInterface.

        Args:
            name (str): Identifier for the binding interface.
        """
        self.name = name
        self.coord = None
        self.my_template = None
        self.my_residues = []
        self.signature = {}
        self.energy = None

class BindingInterfaceTemplate:
    """
    Represents a binding interface template between molecules.

    Attributes:
        name (str): Identifier of the interface template.
        coord (Coords): Relative coordinates of the interface.
        my_residues (list): Residues forming this interface.
        required_free_list (list): Other interface templates that must remain unbound 
            for this interface to bind.
        signature (dict): Stores interface geometry information.
    """

    def __init__(self, name: str):
        """
        Initializes a BindingInterfaceTemplate.

        Args:
            name (str): Identifier for the interface template.
        """
        self.name = name
        self.coord = None
        self.my_residues = []
        self.required_free_list = [] # The list of interface templates that need to be free to bind to this interface template
        self.signature = {}
        self.energy = None

class Reaction:
    """
    Represents an actual reaction between two Molecule objects.

    Attributes:
        expression (str): Textual representation of the reaction.
        reactants (list): List of reactant molecules/interfaces.
        products (list): List of product molecules/interfaces.
        binding_angles (tuple): Tuple describing binding angles (theta1, theta2, phi1, phi2, omega).
        binding_radius (float): Distance between binding interfaces.
        norm1 (list): Normal vector of the first reactant.
        norm2 (list): Normal vector of the second reactant.
    """

    def __init__(self):
        """
        Initializes a Reaction with default values.
        """
        self.expression = None
        self.reactants = None
        self.products = None
        self.binding_angles = None
        self.binding_radius = None
        self.norm1 = None
        self.norm2 = None
        self.my_template = None
        self.kd = None
        self.ka = None
        self.kb = None
        self.energy = None

class ReactionTemplate:
    """
    Defines a reaction template between two MoleculeTemplates.

    Attributes:
        expression (str): Textual representation of the reaction.
        reactants (list): List of reactant molecule/interface templates.
        products (list): List of product molecule/interface templates.
        binding_angles (tuple): Tuple describing binding angles (theta1, theta2, phi1, phi2, omega).
        binding_radius (float): Distance between binding interfaces.
        norm1 (list): Normal vector of the first reactant.
        norm2 (list): Normal vector of the second reactant.
    """

    def __init__(self):
        """
        Initializes a ReactionTemplate with default values.
        """
        self.expression = None
        self.reactants = None
        self.products = None
        self.binding_angles = None
        self.binding_radius = None
        self.norm1 = None
        self.norm2 = None
        self.kd = None
        self.ka = None
        self.kb = None
        self.energy = None

A Molecule is corresponding to a node, whose type is molecule.my_template.name.

A Molecule has interface_list. Two interface form an interaction (reaction), which is a edge. Type of edge is the reaction_template of reaction. All reactions are in pdb_model.reaction_list