diff --git a/convergence_test.ipynb b/convergence_test.ipynb
new file mode 100644
index 00000000000..adaf3a1910f
--- /dev/null
+++ b/convergence_test.ipynb
@@ -0,0 +1,1121 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setting up and running the TARDIS example simulation "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tardis.base import run_tardis\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import logging\n",
+    "import time\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d8df4fb6a2b14601ae1641d20ab5c96e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d8eb68745d68421592fe03b32b9b1431",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6c1305d32b844d409cd7e1a20e763647",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fb9c6396421f42b884947b77ca5c1be9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f23f2b83b7ca48af9268a077ff7a5d8a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "71b00aae94d24fc0b1f18800ed66024f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'dcac35b5-d849-442a-ac0c-63973591b560', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$[[10952.632,~11065.297,~11146.836,~11168.511,~11162.763,~11173.84,~11125.281,~11103.504,~11057.896,~10982.173,~10916.747,~10853.869,~10797.786,~10741.666,~10657.186,~10579.633,~10512.265,~10442,~10359.229,~10257.681],~\n",
+       " [10974.414,~11079.825,~11155.414,~11184.452,~11180.51,~11186.08,~11145.732,~11121.478,~11075.743,~10993.74,~10924.911,~10853.816,~10798.874,~10731.344,~10658.819,~10581.855,~10513.57,~10441.748,~10359.804,~10261.247]] \\; \\mathrm{K}$"
+      ],
+      "text/plain": [
+       "<Quantity [[10952.63231877, 11065.29655507, 11146.8359289 ,\n",
+       "            11168.51126187, 11162.76266113, 11173.84014227,\n",
+       "            11125.28131485, 11103.5044254 , 11057.89578328,\n",
+       "            10982.17284381, 10916.74656888, 10853.86934121,\n",
+       "            10797.7863424 , 10741.66583036, 10657.1863048 ,\n",
+       "            10579.63315852, 10512.26505999, 10441.9998283 ,\n",
+       "            10359.22941609, 10257.68110852],\n",
+       "           [10974.413526  , 11079.82475989, 11155.4144222 ,\n",
+       "            11184.4515512 , 11180.5101573 , 11186.08014564,\n",
+       "            11145.73248128, 11121.47797056, 11075.74310553,\n",
+       "            10993.74039084, 10924.91062725, 10853.81618167,\n",
+       "            10798.87369014, 10731.34443456, 10658.81913311,\n",
+       "            10581.85516831, 10513.56980191, 10441.74819424,\n",
+       "            10359.80427222, 10261.24669165]] K>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sim.iterations_t_rad[-2:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 19 values: [10952.63231877 11065.29655507 11146.8359289  11168.51126187\n",
+      " 11162.76266113 11173.84014227 11125.28131485 11103.5044254\n",
+      " 11057.89578328 10982.17284381 10916.74656888 10853.86934121\n",
+      " 10797.7863424  10741.66583036 10657.1863048  10579.63315852\n",
+      " 10512.26505999 10441.9998283  10359.22941609 10257.68110852] K\n",
+      "Iteration 20 values: [10974.413526   11079.82475989 11155.4144222  11184.4515512\n",
+      " 11180.5101573  11186.08014564 11145.73248128 11121.47797056\n",
+      " 11075.74310553 10993.74039084 10924.91062725 10853.81618167\n",
+      " 10798.87369014 10731.34443456 10658.81913311 10581.85516831\n",
+      " 10513.56980191 10441.74819424 10359.80427222 10261.24669165] K\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "for i, iteration in enumerate(last_two_shells, start=19):\n",
+    "    print(f\"Iteration {i} values: {iteration}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.20%\n",
+      "T_rad 1: 0.13%\n",
+      "T_rad 2: 0.08%\n",
+      "T_rad 3: 0.14%\n",
+      "T_rad 4: 0.16%\n",
+      "T_rad 5: 0.11%\n",
+      "T_rad 6: 0.18%\n",
+      "T_rad 7: 0.16%\n",
+      "T_rad 8: 0.16%\n",
+      "T_rad 9: 0.11%\n",
+      "T_rad 10: 0.07%\n",
+      "T_rad 11: -0.00%\n",
+      "T_rad 12: 0.01%\n",
+      "T_rad 13: -0.10%\n",
+      "T_rad 14: 0.02%\n",
+      "T_rad 15: 0.02%\n",
+      "T_rad 16: 0.01%\n",
+      "T_rad 17: -0.00%\n",
+      "T_rad 18: 0.01%\n",
+      "T_rad 19: 0.03%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c949d2c71b8e4519a6a81aeb98b5c267",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "958762d98764479e94b8c21455bb17b5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2383cb004dbc4d1b9d0399a7c8d36f72",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b6eae0b1de93465f9f0e29146e3d16d9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7f7d830f225c40b48359493ced2af76f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1b4c73cf0f4a4627b0add147dbde4df7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'a30f7fcc-812d-44bb-bd9c-3ede2a772809', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.01%\n",
+      "T_rad 1: -0.17%\n",
+      "T_rad 2: -0.07%\n",
+      "T_rad 3: 0.23%\n",
+      "T_rad 4: 0.10%\n",
+      "T_rad 5: 0.01%\n",
+      "T_rad 6: 0.05%\n",
+      "T_rad 7: 0.01%\n",
+      "T_rad 8: 0.27%\n",
+      "T_rad 9: 0.17%\n",
+      "T_rad 10: -0.03%\n",
+      "T_rad 11: 0.03%\n",
+      "T_rad 12: -0.03%\n",
+      "T_rad 13: -0.13%\n",
+      "T_rad 14: -0.24%\n",
+      "T_rad 15: -0.23%\n",
+      "T_rad 16: -0.12%\n",
+      "T_rad 17: 0.04%\n",
+      "T_rad 18: -0.02%\n",
+      "T_rad 19: 0.02%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.396)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "32621d06000a4e25880aa11044515349",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0908202c86a241449b64efeb0e920154",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "95f6246e3c904e98b20b10e8cb1bfdbd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f3b84d6e4d6d4f849246949f85061d33",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b6c12a016e5426b8e32b2647f440e9b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fad05a8f484748449a3329cbd6788abe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '43d26906-2e85-454d-b0e9-32e763719c76', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e6a2bbf56e634c77a9d21e21f482bd6e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3f88443c37ab4ede9b24a39e94969ccc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4f86cacdc27e43d494911667f4671db6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d9545a6c6c64418e838cb4bf174632ca",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e59434c0485c4d99bf41b951d78e752d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "33d17119baa54b86a109cccd90932c5a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '9fd7a044-c95c-4b15-8e01-8506c23617e3', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.11%\n",
+      "T_rad 1: -0.19%\n",
+      "T_rad 2: -0.08%\n",
+      "T_rad 3: 0.31%\n",
+      "T_rad 4: 0.29%\n",
+      "T_rad 5: 0.13%\n",
+      "T_rad 6: 0.51%\n",
+      "T_rad 7: 0.13%\n",
+      "T_rad 8: 0.10%\n",
+      "T_rad 9: 0.03%\n",
+      "T_rad 10: -0.18%\n",
+      "T_rad 11: -0.32%\n",
+      "T_rad 12: -0.42%\n",
+      "T_rad 13: -0.30%\n",
+      "T_rad 14: -0.34%\n",
+      "T_rad 15: -0.18%\n",
+      "T_rad 16: -0.24%\n",
+      "T_rad 17: 0.07%\n",
+      "T_rad 18: -0.06%\n",
+      "T_rad 19: -0.16%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a3b4290bbcea4e41b75dcc904d72bfbe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c364fc866be94d43ae671c74955e432f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "812805311026488bb656de1f88dd306a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a3b44c38ae7e4f85ab7fa45697af823b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "30486008bb574212a698dc47e2374da8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b858c397c7744ccfb5806e4f041e3a75",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'edde9180-7340-4479-83af-293daca53a6d', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.13%\n",
+      "T_rad 1: -0.14%\n",
+      "T_rad 2: 0.06%\n",
+      "T_rad 3: -0.01%\n",
+      "T_rad 4: 0.04%\n",
+      "T_rad 5: -0.10%\n",
+      "T_rad 6: 0.17%\n",
+      "T_rad 7: 0.02%\n",
+      "T_rad 8: -0.12%\n",
+      "T_rad 9: -0.11%\n",
+      "T_rad 10: 0.06%\n",
+      "T_rad 11: -0.09%\n",
+      "T_rad 12: 0.11%\n",
+      "T_rad 13: -0.28%\n",
+      "T_rad 14: -0.23%\n",
+      "T_rad 15: -0.09%\n",
+      "T_rad 16: -0.37%\n",
+      "T_rad 17: -0.29%\n",
+      "T_rad 18: -0.24%\n",
+      "T_rad 19: -0.30%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ae7ea6d9d02a4cc78621df4a29767958",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b99f871794f54f938ce6a70350ee3eed",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "127f29faa9d748d19d0cf1af2c00d658",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'bc7066d1-2bb6-4ab9-a39e-e65dd1230c1b', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.12%\n",
+      "T_rad 1: 0.07%\n",
+      "T_rad 2: 0.05%\n",
+      "T_rad 3: 0.07%\n",
+      "T_rad 4: 0.10%\n",
+      "T_rad 5: 0.11%\n",
+      "T_rad 6: 0.25%\n",
+      "T_rad 7: 0.23%\n",
+      "T_rad 8: 0.23%\n",
+      "T_rad 9: 0.12%\n",
+      "T_rad 10: 0.05%\n",
+      "T_rad 11: -0.09%\n",
+      "T_rad 12: -0.04%\n",
+      "T_rad 13: -0.11%\n",
+      "T_rad 14: -0.01%\n",
+      "T_rad 15: -0.00%\n",
+      "T_rad 16: -0.01%\n",
+      "T_rad 17: 0.09%\n",
+      "T_rad 18: 0.01%\n",
+      "T_rad 19: -0.05%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.45)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "06a2c6460dab465a9cb8147f6a397dc5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "94cf6cbeed034aeeae1accb03af87496",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c887490aa65a4d13bafd69a7445a0905",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '1dc380cc-f7a1-4def-95f4-2f5979793966', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.06%\n",
+      "T_rad 1: -0.18%\n",
+      "T_rad 2: -0.07%\n",
+      "T_rad 3: 0.12%\n",
+      "T_rad 4: 0.04%\n",
+      "T_rad 5: -0.00%\n",
+      "T_rad 6: 0.09%\n",
+      "T_rad 7: -0.08%\n",
+      "T_rad 8: -0.12%\n",
+      "T_rad 9: 0.05%\n",
+      "T_rad 10: -0.13%\n",
+      "T_rad 11: -0.30%\n",
+      "T_rad 12: -0.17%\n",
+      "T_rad 13: -0.24%\n",
+      "T_rad 14: -0.17%\n",
+      "T_rad 15: -0.20%\n",
+      "T_rad 16: -0.31%\n",
+      "T_rad 17: -0.16%\n",
+      "T_rad 18: -0.26%\n",
+      "T_rad 19: -0.29%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "tardis",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/quickstart.ipynb b/docs/quickstart.ipynb
index da65fc1fb1b..8d6441b6c4a 100644
--- a/docs/quickstart.ipynb
+++ b/docs/quickstart.ipynb
@@ -116,7 +116,7 @@
     "sim = run_tardis(\"tardis_example.yml\", \n",
     "                 virtual_packet_logging=True,\n",
     "                 show_convergence_plots=True,\n",
-    "                 export_convergence_plots=True,\n",
+    "                 export_convergence_plots=False, #TODO: to avoid double plots\n",
     "                 log_level=\"INFO\") "
    ]
   },
