notebook/Polymer_Similarity_Method_Section_PolymerA_PolymerB.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nVg45IXBOyyO"
      },
      "source": [
        "\n",
        "\n",
        "<a target=\"_blank\" href=\"https://colab.research.google.com/github/olsenlabmit/Polymer-Graph-Similarity/blob/main/notebook/Polymer_Similarity_Method_Section_PolymerA_PolymerB.ipynb\">\n",
        "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
        "</a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "cellView": "form",
        "id": "9ExWfHqV1EXI"
      },
      "outputs": [],
      "source": [
        "# @title Copyright & License (click to expand)\n",
        "# MIT License\n",
        "\n",
        "# Copyright (c) 2022 olsenlabmit\n",
        "\n",
        "# Permission is hereby granted, free of charge, to any person obtaining a copy\n",
        "# of this software and associated documentation files (the \"Software\"), to deal\n",
        "# in the Software without restriction, including without limitation the rights\n",
        "# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
        "# copies of the Software, and to permit persons to whom the Software is\n",
        "# furnished to do so, subject to the following conditions:\n",
        "\n",
        "# The above copyright notice and this permission notice shall be included in all\n",
        "# copies or substantial portions of the Software.\n",
        "\n",
        "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
        "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
        "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
        "# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
        "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
        "# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
        "# SOFTWARE."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_sKD4LKzw0QJ"
      },
      "source": [
        "# Method Section: The pairwise similarity between Polymer A and Polymer B"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kA0PTW_O3VxE"
      },
      "source": [
        "This notebook is to perform the calculations and reproduce the results of **Method section** about the calculation of the pairwise similarity between **Polymer A** and **Polymer B** in the manuscript, Jiale Shi, Nathan J. Rebello, Dylan Walsh, Weizhong Zou, Michael E. Deagen, Bruno Salomao Leao, Debra J. Audus, Bradley D. Olsen, \"Quantifying Pairwise Chemical Similarity for Polymers\", submitted."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9n8-Ciyiy7G"
      },
      "source": [
        "# Import and Install Necessary Libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "psnOpmYlL_sw",
        "outputId": "feab230d-5fcd-41ae-b859-d663df616b3e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m29.4/29.4 MB\u001b[0m \u001b[31m64.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.0/11.0 MB\u001b[0m \u001b[31m95.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hSelecting previously unselected package coinor-libcoinutils3v5.\n",
            "(Reading database ... 122349 files and directories currently installed.)\n",
            "Preparing to unpack .../0-coinor-libcoinutils3v5_2.11.4+repack1-1_amd64.deb ...\n",
            "Unpacking coinor-libcoinutils3v5 (2.11.4+repack1-1) ...\n",
            "Selecting previously unselected package coinor-libosi1v5.\n",
            "Preparing to unpack .../1-coinor-libosi1v5_0.108.6+repack1-1_amd64.deb ...\n",
            "Unpacking coinor-libosi1v5 (0.108.6+repack1-1) ...\n",
            "Selecting previously unselected package coinor-libclp1.\n",
            "Preparing to unpack .../2-coinor-libclp1_1.17.5+repack1-1_amd64.deb ...\n",
            "Unpacking coinor-libclp1 (1.17.5+repack1-1) ...\n",
            "Selecting previously unselected package coinor-libcgl1.\n",
            "Preparing to unpack .../3-coinor-libcgl1_0.60.3+repack1-2_amd64.deb ...\n",
            "Unpacking coinor-libcgl1 (0.60.3+repack1-2) ...\n",
            "Selecting previously unselected package coinor-libcbc3.\n",
            "Preparing to unpack .../4-coinor-libcbc3_2.10.3+repack1-1build1_amd64.deb ...\n",
            "Unpacking coinor-libcbc3 (2.10.3+repack1-1build1) ...\n",
            "Selecting previously unselected package coinor-cbc.\n",
            "Preparing to unpack .../5-coinor-cbc_2.10.3+repack1-1build1_amd64.deb ...\n",
            "Unpacking coinor-cbc (2.10.3+repack1-1build1) ...\n",
            "Setting up coinor-libcoinutils3v5 (2.11.4+repack1-1) ...\n",
            "Setting up coinor-libosi1v5 (0.108.6+repack1-1) ...\n",
            "Setting up coinor-libclp1 (1.17.5+repack1-1) ...\n",
            "Setting up coinor-libcgl1 (0.60.3+repack1-2) ...\n",
            "Setting up coinor-libcbc3 (2.10.3+repack1-1build1) ...\n",
            "Setting up coinor-cbc (2.10.3+repack1-1build1) ...\n",
            "Processing triggers for man-db (2.9.1-1) ...\n",
            "Processing triggers for libc-bin (2.31-0ubuntu9.9) ...\n"
          ]
        }
      ],
      "source": [
        "# import necessary libraries available in colab\n",
        "import numpy as np\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "import shutil\n",
        "import sys\n",
        "import os.path\n",
        "\n",
        "# install necessary libraries not available in colab\n",
        "if not shutil.which(\"rdkit\"):\n",
        "    !pip install -q rdkit\n",
        "\n",
        "from rdkit import Chem\n",
        "from rdkit import DataStructs\n",
        "from rdkit.Chem import AllChem\n",
        "from rdkit.Chem import MACCSkeys\n",
        "from rdkit.Chem.AtomPairs import Pairs\n",
        "\n",
        "if not shutil.which(\"pyomo\"):\n",
        "    !pip install -q pyomo\n",
        "    assert shutil.which(\"pyomo\")\n",
        "\n",
        "if not (shutil.which(\"cbc\") or os.path.isfile(\"cbc\")):\n",
        "    if \"google.colab\" in sys.modules:\n",
        "        !apt-get install -y -qq coinor-cbc\n",
        "    else:\n",
        "        try:\n",
        "            !conda install -c conda-forge coincbc\n",
        "        except:\n",
        "            pass\n",
        "\n",
        "assert shutil.which(\"cbc\") or os.path.isfile(\"cbc\")\n",
        "\n",
        "from pyomo.environ import *"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D2aVwhkeZcX8"
      },
      "source": [
        "# Similarity Score Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsMcsqU-Pv6Y"
      },
      "source": [
        "## Earth Mover's Distance (EMD) Similarity Function\n",
        "\n",
        "Use the earth mover's distance to compute similarity for repeating units and end groups.\n",
        "\n",
        "\n",
        "$ EMD (P,Q)= \\min_{F}\\sum_{i=1}^{m}\\sum_{j=1}^{n}f_{i,j}d_{i,j}$\n",
        "\n",
        "$ {\\rm subject\\ to\\ } f_{i,j} \\geq 0, {\\rm\\ for\\ any\\ } \\ 1 \\leq i \\leq m, 1 \\leq j \\leq n $\n",
        "\n",
        "$     \\sum_{j=1}^{n}f_{i,j} =w_{pi}, {\\rm for\\ any} \\ 1 \\leq i \\leq m $\n",
        "\n",
        "$     \\sum_{i=1}^{m}f_{i,j} =w_{qj}, {\\rm for\\ any} \\ 1 \\leq j \\leq n $\n",
        "\n",
        "$     \\sum_{i=1}^{m}\\sum_{j=1}^{n}f_{i,j} = \\sum_{i}^{m} w_{pi} = \\sum_{j}^{n} w_{qj} = 1 $ \n",
        "\n",
        "\n",
        "Molecular fragment ensemble $P = \\{(p_1,w_{p_1}) ,(p_2,w_{p_2}),...,(p_i,w_{p_i}),...,(p_m,w_{p_m})\\}$ has $m$ molecular fragments, where $p_i$ is a molecular fragment such as a repeat unit or end group and $w_{p_i}>0$ is the weight, related to the average probability (or frequency, $z$) of the molecular fragment being present in the polymer. Similarly, the second ensemble $Q = {(q_1,w_{q_1}),(q_2,w_{q_2}),...,(q_j,w_{q_j}),...,(q_n,w_{q_n})}$ has $n$ molecular fragments.  The sums of the weights for $P$ and $Q$ are both normalized and equal to one.\n",
        "The distance $d_{i,j}$ is calculated by the converting the pairwise similarity score $s_{i,j}$ between $p_{i}$ and $q_{j}$, where $d_{i,j} = 1 - s_{i,j}$.\n",
        "Transport flow $f_{i,j}$ represents the amount of weight at $p_i$ which is transported to $q_j$. \n",
        "\n",
        "The EMD linear optimization code  refers to [3.1. Transportation Networks, ND Pyomo Notebook](https://jckantor.github.io/ND-Pyomo-Cookbook/notebooks/03.01-Transportation-Networks.html)\n",
        "\n",
        "Once $EMD (P,Q)$ is calculated, the similarity score between $P$ and $Q$ is \n",
        "\n",
        "$S(P,Q) = 1- EMD (P,Q)$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "eOlNnWbfY8Va"
      },
      "outputs": [],
      "source": [
        "def Similarity_Score_EMD_Calculation(\n",
        "    query_smiles_list=None,\n",
        "    query_smiles_weight_list=None,\n",
        "    target_smiles_list=None,\n",
        "    target_smiles_weight_list=None,\n",
        "    embedding_function=\"MorganFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "):\n",
        "    # obtain the length of query smiles list and target smiles list\n",
        "    query_smiles_list_length = len(query_smiles_list)\n",
        "\n",
        "    target_smiles_list_length = len(target_smiles_list)\n",
        "\n",
        "    # check whether the query is identical to the target\n",
        "    if set(query_smiles_list) == set(target_smiles_list):\n",
        "        query_smiles_array = np.array(query_smiles_list)\n",
        "        query_smiles_level_array = np.array(query_smiles_weight_list)\n",
        "        inds_query = query_smiles_array.argsort()\n",
        "        sorted_query_smiles_array = query_smiles_array[inds_query]\n",
        "        sorted_query_smiles_level_array = query_smiles_level_array[inds_query]\n",
        "\n",
        "        target_smiles_array = np.array(target_smiles_list)\n",
        "        target_smiles_level_array = np.array(target_smiles_weight_list)\n",
        "        inds_target = target_smiles_array.argsort()\n",
        "        sorted_target_smiles_array = target_smiles_array[inds_target]\n",
        "        sorted_target_smiles_level_array = target_smiles_level_array[inds_target]\n",
        "\n",
        "        if np.array_equal(\n",
        "            sorted_query_smiles_array, sorted_target_smiles_array\n",
        "        ) and np.array_equal(\n",
        "            sorted_query_smiles_level_array, sorted_target_smiles_level_array\n",
        "        ):\n",
        "            return 1.0\n",
        "\n",
        "        query_smiles_reduced_list = list(set(query_smiles_list))\n",
        "        query_smiles_reduced_list_number = []\n",
        "\n",
        "        for i in range(0, len(query_smiles_reduced_list)):\n",
        "            query_smiles_reduced_list_number_i = 0\n",
        "            for j in range(0, len(query_smiles_list)):\n",
        "                if query_smiles_reduced_list[i] == query_smiles_list[j]:\n",
        "                    query_smiles_reduced_list_number_i = (\n",
        "                        query_smiles_reduced_list_number_i + query_smiles_weight_list[j]\n",
        "                    )\n",
        "\n",
        "            query_smiles_reduced_list_number.append(\n",
        "                query_smiles_reduced_list_number_i / sum(query_smiles_weight_list)\n",
        "            )\n",
        "\n",
        "        target_smiles_reduced_list = list(set(target_smiles_list))\n",
        "        target_smiles_reduced_list_number = []\n",
        "\n",
        "        for i in range(0, len(target_smiles_reduced_list)):\n",
        "            target_smiles_reduced_list_number_i = 0\n",
        "            for j in range(0, len(target_smiles_list)):\n",
        "                if target_smiles_reduced_list[i] == target_smiles_list[j]:\n",
        "                    target_smiles_reduced_list_number_i = (\n",
        "                        target_smiles_reduced_list_number_i\n",
        "                        + target_smiles_weight_list[j]\n",
        "                    )\n",
        "\n",
        "            target_smiles_reduced_list_number.append(\n",
        "                target_smiles_reduced_list_number_i / sum(target_smiles_weight_list)\n",
        "            )\n",
        "\n",
        "        if query_smiles_reduced_list_number == target_smiles_reduced_list_number:\n",
        "            return 1.0\n",
        "\n",
        "    # transfer SMILES to fingerprints\n",
        "    if embedding_function == \"RDKFingerprint\":\n",
        "        query_mol_list = [Chem.MolFromSmiles(x) for x in query_smiles_list]\n",
        "        query_fingerprint_list = [Chem.RDKFingerprint(x) for x in query_mol_list]\n",
        "        target_mol_list = [Chem.MolFromSmiles(x) for x in target_smiles_list]\n",
        "        target_fingerprint_list = [Chem.RDKFingerprint(x) for x in target_mol_list]\n",
        "\n",
        "    elif embedding_function == \"MorganFingerprint\":\n",
        "        query_mol_list = [Chem.MolFromSmiles(x) for x in query_smiles_list]\n",
        "        query_fingerprint_list = [\n",
        "            AllChem.GetMorganFingerprintAsBitVect(x, 2, nBits=2048)\n",
        "            for x in query_mol_list\n",
        "        ]\n",
        "        target_mol_list = [Chem.MolFromSmiles(x) for x in target_smiles_list]\n",
        "        target_fingerprint_list = [\n",
        "            AllChem.GetMorganFingerprintAsBitVect(x, 2, nBits=2048)\n",
        "            for x in target_mol_list\n",
        "        ]\n",
        "\n",
        "    elif embedding_function == \"MACCSkeys\":\n",
        "        query_mol_list = [Chem.MolFromSmiles(x) for x in query_smiles_list]\n",
        "        query_fingerprint_list = [MACCSkeys.GenMACCSKeys(x) for x in query_mol_list]\n",
        "        target_mol_list = [Chem.MolFromSmiles(x) for x in target_smiles_list]\n",
        "        target_fingerprint_list = [MACCSkeys.GenMACCSKeys(x) for x in target_mol_list]\n",
        "\n",
        "    else:\n",
        "        print(\n",
        "            embedding_function\n",
        "            + \" is not included in the current vision.\"\n",
        "            + \" Please choose an available embedding function:\"\n",
        "        )\n",
        "        print(\"MorganFingerprint, RDKFingerprint, MACCSkeys.\")\n",
        "        return False\n",
        "\n",
        "    # define the required three sets\n",
        "    Demand = {}  # query\n",
        "    Supply = {}  # target\n",
        "    T = {}  # transport flow\n",
        "\n",
        "    # define the weight for SMILES in query, w_i\n",
        "    if len(set(query_smiles_weight_list)) == 1:\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            Demand[\"P\" + str(i + 1)] = 1 / query_smiles_list_length\n",
        "\n",
        "    else:\n",
        "        query_weight_sum = sum(query_smiles_weight_list)\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            Demand[\"P\" + str(i + 1)] = query_smiles_weight_list[i] / query_weight_sum\n",
        "\n",
        "    # define weight for SMILES in target, w_j\n",
        "    if len(set(target_smiles_weight_list)) == 1:\n",
        "        for j in range(0, target_smiles_list_length):\n",
        "            Supply[\"Q\" + str(j + 1)] = 1 / target_smiles_list_length\n",
        "\n",
        "    else:\n",
        "        target_weight_sum = sum(target_smiles_weight_list)\n",
        "        for j in range(0, target_smiles_list_length):\n",
        "            Supply[\"Q\" + str(j + 1)] = target_smiles_weight_list[j] / target_weight_sum\n",
        "\n",
        "    # use similarity function to calculate d_ij\n",
        "    if similarity_score_function == \"Tanimoto\":\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            for j in range(0, target_smiles_list_length):\n",
        "                T[\n",
        "                    (\"P\" + str(i + 1), \"Q\" + str(j + 1))\n",
        "                ] = 1 - DataStructs.FingerprintSimilarity(\n",
        "                    query_fingerprint_list[i], target_fingerprint_list[j]\n",
        "                )\n",
        "\n",
        "    elif similarity_score_function == \"Dice\":\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            for j in range(0, target_smiles_list_length):\n",
        "                T[\n",
        "                    (\"P\" + str(i + 1), \"Q\" + str(j + 1))\n",
        "                ] = 1 - DataStructs.FingerprintSimilarity(\n",
        "                    query_fingerprint_list[i],\n",
        "                    target_fingerprint_list[j],\n",
        "                    metric=DataStructs.DiceSimilarity,\n",
        "                )\n",
        "\n",
        "    elif similarity_score_function == \"Cosine\":\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            for j in range(0, target_smiles_list_length):\n",
        "                T[\n",
        "                    (\"P\" + str(i + 1), \"Q\" + str(j + 1))\n",
        "                ] = 1 - DataStructs.FingerprintSimilarity(\n",
        "                    query_fingerprint_list[i],\n",
        "                    target_fingerprint_list[j],\n",
        "                    metric=DataStructs.CosineSimilarity,\n",
        "                )\n",
        "\n",
        "    else:\n",
        "        print(\n",
        "            similarity_score_function\n",
        "            + \" is not included in the current vision.\"\n",
        "            + \" Please choose an available similarity function:\"\n",
        "        )\n",
        "        print(\"Tanimoto, Dice, or Cosine\")\n",
        "        return\n",
        "\n",
        "    # linear optimization with pyomo\n",
        "    # step 0: Create an instance of the model\n",
        "    model = ConcreteModel()\n",
        "    model.dual = Suffix(direction=Suffix.IMPORT)\n",
        "\n",
        "    # step 1: define index sets\n",
        "    CUS = list(Demand.keys())\n",
        "    SRC = list(Supply.keys())\n",
        "\n",
        "    # step 2: define the decision\n",
        "    model.x = Var(CUS, SRC, domain=NonNegativeReals)\n",
        "\n",
        "    # step 3: define objective\n",
        "    model.Cost = Objective(\n",
        "        expr=sum([T[c, s] * model.x[c, s] for c in CUS for s in SRC]), sense=minimize\n",
        "    )\n",
        "\n",
        "    # step 4: define constraints\n",
        "    model.src = ConstraintList()\n",
        "    for s in SRC:\n",
        "        model.src.add(sum([model.x[c, s] for c in CUS]) == Supply[s])\n",
        "\n",
        "    model.dmd = ConstraintList()\n",
        "    for c in CUS:\n",
        "        model.dmd.add(sum([model.x[c, s] for s in SRC]) == Demand[c])\n",
        "\n",
        "    # step 5: solve the model\n",
        "    results = SolverFactory(\"cbc\").solve(model)\n",
        "\n",
        "    if \"ok\" == str(results.Solver.status):\n",
        "        SimilarityScore = 1 - model.Cost()\n",
        "        return SimilarityScore\n",
        "\n",
        "    else:\n",
        "        print(\"No Valid Solution Found\")\n",
        "        return False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNpt-pIDQLOX"
      },
      "source": [
        "## Topology Similarity Function\n",
        "\n",
        "Use graph edit distance $GED(g_1, g_2)$ to compute the topological similarity $S_{\\rm TOP}(g_1,g_2)$.\n",
        "\n",
        "$GED(g_1, g_2)$  is computed via a networkx function [graph_edit_distance](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.similarity.graph_edit_distance.html), while the topological similarity score $S_{\\rm TOP}(g_1,g_2)$ in the range of (0,1] is computed via a exponential decay function:\n",
        "\n",
        "\n",
        "$S_{\\rm TOP}(g_1, g_2) = \\exp(-\\frac{\\alpha \\cdot GED(g_1, g_2)}{(N_1 + N_2)/2})$\n",
        "\n",
        "where $N_i$ is the number of nodes in graph $g_i$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "oyUi54M_IorG"
      },
      "outputs": [],
      "source": [
        "def Topology_Similarity_Score_Calculation(Graph1=None, Graph2=None, alpha=1):\n",
        "    if Graph1 == None:\n",
        "        print(\"Missing Graph1\")\n",
        "        return\n",
        "    if Graph2 == None:\n",
        "        print(\"Missing Graph2\")\n",
        "        return\n",
        "\n",
        "    Graph1_number_nodes = Graph1.number_of_nodes()\n",
        "    Graph2_number_nodes = Graph2.number_of_nodes()\n",
        "\n",
        "    graph_edit_distance = nx.graph_edit_distance(Graph1, Graph2)\n",
        "\n",
        "    topology_similarity_score = np.exp(\n",
        "        -alpha * graph_edit_distance / ((Graph1_number_nodes + Graph2_number_nodes) / 2)\n",
        "    )\n",
        "\n",
        "    return topology_similarity_score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v_4bM0zPQRGC"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7bdTaiEZQelj"
      },
      "source": [
        "## Weighted Mean Function for Overall Pairwise Similarity Score $S_{\\rm OA}$ \n",
        "\n",
        "From the above EMD and GED calculations, three similarity scores are obtained: $S_{\\rm RU}$  for repeat units, $S_{\\rm EG}$  for end groups, and $S_{\\rm TOP}$   for topology. To calculate the overall similarity score $S_{\\rm OA}$. Two weighted mean functions are provided. \n",
        "\n",
        "1. weighted geometric mean\n",
        "\n",
        "$S_{\\rm OA} =  S_{\\rm RU}^{W_{\\rm RU}} \\cdot S_{\\rm TOP}^{W_{\\rm TOP}} \\cdot S_{\\rm EG}^{W_{\\rm EG}} $ \n",
        "\n",
        "2. weighted arithmetic mean\n",
        "\n",
        "$S_{\\rm OA} =  S_{\\rm RU} \\cdot W_{\\rm RU} + S_{\\rm TOP} \\cdot W_{\\rm TOP} +  S_{\\rm EG} \\cdot W_{\\rm EG} $ \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "tnGFkpht12nw"
      },
      "outputs": [],
      "source": [
        "def Overall_Similarity_Score_Calculation(\n",
        "    query=None,\n",
        "    target=None,\n",
        "    embedding_function=\"RDKFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "    alpha=1,\n",
        "    Repeat_Unit_Weight=0.475,\n",
        "    Topology_Weight=0.475,\n",
        "    End_Group_Weight=0.05,\n",
        "    Mean_Function=\"geometric\",\n",
        "    details_print=False,\n",
        "    return_with_components=False,\n",
        "):\n",
        "    if query == None or target == None:\n",
        "        print(\n",
        "            \"Either query polymer or target polymer is missing! Please check the input.\"\n",
        "        )\n",
        "        return\n",
        "\n",
        "    Repeat_Unit_Similarity_Score = Similarity_Score_EMD_Calculation(\n",
        "        query_smiles_list=query.repeat_unit_smiles_list,\n",
        "        query_smiles_weight_list=query.repeat_unit_smiles_weight_list,\n",
        "        target_smiles_list=target.repeat_unit_smiles_list,\n",
        "        target_smiles_weight_list=target.repeat_unit_smiles_weight_list,\n",
        "        embedding_function=embedding_function,\n",
        "        similarity_score_function=similarity_score_function,\n",
        "    )\n",
        "\n",
        "    Topology_Similarity_Score = Topology_Similarity_Score_Calculation(\n",
        "        Graph1=query.graph_representation,\n",
        "        Graph2=target.graph_representation,\n",
        "        alpha=alpha,\n",
        "    )\n",
        "\n",
        "    if len(query.end_group_smiles_list) == 0 and len(target.end_group_smiles_list) == 0:\n",
        "        End_Group_Similarity_Score = 1.0\n",
        "\n",
        "    elif (\n",
        "        len(query.end_group_smiles_list) == 0 and len(target.end_group_smiles_list) != 0\n",
        "    ) or (\n",
        "        len(query.end_group_smiles_list) != 0 and len(target.end_group_smiles_list) == 0\n",
        "    ):\n",
        "        End_Group_Similarity_Score = 1.0\n",
        "\n",
        "    else:\n",
        "        End_Group_Similarity_Score = Similarity_Score_EMD_Calculation(\n",
        "            query_smiles_list=query.end_group_smiles_list,\n",
        "            query_smiles_weight_list=query.end_group_smiles_weight_list,\n",
        "            target_smiles_list=target.end_group_smiles_list,\n",
        "            target_smiles_weight_list=target.end_group_smiles_weight_list,\n",
        "            embedding_function=embedding_function,\n",
        "            similarity_score_function=similarity_score_function,\n",
        "        )\n",
        "\n",
        "    # verify whether the weight sum is normalized.\n",
        "    if abs(Repeat_Unit_Weight + Topology_Weight + End_Group_Weight - 1) != 0.0:\n",
        "        Weight_Sum = Repeat_Unit_Weight + Topology_Weight + End_Group_Weight\n",
        "\n",
        "        Repeat_Unit_Weight = Repeat_Unit_Weight / Weight_Sum\n",
        "\n",
        "        Topology_Weight = Topology_Weight / Weight_Sum\n",
        "\n",
        "        End_Group_Weight = End_Group_Weight / Weight_Sum\n",
        "\n",
        "    if Mean_Function == \"geometric\":\n",
        "        Overall_Similarity_Score = (\n",
        "            pow(Repeat_Unit_Similarity_Score, Repeat_Unit_Weight)\n",
        "            * pow(Topology_Similarity_Score, Topology_Weight)\n",
        "            * pow(End_Group_Similarity_Score, End_Group_Weight)\n",
        "        )\n",
        "\n",
        "    elif Mean_Function == \"arithmetic\":\n",
        "        Overall_Similarity_Score = (\n",
        "            Repeat_Unit_Weight * Repeat_Unit_Similarity_Score\n",
        "            + Topology_Weight * Topology_Similarity_Score\n",
        "            + End_Group_Weight * End_Group_Similarity_Score\n",
        "        )\n",
        "\n",
        "    else:\n",
        "        print(\n",
        "            \"Your input mean function \",\n",
        "            Mean_Function,\n",
        "            \" is not implemented currently.\"\n",
        "            + \" Please choose those implemented mean functions, such as arithmetic, geometric\",\n",
        "        )\n",
        "        return\n",
        "\n",
        "    if details_print == True:\n",
        "        print(\"Details of the Similarity Score:\\n\")\n",
        "        print(\n",
        "            \"Repeat Unit Similarity Score = \",\n",
        "            Repeat_Unit_Similarity_Score,\n",
        "            \", Normalized Weight for Repeat Unit = \",\n",
        "            Repeat_Unit_Weight,\n",
        "        )\n",
        "        print(\n",
        "            \"Topology Similarity Score = \",\n",
        "            Topology_Similarity_Score,\n",
        "            \", Normalized Weight for Topology = \",\n",
        "            Topology_Weight,\n",
        "        )\n",
        "        print(\n",
        "            \"End Group Similarity  = \",\n",
        "            End_Group_Similarity_Score,\n",
        "            \", Normalized Weight for End Group = \",\n",
        "            End_Group_Weight,\n",
        "        )\n",
        "        print(\n",
        "            \"Overall Pairwise Similarity Score with \"\n",
        "            + Mean_Function\n",
        "            + \" mean function = \",\n",
        "            Overall_Similarity_Score,\n",
        "        )\n",
        "        print(\"\\n\")\n",
        "\n",
        "    if return_with_components == True:\n",
        "        return (\n",
        "            Overall_Similarity_Score,\n",
        "            Repeat_Unit_Similarity_Score,\n",
        "            Topology_Similarity_Score,\n",
        "            End_Group_Similarity_Score,\n",
        "        )\n",
        "\n",
        "    return Overall_Similarity_Score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bijKjSMqQ-gw"
      },
      "source": [
        "# Define Polymer Class for Importing Polymer data\n",
        "\n",
        "The polymer graph is decomposed into three components: repeat units, end groups and topology. \n",
        "\n",
        "(I) To compute $S_{\\rm RU}$  for repeat units, we need the polymer's (1) repeat unit SMILES list and (2) corresponding weight list.\n",
        "\n",
        "(II) To compute $S_{\\rm EG}$  for end groups, we need the polymer's (3) end group SMILES list and (4) corresponding weight list.\n",
        "\n",
        "(III) To compute $S_{\\rm TOP}$ for topology, we need the polymers' (5) topological graph representation.\n",
        "\n",
        "Therefore, in the Polymer Class, we have to define the above five elements which are required to perform polymer similarity calculation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "k-I92q5zfd_L"
      },
      "outputs": [],
      "source": [
        "class Polymer:\n",
        "    def __init__(\n",
        "        self,\n",
        "        repeat_unit_smiles_list=None,\n",
        "        repeat_unit_smiles_weight_list=None,\n",
        "        end_group_smiles_list=None,\n",
        "        end_group_smiles_weight_list=None,\n",
        "        graph_representation=None,\n",
        "    ):\n",
        "        if repeat_unit_smiles_list == None:\n",
        "            print(\n",
        "                \"Error: Repeat Unit SMILES are missing.\"\n",
        "                + \" Please define the Repeat Unit SMILES.\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            self.repeat_unit_smiles_list = repeat_unit_smiles_list\n",
        "\n",
        "        if repeat_unit_smiles_weight_list == None:\n",
        "            print(\n",
        "                \"Error: Repeat Unit weights are missing.\"\n",
        "                + \" Please re-enter the correct Repeat Unit weights.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        elif len(repeat_unit_smiles_weight_list) != len(repeat_unit_smiles_list):\n",
        "            print(\n",
        "                \"Error: Repeat Unit weights are not correct.\"\n",
        "                + \" Please re-enter the correct Repeat Unit SMILES and weights.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            self.repeat_unit_smiles_weight_list = repeat_unit_smiles_weight_list\n",
        "\n",
        "        if end_group_smiles_list == None and end_group_smiles_weight_list == None:\n",
        "            self.end_group_smiles_list = []\n",
        "            self.end_group_smiles_weight_list = []\n",
        "            print(\n",
        "                \"Notice: The Polymer has NO End Group.\\n\"\n",
        "                + \"If this is what you want, this message is NOT Error.\\n\"\n",
        "                + \"Otherwise, please enter the correct End Group SMILES and weights.\\n\"\n",
        "            )\n",
        "\n",
        "        elif (\n",
        "            end_group_smiles_list == None and end_group_smiles_weight_list != None\n",
        "        ) or (end_group_smiles_list != None and end_group_smiles_weight_list == None):\n",
        "            print(\n",
        "                \"Error: End Group SMILES and weights are not matching.\"\n",
        "                + \" Please re-enter the correct End Group SMILES and weights.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            if len(end_group_smiles_list) != len(end_group_smiles_weight_list):\n",
        "                print(\n",
        "                    \"Error: End Group SMILES and weights are not matching.\"\n",
        "                    + \" Please re-enter the correct End Group SMILES and weights.\\n\"\n",
        "                )\n",
        "                return\n",
        "\n",
        "            else:\n",
        "                if (\n",
        "                    len(end_group_smiles_list) == 0\n",
        "                    and len(end_group_smiles_weight_list) == 0\n",
        "                ):\n",
        "                    print(\n",
        "                        \"Notice: The Polymer has NO End Group.\\n\"\n",
        "                        + \"If this is what you want, this message is NOT Error.\\n\"\n",
        "                        + \"Otherwise, please enter the correct End Group SMILES and weights.\\n\"\n",
        "                    )\n",
        "\n",
        "                self.end_group_smiles_list = end_group_smiles_list\n",
        "                self.end_group_smiles_weight_list = end_group_smiles_weight_list\n",
        "\n",
        "        if graph_representation == None:\n",
        "            print(\n",
        "                \"Error: Topology graph representation is missing.\"\n",
        "                + \" Please define the topology graph representation.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            self.graph_representation = graph_representation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vE5C5Cf0zSbF"
      },
      "source": [
        "# Method Section: The pairwise similarity between Polymer A and Polymer B\n",
        "\n",
        "Method section utilizes Polymer A and Polymer B to illustrate the computation of repeat unit similarity ($S_{\\rm RU}$), end group similarity ($S_{\\rm EG}$), topology similarity ($S_{\\rm TOP}$) and overall similarity ($S_{\\rm OA}$) between Polymer A and Polymer B.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "93332dHdzs9Y"
      },
      "source": [
        "# Define Polymer A and Polymer B"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eIHJx_8wpS33"
      },
      "source": [
        "## Polymer A\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1CaQzqPOndNhgvHiQSouFBRo2PFXePBok\"  width=\"50%\">\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "4gg0HbRJzsNw",
        "outputId": "d7b69684-fd00-49d8-a826-2c1e558ba47d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Polymer_A_graph_representation number of nodes:  4\n",
            "Polymer_A_graph_representation number of edges:  5\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "Polymer_A_graph_representation = nx.MultiDiGraph()\n",
        "Polymer_A_graph_representation.add_nodes_from([\"E1\", \"D1\", \"R1\", \"R2\"])\n",
        "Polymer_A_graph_representation.add_edges_from(\n",
        "    [(\"E1\", \"D1\"), (\"D1\", \"R1\"), (\"R1\", \"D1\"), (\"D1\", \"R2\"), (\"R2\", \"D1\")]\n",
        ")\n",
        "nx.draw(Polymer_A_graph_representation)\n",
        "print(\n",
        "    \"Polymer_A_graph_representation number of nodes: \",\n",
        "    Polymer_A_graph_representation.number_of_nodes(),\n",
        ")\n",
        "print(\n",
        "    \"Polymer_A_graph_representation number of edges: \",\n",
        "    Polymer_A_graph_representation.number_of_edges(),\n",
        ")\n",
        "\n",
        "Polymer_A = Polymer(\n",
        "    repeat_unit_smiles_list=[\"*CC(C)O*\", \"*CCO*\"],\n",
        "    repeat_unit_smiles_weight_list=[1, 1],\n",
        "    end_group_smiles_list=[\"OCCO*\"],\n",
        "    end_group_smiles_weight_list=[1],\n",
        "    graph_representation=Polymer_A_graph_representation,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pkO_5dOtpY_E"
      },
      "source": [
        "## Polymer B\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1cvb8M9Cx732BHGVpb1iQ9VOOPTjfwx3G\"  width=\"50%\">"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "FUemADZ3SN0d",
        "outputId": "fb4f3f2e-a373-4dad-9235-b0c8ab9f64cc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Polymer_B_graph_representation number of nodes:  7\n",
            "Polymer_B_graph_representation number of edges:  10\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "Polymer_B_graph_representation = nx.MultiDiGraph()\n",
        "Polymer_B_graph_representation.add_nodes_from(\n",
        "    [\"E1\", \"D1\", \"R1\", \"R1'\", \"D2\", \"R2\", \"R2'\"]\n",
        ")\n",
        "Polymer_B_graph_representation.add_edges_from(\n",
        "    [\n",
        "        (\"E1\", \"D1\"),\n",
        "        (\"D1\", \"R1\"),\n",
        "        (\"R1\", \"D1\"),\n",
        "        (\"D1\", \"R1'\"),\n",
        "        (\"R1'\", \"D1\"),\n",
        "        (\"D1\", \"D2\"),\n",
        "        (\"D2\", \"R2\"),\n",
        "        (\"R2\", \"D2\"),\n",
        "        (\"D2\", \"R2'\"),\n",
        "        (\"R2'\", \"D2\"),\n",
        "    ]\n",
        ")\n",
        "nx.draw(Polymer_B_graph_representation)\n",
        "print(\n",
        "    \"Polymer_B_graph_representation number of nodes: \",\n",
        "    Polymer_B_graph_representation.number_of_nodes(),\n",
        ")\n",
        "print(\n",
        "    \"Polymer_B_graph_representation number of edges: \",\n",
        "    Polymer_B_graph_representation.number_of_edges(),\n",
        ")\n",
        "\n",
        "Polymer_B = Polymer(\n",
        "    repeat_unit_smiles_list=[\"*CC(CC)*\", \"*CC(C)*\"],\n",
        "    repeat_unit_smiles_weight_list=[1, 1],\n",
        "    end_group_smiles_list=[\"CCC(C)*\"],\n",
        "    end_group_smiles_weight_list=[1],\n",
        "    graph_representation=Polymer_B_graph_representation,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jbS9tSrxzq8Q"
      },
      "source": [
        "# Calculate Similarity Scores\n",
        "## Calculate the Pairwise Similarity Score between Polymer A and Polymer B"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "25cY2LqC-PO7"
      },
      "source": [
        "### Geometric Mean"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8p8pHgcmPcg7",
        "outputId": "c7061483-82e6-4245-f1ce-850e44dd0706"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Details of the Similarity Score:\n",
            "\n",
            "Repeat Unit Similarity Score =  0.2773109243697478 , Normalized Weight for Repeat Unit =  0.475\n",
            "Topology Similarity Score =  0.23350647909091338 , Normalized Weight for Topology =  0.475\n",
            "End Group Similarity  =  0.09999999999999998 , Normalized Weight for End Group =  0.05\n",
            "Overall Pairwise Similarity Score with geometric mean function =  0.24285738204797738\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.24285738204797738"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "Overall_Similarity_Score_Calculation(\n",
        "    query=Polymer_A,\n",
        "    target=Polymer_B,\n",
        "    embedding_function=\"MorganFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "    alpha=1,\n",
        "    Repeat_Unit_Weight=0.475,\n",
        "    Topology_Weight=0.475,\n",
        "    End_Group_Weight=0.05,\n",
        "    Mean_Function=\"geometric\",\n",
        "    details_print=True,\n",
        "    return_with_components=False,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DVQ552c5-VCA"
      },
      "source": [
        "### Arithmetic Mean"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i8u6EwBlxydt",
        "outputId": "3016ddef-c54f-41eb-8b71-09e6222869df"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Details of the Similarity Score:\n",
            "\n",
            "Repeat Unit Similarity Score =  0.2773109243697478 , Normalized Weight for Repeat Unit =  0.475\n",
            "Topology Similarity Score =  0.23350647909091338 , Normalized Weight for Topology =  0.475\n",
            "End Group Similarity  =  0.09999999999999998 , Normalized Weight for End Group =  0.05\n",
            "Overall Pairwise Similarity Score with arithmetic mean function =  0.24763826664381405\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.24763826664381405"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "Overall_Similarity_Score_Calculation(\n",
        "    query=Polymer_A,\n",
        "    target=Polymer_B,\n",
        "    embedding_function=\"MorganFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "    alpha=1,\n",
        "    Repeat_Unit_Weight=0.475,\n",
        "    Topology_Weight=0.475,\n",
        "    End_Group_Weight=0.05,\n",
        "    Mean_Function=\"arithmetic\",\n",
        "    details_print=True,\n",
        "    return_with_components=False,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "702_fc7O9vmm"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}