31102022_FATES_flow_field_and_fixed_points.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5a522189",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import scipy.special as sp\n",
    "import random as rand\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "from numba import jit,int64,float64\n",
    "import time\n",
    "import scipy.optimize as sciopt\n",
    "%matplotlib inline\n",
    "\n",
    "#To increase cell width:\n",
    "from IPython.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "\n",
    "#Color-blind friendly colors to plot:\n",
    "CB_colors = ['#377eb8', '#ff7f00', '#4daf4a','#f781bf', '#a65628', '#984ea3','#999999', '#e41a1c', '#dede00']\n",
    "\n",
    "# #Running the script with parameter definitions and functions:\n",
    "# %run 0-2_fates_functions.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "90970159",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parameters - self-activation a, cross-repression r, decay k, noise alpha:\n",
    "a = np.array([0,0])\n",
    "r = np.array([1,1])\n",
    "k = np.array([1,1])\n",
    "alpha = np.array([0.1,0.1])\n",
    "#Hill coefficients:\n",
    "n = np.array([[4,4],[4,4]])\n",
    "theta = np.array([[0.5,0.5],[0.5,0.5]])\n",
    "\n",
    "#The total time and dt::\n",
    "T = 20\n",
    "dt = 0.005\n",
    "#Other time-related variables related to these two:\n",
    "Nt = round(T/dt)\n",
    "sqrt_dt = np.sqrt(dt)\n",
    "TimeRange = np.arange(0,T,dt)\n",
    "# #This is to calculate the dynamic threshold moving average:\n",
    "# timeBase = 2*int(Nt/100)\n",
    "# #Time to plot utility against:\n",
    "# time_trunc = TimeRange[int((timeBase/2)-1):-int(timeBase/2)]\n",
    "\n",
    "#Let's call num_traj the number of trajectories:\n",
    "num_traj = 1000\n",
    "\n",
    "#The initial conditions:\n",
    "x0 = np.zeros((2,num_traj))\n",
    "#Fixed initial bias:\n",
    "init_bias = 0\n",
    "x0[0,:] = init_bias*np.ones(num_traj)\n",
    "\n",
    "#The threshold above which we say x_i is high:\n",
    "thresh = np.array([0.8,0.8])\n",
    "#The stability threshold; a trajectory has to stay above this:\n",
    "stability_thresh = 0.9\n",
    "\n",
    "#A minimum tolerance:\n",
    "eps = 1e-6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "70ced77d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Self-activation:\n",
    "@jit(nopython=True)\n",
    "def activation(x,a,n,theta):\n",
    "    if (x>=0):\n",
    "        return (a*x**n)/(x**n + theta**n)\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "#Cross-inhibition\n",
    "@jit(nopython=True)\n",
    "def repression(x,r,n,theta):\n",
    "    if (x>0):\n",
    "        return (r*theta**n)/(x**n + theta**n)\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "#Bias (for external signals):\n",
    "@jit(nopython=True)\n",
    "def ext_bias(x1,x2,t):\n",
    "#     return (x1-x2,x2-x1)\n",
    "    temp = 0\n",
    "    return (temp,0)\n",
    "    \n",
    "#This solves the system fwd using simple Euler-Maruyama:\n",
    "@jit(nopython=True)\n",
    "def Solver(initial,a,r,k,n,theta,alpha):\n",
    "    final = np.empty((2,num_traj,Nt))\n",
    "    final[:,:,0] = initial\n",
    "    #Solving the system forward in time:\n",
    "    for i in range(num_traj):\n",
    "        for t in range(1,Nt):\n",
    "            #Equation for first species:\n",
    "            temp = np.sqrt(np.maximum(final[0,i,t-1],0.01))\n",
    "            noise = rand.normalvariate(0,alpha[0]*temp)\n",
    "            final[0,i,t] = final[0,i,t-1] + dt*(activation(final[0,i,t-1],a[0],n[0,0],theta[0,0]) \\\n",
    "                                               + repression(final[1,i,t-1],r[0],n[1,0],theta[1,0]) \\\n",
    "                                               - k[0]*final[0,i,t-1] + ext_bias(final[0,i,t-1],final[1,i,t-1],t)[0]) \\\n",
    "                                                + sqrt_dt*noise\n",
    "            #Equation for second:\n",
    "            temp = np.sqrt(np.maximum(final[1,i,t-1],0.01))\n",
    "            noise = rand.normalvariate(0,alpha[1]*temp)\n",
    "            final[1,i,t] = final[1,i,t-1] + dt*(activation(final[1,i,t-1],a[1],n[1,1],theta[1,1]) \\\n",
    "                                               + repression(final[0,i,t-1],r[1],n[0,1],theta[0,1]) \\\n",
    "                                               - k[1]*final[1,i,t-1] + ext_bias(final[0,i,t-1],final[1,i,t-1],t)[1]) \\\n",
    "                                                + sqrt_dt*noise\n",
    "    return final\n",
    "\n",
    "#This solves the system fwd using simple Euler-Maruyama:\n",
    "@jit(nopython=True)\n",
    "def Solver_dynamic_a_and_r(initial,a_dyn,r_dyn,k,n,theta,alpha):\n",
    "    final = np.empty((2,num_traj,Nt))\n",
    "    final[:,:,0] = initial\n",
    "    #Solving the system forward in time:\n",
    "    for i in range(num_traj):\n",
    "        for t in range(1,Nt):\n",
    "            #Setting the dynamic coefficients of auto-activation and cross-repression:\n",
    "            a = a_dyn[t,:]\n",
    "            r = r_dyn[t,:]\n",
    "            #Equation for first species:\n",
    "            temp = np.sqrt(np.maximum(final[0,i,t-1],0.01))\n",
    "            noise = rand.normalvariate(0,alpha[0]*temp)\n",
    "            final[0,i,t] = final[0,i,t-1] + dt*(activation(final[0,i,t-1],a[0],n[0,0],theta[0,0]) \\\n",
    "                                               + repression(final[1,i,t-1],r[0],n[1,0],theta[1,0]) \\\n",
    "                                               - k[0]*final[0,i,t-1] + ext_bias(final[0,i,t-1],final[1,i,t-1],t)[0]) \\\n",
    "                                                + sqrt_dt*noise\n",
    "            #Equation for second:\n",
    "            temp = np.sqrt(np.maximum(final[1,i,t-1],0.01))\n",
    "            noise = rand.normalvariate(0,alpha[1]*temp)\n",
    "            final[1,i,t] = final[1,i,t-1] + dt*(activation(final[1,i,t-1],a[1],n[1,1],theta[1,1]) \\\n",
    "                                               + repression(final[0,i,t-1],r[1],n[0,1],theta[0,1]) \\\n",
    "                                               - k[1]*final[1,i,t-1] + ext_bias(final[0,i,t-1],final[1,i,t-1],t)[1]) \\\n",
    "                                                + sqrt_dt*noise\n",
    "    return final\n",
    "\n",
    "#Classifier:\n",
    "# @jit(nopython=True)\n",
    "def fate_classifier(traj):\n",
    "    #Stability factor of trajectories:\n",
    "    cross_flags = np.zeros((2,num_traj))\n",
    "    cross_times = np.ones((2,num_traj))*Nt\n",
    "    for axis_idx in range(2):\n",
    "        #Axis crossings:\n",
    "        for traj_idx in range(num_traj):\n",
    "            if (np.size(np.where(traj[axis_idx,traj_idx]>thresh[axis_idx])[0]) != 0):\n",
    "                cross_flags[axis_idx,traj_idx] = 1\n",
    "                cross_times[axis_idx,traj_idx] = np.where(traj[axis_idx,traj_idx]>thresh[axis_idx])[0][0]\n",
    "                    \n",
    "    #Stability factor: after the threshold is crossed, how much time the traj spends above it:\n",
    "    stability_factrs = np.zeros((2,num_traj))\n",
    "    for axis_idx in range(2):\n",
    "        for traj_idx in range(num_traj):\n",
    "#             if (cross_flags[axis_idx,traj_idx]==0):\n",
    "#                 stability_factrs[axis_idx,traj_idx] = -1\n",
    "            if (cross_flags[axis_idx,traj_idx]==1):\n",
    "                stability_factrs[axis_idx,traj_idx] = np.sum(traj[axis_idx,traj_idx,int(cross_times[axis_idx,traj_idx]):]>thresh[axis_idx])\\\n",
    "                /len(traj[axis_idx,traj_idx,int(cross_times[axis_idx,traj_idx]):])\n",
    "    \n",
    "    #Stability threshold - trajectories that spend more than this above the concentration threshold are considered committed:\n",
    "#     stability_thresh = 0.8\n",
    "    #Classifying fates:\n",
    "    fates = np.zeros((2,num_traj))\n",
    "    for axis_idx in range(2):\n",
    "        for traj_idx in range(num_traj):\n",
    "            if (cross_times[axis_idx,traj_idx]<=int(Nt/2) and stability_factrs[axis_idx,traj_idx]>=stability_thresh):\n",
    "                fates[axis_idx,traj_idx]=1\n",
    "                \n",
    "    return stability_factrs,fates\n",
    "\n",
    "def fate_fractions(fates):\n",
    "    #Initializing:\n",
    "    fate_frax = np.zeros(4)\n",
    "    fate_frax[0] = np.sum((fates[0]==0) & (fates[1]==0))/num_traj\n",
    "    fate_frax[1] = np.sum((fates[0]==1) & (fates[1]==0))/num_traj\n",
    "    fate_frax[2] = np.sum((fates[0]==0) & (fates[1]==1))/num_traj\n",
    "    fate_frax[3] = np.sum((fates[0]==1) & (fates[1]==1))/num_traj\n",
    "    \n",
    "    return fate_frax\n",
    "\n",
    "def traj_moments(traj,fates):\n",
    "    #Finding the fate fractions first:\n",
    "    fate_frax = fate_fractions(fates)\n",
    "    \n",
    "    #Flags, if fate_frac is zero for a fate then no avg or std is calculated:\n",
    "    fate_flags = np.array([False for i in range(4)])\n",
    "    \n",
    "    #Flag = True if that fate exists in the population:\n",
    "    for fate_idx in range(4):\n",
    "        if (fate_frax[fate_idx] != 0):\n",
    "            fate_flags[fate_idx] = True\n",
    "            \n",
    "    #Average trajectories and standard deviation around them:\n",
    "    avg_traj = np.zeros((4,2,Nt))\n",
    "    std_traj = np.zeros((4,2,Nt))\n",
    "    \n",
    "    if (fate_flags[0]==True):\n",
    "        avg_traj[0,:,:] = np.mean(traj[:,(fates[0]==0) & (fates[1]==0),:],axis=1)\n",
    "        std_traj[0,:,:] = np.std(traj[:,(fates[0]==0) & (fates[1]==0),:],axis=1)\n",
    "\n",
    "    if (fate_flags[1]==True):\n",
    "        avg_traj[1,:,:] = np.mean(traj[:,(fates[0]==1) & (fates[1]==0),:],axis=1)\n",
    "        std_traj[1,:,:] = np.std(traj[:,(fates[0]==1) & (fates[1]==0),:],axis=1)\n",
    "\n",
    "    if (fate_flags[2]==True):\n",
    "        avg_traj[2,:,:] = np.mean(traj[:,(fates[0]==0) & (fates[1]==1),:],axis=1)\n",
    "        std_traj[2,:,:] = np.std(traj[:,(fates[0]==0) & (fates[1]==1),:],axis=1)\n",
    "\n",
    "    if (fate_flags[3]==True):\n",
    "        avg_traj[3,:,:] = np.mean(traj[:,(fates[0]==1) & (fates[1]==1),:],axis=1)\n",
    "        std_traj[3,:,:] = np.std(traj[:,(fates[0]==1) & (fates[1]==1),:],axis=1)\n",
    "        \n",
    "    return (avg_traj,std_traj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "25c1249f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# #The dynamic a and r:\n",
    "# a_dyn = np.zeros((len(TimeRange),2))\n",
    "# r_dyn = np.zeros((len(TimeRange),2))\n",
    "\n",
    "# #Exponentially falling a and rising r:\n",
    "# a_dyn[0,:] = a\n",
    "# r_dyn[0,:] = r\n",
    "\n",
    "# a_dyn = np.array([[np.exp(-t),np.exp(-t)] for t in TimeRange])\n",
    "# r_dyn = np.array(a+r - a_dyn)\n",
    "\n",
    "# plt.plot(TimeRange,a_dyn[:,0],label=r\"self-activation $a(t)$\")\n",
    "# plt.plot(TimeRange,r_dyn[:,0],label=r\"cross-repression $r(t)$\")\n",
    "# plt.legend(loc=\"best\",fontsize=12)\n",
    "# plt.xlabel(r\"Time $t$\",fontsize=18)\n",
    "# plt.ylabel(r\"$a(t)$ and $r(t)$\",fontsize=18)\n",
    "# plt.title(\"Self-act., cross-rep. vs. time\",fontsize=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b72c0261",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 0.6218605041503906 s.\n"
     ]
    }
   ],
   "source": [
    "#Let's try the dynamic a and r:\n",
    "#Initial condition:\n",
    "x0 = np.zeros((2,num_traj))\n",
    "#Fixed initial bias:\n",
    "init_bias = 0.2\n",
    "x0[0,:] = init_bias*np.ones(num_traj)\n",
    "# #Biased start:\n",
    "# x0[0,:] = 0.1\n",
    "# x0[1,:] = 0.1\n",
    "\n",
    "#First half:\n",
    "# x0[0,0:round(num_traj/2)] = 1.5\n",
    "# x0[1,0:round(num_traj/2)] = 0.5\n",
    "# #Second half:\n",
    "# x0[0,round(num_traj/2):] = 0.5\n",
    "# x0[1,round(num_traj/2):] = 1.5\n",
    "\n",
    "# #Uniform start:\n",
    "# x0[0,:] = np.random.uniform(low=0,high=2,size=num_traj)\n",
    "# x0[1,:] = np.random.uniform(low=0,high=2,size=num_traj)\n",
    "\n",
    "\n",
    "#Generating some trajectories:\n",
    "start_time = time.time()\n",
    "traj_simple = np.empty((2,num_traj,Nt))\n",
    "traj_simple = Solver(x0,a,r,k,n,theta,alpha)\n",
    "end_time = time.time()\n",
    "loop_time = end_time - start_time\n",
    "print(f\"Time taken: {loop_time} s.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d71570bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.98702796 0.98294183 ... 0.99629524 1.         0.98551128]\n",
      " [0.         0.         0.         ... 0.         0.         0.        ]]\n",
      "(4, 2, 4000)\n",
      "[0.002 0.989 0.009 0.   ]\n"
     ]
    }
   ],
   "source": [
    "#Now testing the fates and stability factors:\n",
    "stability_factrs,fates = fate_classifier(traj_simple)\n",
    "fate_frax = fate_fractions(fates)\n",
    "avg_traj,std_traj = traj_moments(traj_simple,fates)\n",
    "#Fate fractions:\n",
    "print(stability_factrs)\n",
    "print(np.shape(avg_traj))\n",
    "print(fate_frax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ccd3a199",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Defining our grid points and making the grid:\n",
    "x = np.arange(0, 1.5*(a[0]+r[0]), 0.1)\n",
    "y = np.arange(0, 1.5*(a[1]+r[1]), 0.1)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "#The velocity field:\n",
    "x_dot = (a[0]*X**n[0,0])/(X**n[0,0] + theta[0,0]**n[0,0]) + (r[0]*theta[1,0]**n[1,0])/(Y**n[1,0] + theta[1,0]**n[1,0]) - k[0]*X\n",
    "y_dot = (a[1]*Y**n[1,1])/(Y**n[1,1] + theta[1,1]**n[1,1]) + (r[1]*theta[0,1]**n[0,1])/(X**n[0,1] + theta[0,1]**n[0,1]) - k[1]*Y\n",
    " \n",
    "# creating plot\n",
    "fig, ax = plt.subplots(figsize =(5, 5))\n",
    "ax.quiver(X, Y, x_dot, y_dot)\n",
    "#Diagonal:\n",
    "ax.plot([0, 1],[0, 1],transform=ax.transAxes,color='k',ls=':')\n",
    "#Thresholds:\n",
    "ax.axvline(thresh[0],color='k',ls=':')\n",
    "ax.axhline(thresh[1],color='k',ls=':')\n",
    "\n",
    "#Total state space visited, all:\n",
    "# ax.scatter(traj_simple[0,(fates[0]==0)&(fates[1]==0),:],traj_simple[1,(fates[0]==0)&(fates[1]==0),:],color=CB_colors[0],marker=\"o\",alpha=0.01,rasterized=True)\n",
    "ax.scatter(traj_simple[0,(fates[0]==1)&(fates[1]==0),:],traj_simple[1,(fates[0]==1)&(fates[1]==0),:],color=CB_colors[1],marker=\"o\",alpha=0.01,rasterized=True)\n",
    "ax.scatter(traj_simple[0,(fates[0]==0)&(fates[1]==1),:],traj_simple[1,(fates[0]==0)&(fates[1]==1),:],color=CB_colors[2],marker=\"o\",alpha=0.01,rasterized=True)\n",
    "ax.scatter(traj_simple[0,(fates[0]==1)&(fates[1]==1),:],traj_simple[1,(fates[0]==1)&(fates[1]==1),:],color=CB_colors[3],marker=\"o\",alpha=0.01,rasterized=True)\n",
    "\n",
    "# #Total state space visited, first points:\n",
    "# ax.scatter(traj_simple[0,(fates[0]==0)&(fates[1]==0),0],traj_simple[1,(fates[0]==0)&(fates[1]==0),0],color=CB_colors[0],marker=\"o\",alpha=1)\n",
    "# ax.scatter(traj_simple[0,(fates[0]==1)&(fates[1]==0),0],traj_simple[1,(fates[0]==1)&(fates[1]==0),0],color=CB_colors[1],marker=\"o\",alpha=1)\n",
    "# ax.scatter(traj_simple[0,(fates[0]==0)&(fates[1]==1),0],traj_simple[1,(fates[0]==0)&(fates[1]==1),0],color=CB_colors[2],marker=\"o\",alpha=1)\n",
    "# ax.scatter(traj_simple[0,(fates[0]==1)&(fates[1]==1),0],traj_simple[1,(fates[0]==1)&(fates[1]==1),0],color=CB_colors[3],marker=\"o\",alpha=1) \n",
    "\n",
    "# # Total state space visited, final points:\n",
    "# ax.scatter(traj_simple[0,(fates[0]==0)&(fates[1]==0),-1],traj_simple[1,(fates[0]==0)&(fates[1]==0),-1],color=CB_colors[0],marker=\"o\",alpha=.5,rasterized=True)\n",
    "# ax.scatter(traj_simple[0,(fates[0]==1)&(fates[1]==0),-1],traj_simple[1,(fates[0]==1)&(fates[1]==0),-1],color=CB_colors[1],marker=\"o\",alpha=.5,rasterized=True)\n",
    "# ax.scatter(traj_simple[0,(fates[0]==0)&(fates[1]==1),-1],traj_simple[1,(fates[0]==0)&(fates[1]==1),-1],color=CB_colors[2],marker=\"o\",alpha=.5,rasterized=True)\n",
    "# ax.scatter(traj_simple[0,(fates[0]==1)&(fates[1]==1),-1],traj_simple[1,(fates[0]==1)&(fates[1]==1),-1],color=CB_colors[3],marker=\"o\",alpha=.5,rasterized=True) \n",
    "\n",
    "# # Average trajectory of each class:\n",
    "# ax.plot(avg_traj[0,0,:],avg_traj[0,1,:],color=CB_colors[0],marker=\".\",alpha=0.1)\n",
    "\n",
    "# ax.plot(avg_traj[1,0,:]-std_traj[1,0,:],avg_traj[1,1,:]-std_traj[1,1,:],color=CB_colors[1],ls=\"--\")\n",
    "# ax.plot(avg_traj[1,0,:],avg_traj[1,1,:],color=CB_colors[1],ls=\"-\")\n",
    "# ax.plot(avg_traj[1,0,:]+std_traj[1,0,:],avg_traj[1,1,:]+std_traj[1,1,:],color=CB_colors[1],ls=\"--\")\n",
    "\n",
    "# ax.plot(avg_traj[2,0,:]-std_traj[2,0,:],avg_traj[2,1,:]-std_traj[2,1,:],color=CB_colors[2],ls=\"--\")\n",
    "# ax.plot(avg_traj[2,0,:],avg_traj[2,1,:],color=CB_colors[2],ls=\"-\")\n",
    "# ax.plot(avg_traj[2,0,:]+std_traj[2,0,:],avg_traj[2,1,:]+std_traj[2,1,:],color=CB_colors[2],ls=\"--\")\n",
    "\n",
    "# ax.plot(avg_traj[3,0,:]-std_traj[3,0,:],avg_traj[3,1,:]-std_traj[3,1,:],color=CB_colors[3],ls=\"--\")\n",
    "# ax.plot(avg_traj[3,0,:],avg_traj[3,1,:],color=CB_colors[3],ls=\"-\")\n",
    "# ax.plot(avg_traj[3,0,:]+std_traj[3,0,:],avg_traj[3,1,:]+std_traj[3,1,:],color=CB_colors[3],ls=\"--\")\n",
    "\n",
    "# ax.plot(avg_traj[2,0,:],avg_traj[2,1,:],color=CB_colors[2],marker=\".\",alpha=0.1)\n",
    "# ax.plot(avg_traj[3,0,:],avg_traj[3,1,:],color=CB_colors[3],marker=\".\",alpha=0.1)\n",
    "\n",
    "# ax.xaxis.set_ticks([])\n",
    "# ax.yaxis.set_ticks([])\n",
    "# ax.axis([-0.3, 2.3, -0.3, 2.3])\n",
    "\n",
    "# #Location of stable fixed points and saddle (theta=0.2):\n",
    "# ax.scatter(0.0016,1,s=100,c='k',marker='o')\n",
    "# ax.scatter(1,0.0016,s=100,c='k',marker='o')\n",
    "# ax.scatter(0.2598,0.2598,s=100,c='k',marker='X')\n",
    "\n",
    "#Location of stable fixed points and saddle (theta=0.5):\n",
    "ax.scatter(0.0589,0.9998,s=100,c='k',marker='o')\n",
    "ax.scatter(0.9998,0.0589,s=100,c='k',marker='o')\n",
    "ax.scatter(0.5,0.5,s=100,c='k',marker='X')\n",
    "\n",
    "# #Location of stable fixed points and saddle (theta=0.8):\n",
    "# ax.scatter(0.3091,0.9782,s=100,c='k',marker='o')\n",
    "# ax.scatter(0.9782,0.3091,s=100,c='k',marker='o')\n",
    "# ax.scatter(0.6701,0.6701,s=100,c='k',marker='X')\n",
    "\n",
    "#Axis labels and theta:\n",
    "ax.set_xlabel(r\"Marker (coordinate) $x$\", fontsize=18)\n",
    "ax.set_ylabel(r\"Marker (coordinate) $y$\", fontsize=18)\n",
    "ax.set_title(fr\"Initial bias $\\delta_x = 0.2$\",fontsize=20)\n",
    "\n",
    "ax.set_aspect('equal')\n",
    " \n",
    "# # show plot\n",
    "# plt.show()\n",
    "\n",
    "plt.savefig(f\"31102022_FATES_initial_x_bias={init_bias}.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3595559",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}