diff --git a/scratchfile that works.ipynb b/scratchfile that works.ipynb
new file mode 100644
index 00000000000..98b230a9712
--- /dev/null
+++ b/scratchfile that works.ipynb	
@@ -0,0 +1,2016 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setting up and running the TARDIS example simulation "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tardis.base import run_tardis\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import logging\n",
+    "import time\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0205857eaa154ad2bca4ea04802cbb45",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "198191cf6b1b49a1824c271c461af39c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "efda4a398b3d4a38be23335aee679000",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "96ad185c04b1488c8482f5b64ef6739e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "833e115ba342410b8998fab731e9450d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a5a91f3ab3654f7c90e542d51bf507f1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '37c8e66d-f827-4dbd-8af2-7d2b87798a65', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$[[10952.632,~11065.297,~11146.836,~11168.511,~11162.763,~11173.84,~11125.281,~11103.504,~11057.896,~10982.173,~10916.747,~10853.869,~10797.786,~10741.666,~10657.186,~10579.633,~10512.265,~10442,~10359.229,~10257.681],~\n",
+       " [10974.414,~11079.825,~11155.414,~11184.452,~11180.51,~11186.08,~11145.732,~11121.478,~11075.743,~10993.74,~10924.911,~10853.816,~10798.874,~10731.344,~10658.819,~10581.855,~10513.57,~10441.748,~10359.804,~10261.247]] \\; \\mathrm{K}$"
+      ],
+      "text/plain": [
+       "<Quantity [[10952.63231877, 11065.29655507, 11146.8359289 ,\n",
+       "            11168.51126187, 11162.76266113, 11173.84014227,\n",
+       "            11125.28131485, 11103.5044254 , 11057.89578328,\n",
+       "            10982.17284381, 10916.74656888, 10853.86934121,\n",
+       "            10797.7863424 , 10741.66583036, 10657.1863048 ,\n",
+       "            10579.63315852, 10512.26505999, 10441.9998283 ,\n",
+       "            10359.22941609, 10257.68110852],\n",
+       "           [10974.413526  , 11079.82475989, 11155.4144222 ,\n",
+       "            11184.4515512 , 11180.5101573 , 11186.08014564,\n",
+       "            11145.73248128, 11121.47797056, 11075.74310553,\n",
+       "            10993.74039084, 10924.91062725, 10853.81618167,\n",
+       "            10798.87369014, 10731.34443456, 10658.81913311,\n",
+       "            10581.85516831, 10513.56980191, 10441.74819424,\n",
+       "            10359.80427222, 10261.24669165]] K>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sim.iterations_t_rad[-2:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 19 values: [10952.63231877 11065.29655507 11146.8359289  11168.51126187\n",
+      " 11162.76266113 11173.84014227 11125.28131485 11103.5044254\n",
+      " 11057.89578328 10982.17284381 10916.74656888 10853.86934121\n",
+      " 10797.7863424  10741.66583036 10657.1863048  10579.63315852\n",
+      " 10512.26505999 10441.9998283  10359.22941609 10257.68110852] K\n",
+      "Iteration 20 values: [10974.413526   11079.82475989 11155.4144222  11184.4515512\n",
+      " 11180.5101573  11186.08014564 11145.73248128 11121.47797056\n",
+      " 11075.74310553 10993.74039084 10924.91062725 10853.81618167\n",
+      " 10798.87369014 10731.34443456 10658.81913311 10581.85516831\n",
+      " 10513.56980191 10441.74819424 10359.80427222 10261.24669165] K\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "for i, iteration in enumerate(last_two_shells, start=19):\n",
+    "    print(f\"Iteration {i} values: {iteration}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.20%\n",
+      "T_rad 1: 0.13%\n",
+      "T_rad 2: 0.08%\n",
+      "T_rad 3: 0.14%\n",
+      "T_rad 4: 0.16%\n",
+      "T_rad 5: 0.11%\n",
+      "T_rad 6: 0.18%\n",
+      "T_rad 7: 0.16%\n",
+      "T_rad 8: 0.16%\n",
+      "T_rad 9: 0.11%\n",
+      "T_rad 10: 0.07%\n",
+      "T_rad 11: -0.00%\n",
+      "T_rad 12: 0.01%\n",
+      "T_rad 13: -0.10%\n",
+      "T_rad 14: 0.02%\n",
+      "T_rad 15: 0.02%\n",
+      "T_rad 16: 0.01%\n",
+      "T_rad 17: -0.00%\n",
+      "T_rad 18: 0.01%\n",
+      "T_rad 19: 0.03%\n"
+     ]
+    }
+   ],
+   "source": [
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c949d2c71b8e4519a6a81aeb98b5c267",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "958762d98764479e94b8c21455bb17b5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2383cb004dbc4d1b9d0399a7c8d36f72",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b6eae0b1de93465f9f0e29146e3d16d9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7f7d830f225c40b48359493ced2af76f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1b4c73cf0f4a4627b0add147dbde4df7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'a30f7fcc-812d-44bb-bd9c-3ede2a772809', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.01%\n",
+      "T_rad 1: -0.17%\n",
+      "T_rad 2: -0.07%\n",
+      "T_rad 3: 0.23%\n",
+      "T_rad 4: 0.10%\n",
+      "T_rad 5: 0.01%\n",
+      "T_rad 6: 0.05%\n",
+      "T_rad 7: 0.01%\n",
+      "T_rad 8: 0.27%\n",
+      "T_rad 9: 0.17%\n",
+      "T_rad 10: -0.03%\n",
+      "T_rad 11: 0.03%\n",
+      "T_rad 12: -0.03%\n",
+      "T_rad 13: -0.13%\n",
+      "T_rad 14: -0.24%\n",
+      "T_rad 15: -0.23%\n",
+      "T_rad 16: -0.12%\n",
+      "T_rad 17: 0.04%\n",
+      "T_rad 18: -0.02%\n",
+      "T_rad 19: 0.02%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### damping_constant=0.396"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "32621d06000a4e25880aa11044515349",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0908202c86a241449b64efeb0e920154",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "95f6246e3c904e98b20b10e8cb1bfdbd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f3b84d6e4d6d4f849246949f85061d33",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b6c12a016e5426b8e32b2647f440e9b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fad05a8f484748449a3329cbd6788abe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '43d26906-2e85-454d-b0e9-32e763719c76', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e6a2bbf56e634c77a9d21e21f482bd6e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3f88443c37ab4ede9b24a39e94969ccc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4f86cacdc27e43d494911667f4671db6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d9545a6c6c64418e838cb4bf174632ca",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e59434c0485c4d99bf41b951d78e752d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "33d17119baa54b86a109cccd90932c5a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '9fd7a044-c95c-4b15-8e01-8506c23617e3', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.11%\n",
+      "T_rad 1: -0.19%\n",
+      "T_rad 2: -0.08%\n",
+      "T_rad 3: 0.31%\n",
+      "T_rad 4: 0.29%\n",
+      "T_rad 5: 0.13%\n",
+      "T_rad 6: 0.51%\n",
+      "T_rad 7: 0.13%\n",
+      "T_rad 8: 0.10%\n",
+      "T_rad 9: 0.03%\n",
+      "T_rad 10: -0.18%\n",
+      "T_rad 11: -0.32%\n",
+      "T_rad 12: -0.42%\n",
+      "T_rad 13: -0.30%\n",
+      "T_rad 14: -0.34%\n",
+      "T_rad 15: -0.18%\n",
+      "T_rad 16: -0.24%\n",
+      "T_rad 17: 0.07%\n",
+      "T_rad 18: -0.06%\n",
+      "T_rad 19: -0.16%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aa303a886f144b4fbb0ab0b124b8409f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1df2905d2b6247e0abf3b0cb8bd912d6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b2e685f64e98430396e7bda5d63fcda6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "16607f8d0261412a815e1a6e3e5d5e6f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "964a2bf8b68a4af9b8e2c5416cd674b6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1fd4d357ba12450ab2eec9c3205de512",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'c8b48cd8-638a-44c5-9fa6-1552032cf38a', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.13%\n",
+      "T_rad 1: -0.14%\n",
+      "T_rad 2: 0.06%\n",
+      "T_rad 3: -0.01%\n",
+      "T_rad 4: 0.04%\n",
+      "T_rad 5: -0.10%\n",
+      "T_rad 6: 0.17%\n",
+      "T_rad 7: 0.02%\n",
+      "T_rad 8: -0.12%\n",
+      "T_rad 9: -0.11%\n",
+      "T_rad 10: 0.06%\n",
+      "T_rad 11: -0.09%\n",
+      "T_rad 12: 0.11%\n",
+      "T_rad 13: -0.28%\n",
+      "T_rad 14: -0.23%\n",
+      "T_rad 15: -0.09%\n",
+      "T_rad 16: -0.37%\n",
+      "T_rad 17: -0.29%\n",
+      "T_rad 18: -0.24%\n",
+      "T_rad 19: -0.30%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ae7ea6d9d02a4cc78621df4a29767958",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b99f871794f54f938ce6a70350ee3eed",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "127f29faa9d748d19d0cf1af2c00d658",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': 'bc7066d1-2bb6-4ab9-a39e-e65dd1230c1b', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.12%\n",
+      "T_rad 1: 0.07%\n",
+      "T_rad 2: 0.05%\n",
+      "T_rad 3: 0.07%\n",
+      "T_rad 4: 0.10%\n",
+      "T_rad 5: 0.11%\n",
+      "T_rad 6: 0.25%\n",
+      "T_rad 7: 0.23%\n",
+      "T_rad 8: 0.23%\n",
+      "T_rad 9: 0.12%\n",
+      "T_rad 10: 0.05%\n",
+      "T_rad 11: -0.09%\n",
+      "T_rad 12: -0.04%\n",
+      "T_rad 13: -0.11%\n",
+      "T_rad 14: -0.01%\n",
+      "T_rad 15: -0.00%\n",
+      "T_rad 16: -0.01%\n",
+      "T_rad 17: 0.09%\n",
+      "T_rad 18: 0.01%\n",
+      "T_rad 19: -0.05%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis of damped convergence iterations in TARDIS (0.45)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "06a2c6460dab465a9cb8147f6a397dc5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "94cf6cbeed034aeeae1accb03af87496",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c887490aa65a4d13bafd69a7445a0905",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '1dc380cc-f7a1-4def-95f4-2f5979793966', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\")  \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True, \n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between last two shells\n",
+      "T_rad 0: 0.06%\n",
+      "T_rad 1: -0.18%\n",
+      "T_rad 2: -0.07%\n",
+      "T_rad 3: 0.12%\n",
+      "T_rad 4: 0.04%\n",
+      "T_rad 5: -0.00%\n",
+      "T_rad 6: 0.09%\n",
+      "T_rad 7: -0.08%\n",
+      "T_rad 8: -0.12%\n",
+      "T_rad 9: 0.05%\n",
+      "T_rad 10: -0.13%\n",
+      "T_rad 11: -0.30%\n",
+      "T_rad 12: -0.17%\n",
+      "T_rad 13: -0.24%\n",
+      "T_rad 14: -0.17%\n",
+      "T_rad 15: -0.20%\n",
+      "T_rad 16: -0.31%\n",
+      "T_rad 17: -0.16%\n",
+      "T_rad 18: -0.26%\n",
+      "T_rad 19: -0.29%\n"
+     ]
+    }
+   ],
+   "source": [
+    "last_two_shells = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "differences = last_two_shells[1] - last_two_shells[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_shells[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between last two shells\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"T_rad {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Undamped convergence plots in TARDIS when we set damping_factor to 1.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f9099735e75244c7a4810c193897ed13",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "299eab8867404ad6bef3d99e2367a9e8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "94f7b6a8e22644d59577983f6a67e96d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "32c71e40300d4d188beb0d6f724d7383",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c464d3e0c1054126afb03813a6380f02",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "101b443ed7c44df884100a2963d1982c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '2ee8496f-2406-4431-99ce-deba8e691eb6', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plt.rcParams['text.usetex'] = True\n",
+    "#plt.rcParams['font.family'] = 'serif'\n",
+    "\n",
+    "os.chdir(\"/Users/deekshamohanty/tardis\") \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True,\n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 19 values: [11444.94537561 11607.53080072 11736.38794021 11767.62629371\n",
+      " 11726.46767424 11745.07650199 11720.10281735 11664.04363817\n",
+      " 11593.99527497 11532.16070069 11462.6778666  11328.26221745\n",
+      " 11298.11073554 11269.61067451 11199.15466931 11117.75602505\n",
+      " 10998.60002668 10867.17107014 10759.70220032 10688.11229821] K\n",
+      "Iteration 20 values: [10748.90193246 10927.8200971  10998.79113624 11102.00007216\n",
+      " 11124.69397086 11092.36545454 11109.20982059 11044.60079839\n",
+      " 11009.33979842 10974.32538709 10875.99873239 10711.88616652\n",
+      " 10639.11200499 10577.49595765 10546.67237506 10491.73931947\n",
+      " 10362.76140891 10233.36943785 10157.74597418 10052.60841091] K\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "\n",
+    "last_two_iterations = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "for i, iteration in enumerate(last_two_iterations, start=19):\n",
+    "    print(f\"Iteration {i} values: {iteration}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between Iteration 20 and 19:\n",
+      "Element 0: -6.08%\n",
+      "Element 1: -5.86%\n",
+      "Element 2: -6.28%\n",
+      "Element 3: -5.66%\n",
+      "Element 4: -5.13%\n",
+      "Element 5: -5.56%\n",
+      "Element 6: -5.21%\n",
+      "Element 7: -5.31%\n",
+      "Element 8: -5.04%\n",
+      "Element 9: -4.84%\n",
+      "Element 10: -5.12%\n",
+      "Element 11: -5.44%\n",
+      "Element 12: -5.83%\n",
+      "Element 13: -6.14%\n",
+      "Element 14: -5.83%\n",
+      "Element 15: -5.63%\n",
+      "Element 16: -5.78%\n",
+      "Element 17: -5.83%\n",
+      "Element 18: -5.59%\n",
+      "Element 19: -5.95%\n"
+     ]
+    }
+   ],
+   "source": [
+    "differences = last_two_iterations[1] - last_two_iterations[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_iterations[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between Iteration 20 and 19:\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"Element {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Undamped convergence plots in TARDIS when we set damping_factor to 0, change value->estimated_value (now it works)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "492c4b3cd91b437083d655b001dd4dde",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e3c3ae3aa2194169b5d6806c18084dd2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fe463d4737394af185c24cce3b9bb040",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6caf34141d9c47c1a970105f3b900f70",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9c0b7533892e4501b2f5d2cb2a0ef7d2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "32b84907986943f1b67cdc57c9b3f075",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '569fcd00-e5e3-458e-a9ad-636ff6896b22', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\") \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True,\n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 19 values: [11444.94537561 11607.53080072 11736.38794021 11767.62629371\n",
+      " 11726.46767424 11745.07650199 11720.10281735 11664.04363817\n",
+      " 11593.99527497 11532.16070069 11462.6778666  11328.26221745\n",
+      " 11298.11073554 11269.61067451 11199.15466931 11117.75602505\n",
+      " 10998.60002668 10867.17107014 10759.70220032 10688.11229821] K\n",
+      "Iteration 20 values: [10748.90193246 10927.8200971  10998.79113624 11102.00007216\n",
+      " 11124.69397086 11092.36545454 11109.20982059 11044.60079839\n",
+      " 11009.33979842 10974.32538709 10875.99873239 10711.88616652\n",
+      " 10639.11200499 10577.49595765 10546.67237506 10491.73931947\n",
+      " 10362.76140891 10233.36943785 10157.74597418 10052.60841091] K\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "\n",
+    "last_two_iterations = sim.iterations_t_rad[-2:]\n",
+    "\n",
+    "for i, iteration in enumerate(last_two_iterations, start=19):\n",
+    "    print(f\"Iteration {i} values: {iteration}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage differences between Iteration 20 and 19:\n",
+      "Element 0: -6.08%\n",
+      "Element 1: -5.86%\n",
+      "Element 2: -6.28%\n",
+      "Element 3: -5.66%\n",
+      "Element 4: -5.13%\n",
+      "Element 5: -5.56%\n",
+      "Element 6: -5.21%\n",
+      "Element 7: -5.31%\n",
+      "Element 8: -5.04%\n",
+      "Element 9: -4.84%\n",
+      "Element 10: -5.12%\n",
+      "Element 11: -5.44%\n",
+      "Element 12: -5.83%\n",
+      "Element 13: -6.14%\n",
+      "Element 14: -5.83%\n",
+      "Element 15: -5.63%\n",
+      "Element 16: -5.78%\n",
+      "Element 17: -5.83%\n",
+      "Element 18: -5.59%\n",
+      "Element 19: -5.95%\n"
+     ]
+    }
+   ],
+   "source": [
+    "differences = last_two_iterations[1] - last_two_iterations[0]\n",
+    "\n",
+    "percentage_differences = (differences / last_two_iterations[0]) * 100\n",
+    "\n",
+    "print(\"Percentage differences between Iteration 20 and 19:\")\n",
+    "for i, percentage_difference in enumerate(percentage_differences):\n",
+    "    print(f\"Element {i}: {percentage_difference:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Applying Anderson Acceleration to TARDIS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "47a96055de534bab8f121fcd80fd296b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Tab(children=(Output(layout=Layout(height='300px', overflow_y='auto')), Output(layout=Layout(height='300px', o…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c9f64fc8185f4020ab47b0ca2cb05990",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Iterations:          0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4aeec0e8f7784c13aab559215804d447",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Packets:             0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0df9d6dd06ac4bae86be5f7661193c71",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Iterations:', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8eb90eeb9ac448658cffe777712a68c6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "TqdmHBox(children=(HTML(value='Packets:   ', layout=Layout(width='6%')), FloatProgress(value=0.0, layout=Layou…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e16a1f67c1054d22abcb334aaeeea274",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(FigureWidget({\n",
+       "    'data': [{'type': 'scatter', 'uid': '0fd12d79-9dcd-490d-9ac8-56a2266734ca', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "os.chdir(\"/Users/deekshamohanty/tardis\") \n",
+    "\n",
+    "sim = run_tardis(\n",
+    "    \"tardis_anderson.yml\",\n",
+    "    virtual_packet_logging=False,\n",
+    "    show_convergence_plots=True,\n",
+    "    export_convergence_plots=False,\n",
+    "    log_level=\"INFO\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Applying TARDIS convergence method to cos(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:__main__:\n",
+      "\tConverged in 9 iterations \n",
+      "\tSimulation took 0.000167 s\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Converged value: 0.739085071363885 after 8 iterations\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "logging.basicConfig(level=logging.INFO)\n",
+    "logger = logging.getLogger(__name__)\n",
+    "\n",
+    "# Defining the control function (cos(x))\n",
+    "def control_function(x):\n",
+    "    return np.cos(x)\n",
+    "\n",
+    "# Defining the damped convergence function\n",
+    "def damped_converge(value, estimated_value, damping_factor):\n",
+    "    return value + damping_factor * (estimated_value - value)\n",
+    "\n",
+    "# Checking the convergence status\n",
+    "def check_convergence_status(x, estimated_x, threshold):\n",
+    "    convergence_value = abs(x - estimated_x) / abs(estimated_x)\n",
+    "    return convergence_value < threshold\n",
+    "\n",
+    "# Example of running the convergence check on cos(x)\n",
+    "def run_convergence(x0, damping_factor=0.5, threshold=1e-6, max_iterations=100):\n",
+    "    start_time = time.perf_counter()  # Starting timing\n",
+    "    iterations = 0\n",
+    "    x_values = [x0]  # Storing initial guess values\n",
+    "    while iterations < max_iterations:\n",
+    "        estimated_x = control_function(x0)\n",
+    "        if check_convergence_status(x0, estimated_x, threshold):\n",
+    "            end_time = time.perf_counter()  # End timing\n",
+    "            logger.info(f\"\\n\\tConverged in {iterations+1} iterations \"\n",
+    "                        f\"\\n\\tSimulation took {(end_time - start_time):.6f} s\\n\")\n",
+    "            return estimated_x, x_values, iterations\n",
+    "        x0 = damped_converge(x0, estimated_x, damping_factor)\n",
+    "        x_values.append(x0)  # Storing each new value of x\n",
+    "        iterations += 1\n",
+    "    end_time = time.perf_counter()  # Ending timing\n",
+    "    logger.info(f\"\\n\\tDid not converge in {iterations} iterations \"\n",
+    "                f\"\\n\\tSimulation took {(end_time - start_time):.6f} s\\n\")\n",
+    "    return estimated_x, x_values, iterations\n",
+    "\n",
+    "# Initial guess\n",
+    "x0 = 1.0\n",
+    "\n",
+    "# Running the convergence check and printing results \n",
+    "converged_value, x_values, iterations = run_convergence(x0)\n",
+    "print(f'Converged value: {converged_value} after {iterations} iterations')\n",
+    "\n",
+    "# Plotting the convergence process\n",
+    "iterations_range = np.arange(len(x_values))\n",
+    "plt.plot(iterations_range, x_values, marker='o', label='Damped Fixed Point Iteration')\n",
+    "plt.axhline(y=converged_value, color='r', linestyle='--', label='Converged Value')\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel('Value of x')\n",
+    "plt.title('Convergence of Damped Fixed-Point Iteration')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Undamped convergence for cos(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Converged in 34 iterations.\n",
+      "Convergence took 0.006329 seconds.\n",
+      "Fixed point: 0.7390848229131413\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def fixed_point_iteration(q, x0, tol=1e-6, max_iter=1000):\n",
+    "    start_time = time.perf_counter()  # Starting timing\n",
+    "    x = x0\n",
+    "    for i in range(max_iter):\n",
+    "        x_new = q(x)\n",
+    "        if np.abs(x_new - x) < tol:\n",
+    "            end_time = time.perf_counter()  # Ending timing\n",
+    "            print(f\"Converged in {i+1} iterations.\")\n",
+    "            print(f\"Convergence took {(end_time - start_time):.6f} seconds.\")\n",
+    "            return x_new\n",
+    "        x = x_new\n",
+    "    end_time = time.perf_counter() \n",
+    "    print(\"Did not converge.\")\n",
+    "    print(f\"Total time taken: {(end_time - start_time):.6f} seconds.\")\n",
+    "    return x\n",
+    "\n",
+    "def control_function(x):\n",
+    "    return np.cos(x)\n",
+    "\n",
+    "x0 = 0.5  # Initial guess\n",
+    "result = fixed_point_iteration(control_function, x0)\n",
+    "print(f\"Fixed point: {result}\")\n",
+    "\n",
+    "# Collecting the values to plot\n",
+    "x = x0\n",
+    "vals = []\n",
+    "for i in range(50):\n",
+    "    x = np.cos(x)\n",
+    "    vals.append(x)\n",
+    "\n",
+    "# Plottingn the values\n",
+    "plt.figure()\n",
+    "plt.plot(vals, marker='o', markersize=3)\n",
+    "plt.title('Convergence of Undamped Fixed-Point Iteration')\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel('cos(x)')\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Anderson acceleration implementation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Converged in 34 iterations.\n",
+      "Convergence took 0.003145 seconds.\n",
+      "Fixed point: 0.7390848229131413\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def anderson_acceleration(f, x0, m=5, tol=1e-6, max_iter=100):\n",
+    "    start_time = time.perf_counter()  # Starting timing\n",
+    "    x = [x0]  # List to store iterates\n",
+    "    g = [f(x0) - x0]  # List to store residuals\n",
+    "\n",
+    "    for k in range(1, max_iter + 1):\n",
+    "        x_new = f(x[-1])\n",
+    "        g_new = x_new - x[-1]\n",
+    "\n",
+    "        if np.abs(g_new) < tol:\n",
+    "            end_time = time.perf_counter()  # Ending timing\n",
+    "            print(f\"Converged in {k} iterations.\")\n",
+    "            print(f\"Convergence took {(end_time - start_time):.6f} seconds.\")\n",
+    "            return x_new\n",
+    "\n",
+    "        x.append(x_new)\n",
+    "        g.append(g_new)\n",
+    "\n",
+    "        if k > 1:\n",
+    "            G_k = np.column_stack([g[i] - g[i - 1] for i in range(max(0, k - m), k)])\n",
+    "            X_k = np.column_stack([x[i] - x[i - 1] for i in range(max(0, k - m), k)])\n",
+    "\n",
+    "            # Ensure g_new and g are column vectors for matrix operations\n",
+    "            g_new = np.array(g_new).reshape(-1, 1)\n",
+    "\n",
+    "            # Solve the least squares problem\n",
+    "            try:\n",
+    "                Q, R = np.linalg.qr(G_k)\n",
+    "                gamma_k = np.linalg.solve(R, Q.T @ g_new)\n",
+    "                x_accel = x[-1] - (X_k @ gamma_k + G_k @ gamma_k).flatten()\n",
+    "                x[-1] = x_accel\n",
+    "                g[-1] = f(x_accel) - x_accel\n",
+    "            except np.linalg.LinAlgError:\n",
+    "                pass\n",
+    "\n",
+    "    end_time = time.perf_counter() \n",
+    "    print(\"Did not converge.\")\n",
+    "    print(f\"Total time taken: {(end_time - start_time):.6f} seconds.\")\n",
+    "    return x[-1]\n",
+    "\n",
+    "def control_function(x):\n",
+    "    return np.cos(x)\n",
+    "\n",
+    "x0 = 0.5  # initial guess\n",
+    "result = anderson_acceleration(control_function, x0)\n",
+    "print(f\"Fixed point: {result}\")\n",
+    "\n",
+    "# Collecting the values to plot\n",
+    "x_vals = [x0]\n",
+    "x = x0\n",
+    "for _ in range(50):\n",
+    "    x = np.cos(x)\n",
+    "    x_vals.append(x)\n",
+    "\n",
+    "# Plotting the values\n",
+    "plt.figure()\n",
+    "plt.plot(x_vals, marker='o')\n",
+    "plt.title('Convergence of Anderson-Accelerated Fixed-Point Iteration')\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel('cos(x)')\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Anderson Acceleration converged in 11 iterations.\n",
+      "Anderson Acceleration took 0.002159 seconds.\n",
+      "Fixed point (Anderson): 2.0134438112396547\n",
+      "Fixed Point Iteration converged in 11 iterations.\n",
+      "Fixed Point Iteration took 0.000042 seconds.\n",
+      "Fixed point (Fixed Point Iteration): 2.0134438112396547\n",
+      "Anderson Acceleration Time: 0.002159 seconds for 11 iterations\n",
+      "Fixed Point Iteration Time: 0.000042 seconds for 11 iterations\n"
+     ]
+    }
+   ],
+   "source": [
+    "def anderson_acceleration(f, x0, m=3, tol=1e-6, max_iter=100):\n",
+    "    start_time = time.perf_counter()  # Start timing\n",
+    "    x = [x0]  # List to store iterates\n",
+    "    g = [f(x0) - x0]  # List to store residuals\n",
+    "\n",
+    "    G_k = np.zeros((1, 0))\n",
+    "    X_k = np.zeros((1, 0))\n",
+    "\n",
+    "    for k in range(1, max_iter + 1):\n",
+    "        x_new = f(x[-1])\n",
+    "        g_new = x_new - x[-1]\n",
+    "\n",
+    "        if np.abs(g_new) < tol:\n",
+    "            end_time = time.perf_counter()  # End timing\n",
+    "            print(f\"Anderson Acceleration converged in {k} iterations.\")\n",
+    "            print(f\"Anderson Acceleration took {(end_time - start_time):.6f} seconds.\")\n",
+    "            return x_new, (end_time - start_time), k\n",
+    "\n",
+    "        x.append(x_new)\n",
+    "        g.append(g_new)\n",
+    "\n",
+    "        g_new = np.array([[g_new]])  # Reshape to (1,1)\n",
+    "        x_new = np.array([[x_new]])  # Reshape to (1,1)\n",
+    "\n",
+    "        if k == 1:\n",
+    "            G_k = g_new - np.array([[g[-2]]])\n",
+    "            X_k = x_new - np.array([[x[-2]]])\n",
+    "        else:\n",
+    "            G_k = np.hstack((G_k, g_new - np.array([[g[-2]]])))\n",
+    "            X_k = np.hstack((X_k, x_new - np.array([[x[-2]]])))\n",
+    "\n",
+    "        # Use only the last m values\n",
+    "        if G_k.shape[1] > m:\n",
+    "            G_k = G_k[:, -m:]\n",
+    "            X_k = G_k[:, -m:]\n",
+    "\n",
+    "        # Solve the least squares problem\n",
+    "        try:\n",
+    "            Q, R = np.linalg.qr(G_k)\n",
+    "            gamma_k = np.linalg.solve(R, Q.T @ g_new.T).flatten()\n",
+    "            x_accel = x[-1] + g[-1] - (X_k @ gamma_k + G_k @ gamma_k)\n",
+    "            x[-1] = x_accel\n",
+    "            g[-1] = f(x_accel) - x_accel\n",
+    "        except np.linalg.LinAlgError:\n",
+    "            pass\n",
+    "\n",
+    "    end_time = time.perf_counter()  # End timing\n",
+    "    print(\"Anderson Acceleration did not converge.\")\n",
+    "    print(f\"Total time taken: {(end_time - start_time):.6f} seconds.\")\n",
+    "    return x[-1], (end_time - start_time), k\n",
+    "\n",
+    "def fixed_point_iteration(q, x0, tol=1e-6, max_iter=1000):\n",
+    "    start_time = time.perf_counter()  # Start timing\n",
+    "    x = x0\n",
+    "    for i in range(max_iter):\n",
+    "        x_new = q(x)\n",
+    "        if np.abs(x_new - x) < tol:\n",
+    "            end_time = time.perf_counter()  # End timing\n",
+    "            print(f\"Fixed Point Iteration converged in {i+1} iterations.\")\n",
+    "            print(f\"Fixed Point Iteration took {(end_time - start_time):.6f} seconds.\")\n",
+    "            return x_new, (end_time - start_time), i + 1\n",
+    "        x = x_new\n",
+    "    end_time = time.perf_counter()  # End timing\n",
+    "    print(\"Fixed Point Iteration did not converge.\")\n",
+    "    print(f\"Total time taken: {(end_time - start_time):.6f} seconds.\")\n",
+    "    return x, (end_time - start_time), max_iter\n",
+    "\n",
+    "def control_function(x):\n",
+    "    return np.sin(x) + np.arctan(x)\n",
+    "\n",
+    "# Initial guess\n",
+    "x0 = 0.5\n",
+    "\n",
+    "# Running Anderson Acceleration\n",
+    "result_anderson, time_anderson, iterations_anderson = anderson_acceleration(control_function, x0)\n",
+    "print(f\"Fixed point (Anderson): {result_anderson}\")\n",
+    "\n",
+    "# Running Fixed Point Iteration\n",
+    "result_fixed_point, time_fixed_point, iterations_fixed_point = fixed_point_iteration(control_function, x0)\n",
+    "print(f\"Fixed point (Fixed Point Iteration): {result_fixed_point}\")\n",
+    "\n",
+    "# Compare times\n",
+    "print(f\"Anderson Acceleration Time: {time_anderson:.6f} seconds for {iterations_anderson} iterations\")\n",
+    "print(f\"Fixed Point Iteration Time: {time_fixed_point:.6f} seconds for {iterations_fixed_point} iterations\")\n",
+    "\n",
+    "# Collecting the values to plot\n",
+    "x = x0\n",
+    "vals = []\n",
+    "for _ in range(50):\n",
+    "    x = np.cos(x)\n",
+    "    vals.append(x)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "tardis",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tardis/io/configuration/config_reader.py b/tardis/io/configuration/config_reader.py
index bc67fe0324f..ec57a524ed7 100644
--- a/tardis/io/configuration/config_reader.py
+++ b/tardis/io/configuration/config_reader.py
@@ -411,13 +411,19 @@ def validate_montecarlo_section(montecarlo_section):
             ] = Configuration.parse_convergence_section(
                 montecarlo_section["convergence_strategy"]
             )
+        elif montecarlo_section["convergence_strategy"]["type"] == "anderson":
+            montecarlo_section[
+                "convergence_strategy"
+            ] = Configuration.parse_convergence_section(
+                montecarlo_section["convergence_strategy"]
+            )
         elif montecarlo_section["convergence_strategy"]["type"] == "custom":
             raise NotImplementedError(
                 'convergence_strategy is set to "custom"; '
                 "you need to implement your specific convergence treatment"
             )
         else:
-            raise ValueError('convergence_strategy is not "damped" or "custom"')
+            raise ValueError('convergence_strategy is not "damped", "anderson", or "custom"')
 
     @staticmethod
     def parse_convergence_section(convergence_section_dict):
diff --git a/tardis/io/configuration/schemas/montecarlo.yml b/tardis/io/configuration/schemas/montecarlo.yml
index 1baa9f37dac..88c43f7e370 100644
--- a/tardis/io/configuration/schemas/montecarlo.yml
+++ b/tardis/io/configuration/schemas/montecarlo.yml
@@ -48,6 +48,7 @@ properties:
   convergence_strategy:
     oneOf:
     - $ref: 'montecarlo_definitions.yml#/definitions/convergence_strategy/damped'
+    - $ref: 'montecarlo_definitions.yml#/definitions/convergence_strategy/anderson'
     - $ref: 'montecarlo_definitions.yml#/definitions/convergence_strategy/custom'
     default:
       type: 'damped'
diff --git a/tardis/io/configuration/schemas/montecarlo_definitions.yml b/tardis/io/configuration/schemas/montecarlo_definitions.yml
index 1adf22599ae..deb58b5407b 100644
--- a/tardis/io/configuration/schemas/montecarlo_definitions.yml
+++ b/tardis/io/configuration/schemas/montecarlo_definitions.yml
@@ -110,6 +110,114 @@ definitions:
           type: number
           default: -0.5
           description: L=4*pi*r**2*T^y
+    anderson:
+      title: 'Anderson Convergence Strategy'
+      type: object
+      additionalProperties: false
+      properties:
+        type:
+          enum:
+            - anderson
+        memory:
+          type: number
+          default: 5
+          description: "Number of past iterations to use for computing Anderson acceleration."
+          minimum: 1
+        threshold:
+          type: number
+          default: 0.05
+          description: "Specifies the threshold that is taken as convergence (i.e., 0.05 means that the value does not change more than 5%)."
+          minimum: 0
+        damping_constant:
+          type: number
+          default: 1.0
+          description: "Damping constant used to stabilize the acceleration if necessary."
+          minimum: 0
+        hold_iterations:
+          type: number
+          multipleOf: 1.0
+          default: 3
+          description: "The number of iterations that the convergence criteria need to be fulfilled before TARDIS accepts the simulation as converged."
+        stop_if_converged:
+          type: boolean
+          default: false
+          description: "Stop plasma iterations before the number of specified iterations are reached if the simulation is plasma and inner boundary state is converged."
+        fraction:
+          type: number
+          default: 0.8
+          description: the fraction of shells that have to converge to the given  convergence
+            threshold. For example, 0.8 means that 80% of shells have to converge
+            to the threshold that convergence is established
+          minimum: 0
+        t_inner:
+          type: object
+          additionalProperties: false
+          properties:
+            damping_constant:
+              type: number
+              default: 0.5
+              description: damping constant
+              minimum: 0
+            threshold:
+              type: number
+              description: specifies the threshold that is taken as convergence  (i.e.
+                0.05 means that the value does not change more than 5%)
+              minimum: 0
+            type:
+              type: string
+              default: 'damped'
+              description: THIS IS A DUMMY VARIABLE DO NOT USE
+        t_rad:
+          type: object
+          additionalProperties: false
+          properties:
+            damping_constant:
+              type: number
+              default: 0.5
+              description: damping constant
+              minimum: 0
+            threshold:
+              type: number
+              description: specifies the threshold that is taken as convergence  (i.e.
+                0.05 means that the value does not change more than 5%)
+              minimum: 0
+            type:
+              type: string
+              default: 'damped'
+              description: THIS IS A DUMMY VARIABLE DO NOT USE
+          required:
+          - threshold
+        w:
+          type: object
+          additionalProperties: false
+          properties:
+            damping_constant:
+              type: number
+              default: 0.5
+              description: damping constant
+              minimum: 0
+            threshold:
+              type: number
+              description: specifies the threshold that is taken as convergence  (i.e.
+                0.05 means that the value does not change more than 5%)
+              minimum: 0
+            type:
+              type: string
+              default: 'damped'
+              description: THIS IS A DUMMY VARIABLE DO NOT USE
+          required:
+          - threshold
+        lock_t_inner_cycles:
+          type: number
+          multipleOf: 1.0
+          default: 1
+          description: The number of cycles to lock the update of the inner boundary
+            temperature. This process helps with convergence. The default is to switch
+            it off (1 cycle)
+        t_inner_update_exponent:
+          type: number
+          default: -0.5
+          description: L=4*pi*r**2*T^y
     custom:
       $$target: 'montecarlo_definitions.yml#/definitions/convergence_strategy/custom'
       title: 'Custom Convergence Strategy'
diff --git a/tardis/io/logger/colored_logger.py b/tardis/io/logger/colored_logger.py
deleted file mode 100644
index a03d88a1fac..00000000000
--- a/tardis/io/logger/colored_logger.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import logging
-
-"""
-Code for Custom Logger Classes (ColoredFormatter and ColorLogger) and its helper function
-(formatter_message) is used from this thread
-http://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
-"""
-
-FORMAT = "[$BOLD{name:20s}$RESET][{levelname:18s}]  \n\t{message:s} ($BOLD{filename:s}$RESET:{lineno:d})"
-DEBUG_FORMAT = "[$BOLD{name:20s}$RESET][{levelname:18s}]  {message:s} ($BOLD{filename:s}$RESET:{lineno:d})"
-
-
-def formatter_message(message, use_color=True):
-    """
-    Helper Function used for Coloring Log Output
-    """
-    # These are the sequences need to get colored ouput
-    RESET_SEQ = "\033[0m"
-    BOLD_SEQ = "\033[1m"
-    if use_color:
-        message = message.replace("$RESET", RESET_SEQ).replace(
-            "$BOLD", BOLD_SEQ
-        )
-    else:
-        message = message.replace("$RESET", "").replace("$BOLD", "")
-    return message
-
-
-class ColoredFormatter(logging.Formatter):
-    """
-    Custom logger class for changing levels color
-    """
-
-    def __init__(self, use_color=True):
-        self.non_debug = formatter_message(FORMAT, True)
-        self.debug = formatter_message(DEBUG_FORMAT, True)
-        logging.Formatter.__init__(self, self.non_debug, style="{")
-        self.use_color = use_color
-
-    def format(self, record):
-        COLOR_SEQ = "\033[1;%dm"
-        RESET_SEQ = "\033[0m"
-        BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
-        COLORS = {
-            "WARNING": YELLOW,
-            "INFO": WHITE,
-            "DEBUG": BLUE,
-            "CRITICAL": YELLOW,
-            "ERROR": RED,
-        }
-
-        levelname = record.levelname
-        if self.use_color and levelname in COLORS:
-            levelname_color = (
-                COLOR_SEQ % (30 + COLORS[levelname]) + levelname + RESET_SEQ
-            )
-            record.levelname = levelname_color
-
-        if record.levelno == logging.DEBUG:
-            self._style._fmt = self.debug
-        else:
-            self._style._fmt = self.non_debug
-
-        return logging.Formatter.format(self, record)
-
-
-class ColoredLogger(logging.Logger):
-    """
-    Custom logger class with multiple destinations
-    """
-
-    COLOR_FORMAT = formatter_message(FORMAT, True)
-
-    def __init__(self, name):
-        logging.Logger.__init__(self, name, logging.DEBUG)
-
-        color_formatter = ColoredFormatter(self.COLOR_FORMAT)
-
-        console = logging.StreamHandler()
-        console.setFormatter(color_formatter)
-
-        self.addHandler(console)
-        return
diff --git a/tardis/io/logger/logger.py b/tardis/io/logger/logger.py
index 70fcabcc4e9..311f5976260 100644
--- a/tardis/io/logger/logger.py
+++ b/tardis/io/logger/logger.py
@@ -1,66 +1,7 @@
 import logging
-import sys
-
-from tardis.io.logger.colored_logger import ColoredFormatter, formatter_message
-
-logging.captureWarnings(True)
-logger = logging.getLogger("tardis")
-
-console_handler = logging.StreamHandler(sys.stdout)
-console_formatter = ColoredFormatter()
-console_handler.setFormatter(console_formatter)
-
-logger.addHandler(console_handler)
-logging.getLogger("py.warnings").addHandler(console_handler)
-
-LOGGING_LEVELS = {
-    "NOTSET": logging.NOTSET,
-    "DEBUG": logging.DEBUG,
-    "INFO": logging.INFO,
-    "WARNING": logging.WARNING,
-    "ERROR": logging.ERROR,
-    "CRITICAL": logging.CRITICAL,
-}
-DEFAULT_LOG_LEVEL = "INFO"
-DEFAULT_SPECIFIC_STATE = False
-
-
-class FilterLog(object):
-    """
-    Filter Log Class for Filtering Logging Output
-    to a particular level
-
-    Parameters
-    ----------
-    log_level : logging object
-        allows to have a filter for the
-        particular log_level
-    """
-
-    def __init__(self, log_level):
-        self.log_level = log_level
-
-    def filter(self, log_record):
-        """
-        filter() allows to set the logging level for
-        all the record that are being parsed & hence remove those
-        which are not of the particular level
-
-        Parameters
-        ----------
-        log_record : logging.record
-            which the paricular record upon which the
-            filter will be applied
-
-        Returns
-        -------
-        boolean : True, if the current log_record has the
-            level that of the specified log_level
-            False, if the current log_record doesn't have the
-            same log_level as the specified one
-        """
-        return log_record.levelno == self.log_level
-
+import re
+from ipywidgets import Output, Tab, Layout
+from IPython.display import display, HTML
 
 def logging_state(log_level, tardis_config, specific_log_level):
     """
@@ -71,13 +12,14 @@ def logging_state(log_level, tardis_config, specific_log_level):
 
     Parameters
     ----------
-    log_level: str
-        Allows to input the log level for the simulation
-        Uses Python logging framework to determine the messages that will be output
-    specific_log_level: boolean
-        Allows to set specific logging levels. Logs of the `log_level` level would be output.
+    log_level : str
+        Allows input of the log level for the simulation.
+        Uses Python logging framework to determine the messages that will be output.
+    tardis_config : dict
+        Configuration dictionary for TARDIS.
+    specific_log_level : bool
+        Allows setting specific logging levels. Logs of the `log_level` level would be output.
     """
-
     if "debug" in tardis_config:
         specific_log_level = (
             tardis_config["debug"]["specific_log_level"]
@@ -89,7 +31,6 @@ def logging_state(log_level, tardis_config, specific_log_level):
             log_level if log_level else tardis_config["debug"]["log_level"]
         )
 
-        # Displays a message when both log_level & tardis["debug"]["log_level"] are specified
         if log_level and tardis_config["debug"]["log_level"]:
             print(
                 "log_level is defined both in Functional Argument & YAML Configuration {debug section}"
@@ -99,36 +40,30 @@ def logging_state(log_level, tardis_config, specific_log_level):
             )
 
     else:
-        # Adds empty `debug` section for the YAML
         tardis_config["debug"] = {}
 
         if log_level:
             logging_level = log_level
         else:
-            tardis_config["debug"]["log_level"] = DEFAULT_LOG_LEVEL
+            tardis_config["debug"]["log_level"] = "INFO"
             logging_level = tardis_config["debug"]["log_level"]
 
         if not specific_log_level:
-            tardis_config["debug"][
-                "specific_log_level"
-            ] = DEFAULT_SPECIFIC_STATE
+            tardis_config["debug"]["specific_log_level"] = False
             specific_log_level = tardis_config["debug"]["specific_log_level"]
 
     logging_level = logging_level.upper()
-    if not logging_level in LOGGING_LEVELS:
+    if not logging_level in ["NOTSET", "DEBUG", "INFO", "WARNING", "ERROR", "ALL"]:
         raise ValueError(
-            f"Passed Value for log_level = {logging_level} is Invalid. Must be one of the following {list(LOGGING_LEVELS.keys())}"
+            f"Passed Value for log_level = {logging_level} is Invalid. Must be one of the following ['NOTSET', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'ALL']"
         )
 
-    # Getting the TARDIS logger & all its children loggers
     logger = logging.getLogger("tardis")
+    tardis_loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict if name.startswith("tardis")]
 
-    # Creating a list for Storing all the Loggers which are derived from TARDIS
-    tardis_loggers = tardis_logger()
-
-    if logging_level in LOGGING_LEVELS:
+    if logging_level in ["NOTSET", "DEBUG", "INFO", "WARNING", "ERROR"]:
         for logger in tardis_loggers:
-            logger.setLevel(LOGGING_LEVELS[logging_level])
+            logger.setLevel(getattr(logging, logging_level))
 
     if logger.filters:
         for filter in logger.filters:
@@ -136,7 +71,7 @@ def logging_state(log_level, tardis_config, specific_log_level):
                 logger.removeFilter(filter)
 
     if specific_log_level:
-        filter_log = FilterLog(LOGGING_LEVELS[logging_level])
+        filter_log = FilterLog([getattr(logging, logging_level), logging.INFO, logging.DEBUG])
         for logger in tardis_loggers:
             logger.addFilter(filter_log)
     else:
@@ -144,23 +79,142 @@ def logging_state(log_level, tardis_config, specific_log_level):
             for logger in tardis_loggers:
                 logger.removeFilter(filter)
 
+log_outputs = {
+    "WARNING/ERROR": Output(layout=Layout(height='300px', overflow_y='auto')),
+    "INFO": Output(layout=Layout(height='300px', overflow_y='auto')),
+    "DEBUG": Output(layout=Layout(height='300px', overflow_y='auto')),
+    "ALL": Output(layout=Layout(height='300px', overflow_y='auto'))
+}
+
+tab = Tab(children=[log_outputs["WARNING/ERROR"], log_outputs["INFO"], log_outputs["DEBUG"], log_outputs["ALL"]])
+tab.set_title(0, "WARNING/ERROR")
+tab.set_title(1, "INFO")
+tab.set_title(2, "DEBUG")
+tab.set_title(3, "ALL")
+
+display(tab)
 
-def tardis_logger():
+def remove_ansi_escape_sequences(text):
     """
-    Generates the list of the loggers which are derived from TARDIS
-    All loggers which are of the form `tardis.module_name` are added to the list
+    Remove ANSI escape sequences from a string.
 
     Parameters
     ----------
-    list_for_loggers : list
-        List for storing the loggers derived from TARDIS
+    text : str
+        The input string containing ANSI escape sequences.
 
     Returns
     -------
-    list_for_loggers : list
+    str
+        The cleaned string without ANSI escape sequences.
+    """
+    ansi_escape = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]')
+    return ansi_escape.sub('', text)
+
+class WidgetHandler(logging.Handler):
     """
-    list_for_loggers = []
-    for name in logging.root.manager.loggerDict:
-        if not name.find("tardis"):
-            list_for_loggers.append(logging.getLogger(name))
-    return list_for_loggers
+    A custom logging handler that outputs log messages to IPython widgets.
+
+    Parameters
+    ----------
+    logging.Handler : class
+        Inherits from the logging.Handler class.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def emit(self, record):
+        """
+        Emit a log record.
+
+        Parameters
+        ----------
+        record : logging.LogRecord
+            The log record to be emitted.
+        """
+        log_entry = self.format(record)
+        clean_log_entry = remove_ansi_escape_sequences(log_entry)
+
+        if record.levelno == logging.INFO:
+            color = '#D3D3D3'
+        elif record.levelno == logging.WARNING:
+            color = 'orange'
+        elif record.levelno == logging.ERROR:
+            color = 'red'
+        elif record.levelno == logging.CRITICAL:
+            color = 'orange'
+        elif record.levelno == logging.DEBUG:
+            color = 'blue'
+        else:
+            color = 'black'
+
+        parts = clean_log_entry.split(' ', 2)
+        if len(parts) > 2:
+            prefix = parts[0]
+            levelname = parts[1]
+            message = parts[2]
+            html_output = f'<span>{prefix}</span> <span style="color: {color}; font-weight: bold;">{levelname}</span> {message}'
+        else:
+            html_output = clean_log_entry
+
+        if record.levelno in (logging.WARNING, logging.ERROR):
+            with log_outputs["WARNING/ERROR"]:
+                display(HTML(f"<pre style='white-space: pre-wrap; word-wrap: break-word;'>{html_output}</pre>"))
+        elif record.levelno == logging.INFO:
+            with log_outputs["INFO"]:
+                display(HTML(f"<pre style='white-space: pre-wrap; word-wrap: break-word;'>{html_output}</pre>"))
+        elif record.levelno == logging.DEBUG:
+            with log_outputs["DEBUG"]:
+                display(HTML(f"<pre style='white-space: pre-wrap; word-wrap: break-word;'>{html_output}</pre>"))
+        with log_outputs["ALL"]:
+            display(HTML(f"<pre style='white-space: pre-wrap; word-wrap: break-word;'>{html_output}</pre>"))
+
+widget_handler = WidgetHandler()
+widget_handler.setFormatter(logging.Formatter('%(name)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)d)'))
+
+logging.captureWarnings(True)
+logger = logging.getLogger("tardis")
+logger.setLevel(logging.DEBUG)
+
+# To fix the issue of duplicate logs
+for handler in logger.handlers[:]:
+    logger.removeHandler(handler)
+
+root_logger = logging.getLogger()
+for handler in root_logger.handlers[:]:
+    root_logger.removeHandler(handler)
+
+logger.addHandler(widget_handler)
+logging.getLogger("py.warnings").addHandler(widget_handler)
+
+class FilterLog(object):
+    """
+    Filter Log Class for Filtering Logging Output
+    to a particular level.
+
+    Parameters
+    ----------
+    log_level : logging object
+        allows to have a filter for the
+        particular log_level
+    """
+    def __init__(self, log_levels):
+        self.log_levels = log_levels
+
+    def filter(self, log_record):
+        """
+         Determine if the specified record is to be logged.
+
+        Parameters
+        ----------
+        log_record : logging.LogRecord
+            The log record to be filtered.
+
+        Returns
+        -------
+        boolean : True, if the current log_record has the
+            level that of the specified log_level,
+            False, if the current log_record doesn't have the
+            same log_level as the specified one.
+        """
+        return log_record.levelno in self.log_levels
\ No newline at end of file
diff --git a/tardis/simulation/base.py b/tardis/simulation/base.py
index 7efa377a314..e717aff9a64 100644
--- a/tardis/simulation/base.py
+++ b/tardis/simulation/base.py
@@ -517,7 +517,7 @@ def log_plasma_state(
         plasma_state_log["next_w"] = next_dilution_factor
         plasma_state_log.columns.name = "Shell No."
 
-        if is_notebook():
+        if False and is_notebook(): #TODO: remove it with something better
             logger.info("\n\tPlasma stratification:")
 
             # Displaying the DataFrame only when the logging level is NOTSET, DEBUG or INFO
diff --git a/tardis/simulation/convergence.py b/tardis/simulation/convergence.py
index 3891b50374e..3b79a4a86de 100644
--- a/tardis/simulation/convergence.py
+++ b/tardis/simulation/convergence.py
@@ -1,5 +1,6 @@
 import numpy as np
-
+from astropy import units as u
+from astropy.units import Quantity
 
 class ConvergenceSolver:
     def __init__(self, strategy):
@@ -21,9 +22,16 @@ def __init__(self, strategy):
         self.convergence_strategy = strategy
         self.damping_factor = self.convergence_strategy.damping_constant
         self.threshold = self.convergence_strategy.threshold
+        self.memory = self.convergence_strategy.get('memory', 5)
+
+        #Initializing the history for Anderson method
+        self.x_history = []
+        self.g_history = []
 
         if self.convergence_strategy.type in ("damped"):
             self.converge = self.damped_converge
+        elif self.convergence_strategy.type in ("anderson"):
+            self.converge = self.anderson_converge
         elif self.convergence_strategy.type in ("custom"):
             raise NotImplementedError(
                 "Convergence strategy type is custom; "
@@ -32,10 +40,68 @@ def __init__(self, strategy):
         else:
             raise ValueError(
                 f"Convergence strategy type is "
-                f"not damped or custom "
+                f"not damped, anderson or custom "
                 f"- input is {self.convergence_strategy.type}"
             )
 
+    def anderson_converge(self, value, estimated_value):
+        """
+        Anderson acceleration method for convergence.
+
+        Parameters
+        ----------
+        value : Quantity or float
+            The current value of the physical property.
+        estimated_value : Quantity or float
+            The estimated value of the physical property.
+
+        Returns
+        -------
+        Quantity
+            The accelerated converged value with the same units as the input value.
+
+        Raises
+        ------
+        LinAlgError
+            If the QR decomposition or the linear system solution fails, the method 
+            should fall back to returning the current estimated value without acceleration.
+        """
+        if not isinstance(value, Quantity):
+            value = value * u.K  
+        if not isinstance(estimated_value, Quantity):
+            estimated_value = estimated_value * u.K
+
+        original_unit = value.unit
+        if value.unit != estimated_value.unit:
+            value = value.to(estimated_value.unit)
+
+        value = value.value
+        estimated_value = estimated_value.value
+
+        x_new = estimated_value
+        g_new = x_new - value
+
+        self.x_history.append(value) 
+        self.g_history.append(g_new)
+
+        if len(self.x_history) > 1:
+            m = min(self.memory, len(self.x_history) - 1)
+            G_k = np.column_stack([self.g_history[i] - self.g_history[i - 1] for i in range(-m, 0)])
+            X_k = np.column_stack([self.x_history[i] - self.x_history[i - 1] for i in range(-m, 0)])
+
+            g_new = np.array(g_new).reshape(-1, 1)
+            try:
+                Q, R = np.linalg.qr(G_k)
+                gamma_k = np.linalg.solve(R, Q.T @ g_new)
+                x_accel = self.x_history[-1] - (X_k @ gamma_k + G_k @ gamma_k).flatten()
+                self.x_history[-1] = x_accel
+                self.g_history[-1] = estimated_value - x_accel
+                return (x_accel * original_unit)
+            except np.linalg.LinAlgError:
+                pass
+
+        return x_new * original_unit 
+
     def damped_converge(self, value, estimated_value):
         """Damped convergence solver
 
diff --git a/tardis_anderson.yml b/tardis_anderson.yml
new file mode 100644
index 00000000000..39eb6713307
--- /dev/null
+++ b/tardis_anderson.yml
@@ -0,0 +1,58 @@
+# Example YAML configuration for TARDIS
+tardis_config_version: v1.0
+
+supernova:
+  luminosity_requested: 9.44 log_lsun
+  time_explosion: 13 day
+
+atom_data: kurucz_cd23_chianti_H_He.h5
+
+model:
+  structure:
+    type: specific
+    velocity:
+      start: 1.1e4 km/s
+      stop: 20000 km/s
+      num: 20
+    density:
+      type: branch85_w7
+
+  abundances:
+    type: uniform
+    O: 0.19
+    Mg: 0.03
+    Si: 0.52
+    S: 0.19
+    Ar: 0.04
+    Ca: 0.03
+
+plasma:
+  disable_electron_scattering: no
+  ionization: lte
+  excitation: lte
+  radiative_rates_type: dilute-blackbody
+  line_interaction_type: macroatom
+
+montecarlo:
+  seed: 23111963
+  no_of_packets: 4.0e+4
+  iterations: 20
+  nthreads: 1
+
+  last_no_of_packets: 1.e+5
+  no_of_virtual_packets: 10
+
+  convergence_strategy:
+    type: damped
+    damping_constant: 0.2
+    #memory: 10
+    threshold: 0.05
+    fraction: 0.8
+    hold_iterations: 3
+    t_inner:
+      damping_constant: 0.2
+
+spectrum:
+  start: 500 angstrom
+  stop: 20000 angstrom
+  num: 10000