diff --git a/Tests/Data/Notebooks/pointheatsource.run-skip.ipynb b/Tests/Data/Notebooks/pointheatsource.run-skip.ipynb
index c197a2596d1f0a6b47521f7af00a1e9893b8e8b1..3241debeb3ff5c246d02880917f1800bc86d8c5c 100644
--- a/Tests/Data/Notebooks/pointheatsource.run-skip.ipynb
+++ b/Tests/Data/Notebooks/pointheatsource.run-skip.ipynb
@@ -69,10 +69,10 @@
"and\n",
"\n",
"\\begin{equation}\n",
- " g^{A}_{,i} = \\dfrac{2x_{i}At}{r^{4}}\\left(f^{A}-1+\\dfrac{r}{\\sqrt{\\pi At}}\\exp\\left(-\\dfrac{r^{2}}{4At}\\right)\\right),\\quad i=1,2,3\n",
+ " g^{A}\\_{,i} = \\dfrac{2x\\_{i}At}{r^{4}}\\left(f^{A}-1+\\dfrac{r}{\\sqrt{\\pi At}}\\exp\\left(-\\dfrac{r^{2}}{4At}\\right)\\right),\\quad i=1,2,3\n",
"\\end{equation}\n",
"\\begin{equation}\n",
- " g^{\\ast}_{,i} = Yg^{\\kappa}\\_{,i}-Zg^{c}_{,i}\n",
+ " g^{\\ast}\\_{,i} = Yg^{\\kappa}\\_{,i}-Zg^{c}\\_{,i}\n",
"\\end{equation}\n",
"\n",
"For the temperature, porepressure and displacements, the correct solution can be found in the original work:\n",
@@ -89,10 +89,10 @@
"For the stress components the corrected expressions can be found in the work of Chaudhry et al. (2019):\n",
"\n",
"\\begin{equation}\n",
- " \\sigma^{\\prime}_{ij\\,|\\,j=i} = \\dfrac{Q a_\\text{u}}{4\\pi Kr}\\left( 2G\\left[g^{\\ast}\\left(1-\\dfrac{x^{2}_{i}}{r^{2}}\\right)+x_{i}g^{\\ast}_{,i}\\right]+\\lambda \\left[x_{i}g^{\\ast}_{,i}+2g^{\\ast}\\right]\\right)-b^{\\prime}\\Delta T\n",
+ " \\sigma^{\\prime}\\_{ij,|,j=i} = \\dfrac{Q a\\_\\text{u}}{4\\pi Kr}\\left( 2G\\left[g^{\\ast}\\left(1-\\dfrac{x^{2}\\_{i}}{r^{2}}\\right)+x\\_{i}g^{\\ast}\\_{,i}\\right]+\\lambda \\left[x\\_{i}g^{\\ast}\\_{,i}+2g^{\\ast}\\right]\\right)-b^{\\prime}\\Delta T\n",
"\\end{equation}\n",
"\\begin{equation}\n",
- " \\sigma^{\\prime}_{ij\\,|\\,j \\neq i} = \\dfrac{Q a_\\text{u}}{4\\pi Kr}\\left( G\\left[x_{i}g^{\\ast}_{,j}+x_{j}g^{\\ast}_{,i}-2g^{\\ast}\\dfrac{x_{i}x_{j}}{r^{2}}\\right]\\right)\n",
+ " \\sigma^{\\prime}\\_{ij,|,j \\neq i} = \\dfrac{Q a\\_\\text{u}}{4\\pi Kr}\\left( G\\left[x\\_{i}g^{\\ast}\\_{,j}+x\\_{j}g^{\\ast}\\_{,i}-2g^{\\ast}\\dfrac{x\\_{i}x\\_{j}}{r^{2}}\\right]\\right)\n",
"\\end{equation}\n"
]
},
@@ -106,7 +106,7 @@
},
{
"cell_type": "code",
- "execution_count": 126,
+ "execution_count": 167,
"metadata": {},
"outputs": [],
"source": [
@@ -131,7 +131,7 @@
},
{
"cell_type": "code",
- "execution_count": 127,
+ "execution_count": 168,
"metadata": {},
"outputs": [],
"source": [
@@ -166,7 +166,7 @@
},
{
"cell_type": "code",
- "execution_count": 128,
+ "execution_count": 169,
"metadata": {},
"outputs": [],
"source": [
@@ -183,7 +183,7 @@
},
{
"cell_type": "code",
- "execution_count": 161,
+ "execution_count": 170,
"metadata": {},
"outputs": [
{
@@ -191,9 +191,9 @@
"output_type": "stream",
"text": [
"OGS finished with project file ../../Data/ThermoHydroMechanics/Linear/Point_injection/pointheatsource_lin.prj.\n",
- "Execution took 419.13923168182373 s\n",
+ "Execution took 364.149382352829 s\n",
"OGS finished with project file ../../Data/ThermoHydroMechanics/Linear/Point_injection/pointheatsource_quad.prj.\n",
- "Execution took 966.364892244339 s\n"
+ "Execution took 1031.2281892299652 s\n"
]
}
],
@@ -215,7 +215,7 @@
},
{
"cell_type": "code",
- "execution_count": 130,
+ "execution_count": 171,
"metadata": {},
"outputs": [],
"source": [
@@ -231,7 +231,7 @@
},
{
"cell_type": "code",
- "execution_count": 131,
+ "execution_count": 172,
"metadata": {},
"outputs": [],
"source": [
@@ -247,7 +247,7 @@
},
{
"cell_type": "code",
- "execution_count": 132,
+ "execution_count": 173,
"metadata": {},
"outputs": [],
"source": [
@@ -257,7 +257,7 @@
},
{
"cell_type": "code",
- "execution_count": 133,
+ "execution_count": 174,
"metadata": {},
"outputs": [],
"source": [
@@ -274,24 +274,16 @@
},
{
"cell_type": "code",
- "execution_count": 157,
+ "execution_count": 175,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:29: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return special.erfc(R/(2*np.sqrt(ka*t)))\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'temperature')"
]
},
- "execution_count": 157,
+ "execution_count": 175,
"metadata": {},
"output_type": "execute_result"
},
@@ -325,24 +317,16 @@
},
{
"cell_type": "code",
- "execution_count": 158,
+ "execution_count": 176,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:29: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return special.erfc(R/(2*np.sqrt(ka*t)))\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'pressure')"
]
},
- "execution_count": 158,
+ "execution_count": 176,
"metadata": {},
"output_type": "execute_result"
},
@@ -372,24 +356,16 @@
},
{
"cell_type": "code",
- "execution_count": 159,
+ "execution_count": 177,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'displacement')"
]
},
- "execution_count": 159,
+ "execution_count": 177,
"metadata": {},
"output_type": "execute_result"
},
@@ -426,7 +402,7 @@
},
{
"cell_type": "code",
- "execution_count": 137,
+ "execution_count": 178,
"metadata": {},
"outputs": [],
"source": [
@@ -436,7 +412,7 @@
},
{
"cell_type": "code",
- "execution_count": 138,
+ "execution_count": 179,
"metadata": {},
"outputs": [],
"source": [
@@ -447,28 +423,16 @@
},
{
"cell_type": "code",
- "execution_count": 139,
+ "execution_count": 180,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:42: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (self.Q/(4*np.pi*self.K*R)*self.f(self.kappa,R,t)+self.T0)\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'temperature')"
]
},
- "execution_count": 139,
+ "execution_count": 180,
"metadata": {},
"output_type": "execute_result"
},
@@ -499,30 +463,16 @@
},
{
"cell_type": "code",
- "execution_count": 151,
+ "execution_count": 181,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:42: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (self.Q/(4*np.pi*self.K*R)*self.f(self.kappa,R,t)+self.T0)\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:42: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (self.Q/(4*np.pi*self.K*R)*self.f(self.kappa,R,t)+self.T0)\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'temperature error')"
]
},
- "execution_count": 151,
+ "execution_count": 181,
"metadata": {},
"output_type": "execute_result"
},
@@ -550,30 +500,16 @@
},
{
"cell_type": "code",
- "execution_count": 152,
+ "execution_count": 182,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:46: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (self.X/(1-self.c/self.kappa)*self.Q/(4*np.pi*self.K*R)*(self.f(self.kappa,R,t)-self.f(self.c,R,t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:46: RuntimeWarning: invalid value encountered in multiply\n",
- " return (self.X/(1-self.c/self.kappa)*self.Q/(4*np.pi*self.K*R)*(self.f(self.kappa,R,t)-self.f(self.c,R,t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'pressure')"
]
},
- "execution_count": 152,
+ "execution_count": 182,
"metadata": {},
"output_type": "execute_result"
},
@@ -604,34 +540,16 @@
},
{
"cell_type": "code",
- "execution_count": 153,
+ "execution_count": 183,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:46: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (self.X/(1-self.c/self.kappa)*self.Q/(4*np.pi*self.K*R)*(self.f(self.kappa,R,t)-self.f(self.c,R,t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:46: RuntimeWarning: invalid value encountered in multiply\n",
- " return (self.X/(1-self.c/self.kappa)*self.Q/(4*np.pi*self.K*R)*(self.f(self.kappa,R,t)-self.f(self.c,R,t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:46: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (self.X/(1-self.c/self.kappa)*self.Q/(4*np.pi*self.K*R)*(self.f(self.kappa,R,t)-self.f(self.c,R,t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:46: RuntimeWarning: invalid value encountered in multiply\n",
- " return (self.X/(1-self.c/self.kappa)*self.Q/(4*np.pi*self.K*R)*(self.f(self.kappa,R,t)-self.f(self.c,R,t)))\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'pressure error')"
]
},
- "execution_count": 153,
+ "execution_count": 183,
"metadata": {},
"output_type": "execute_result"
},
@@ -659,32 +577,16 @@
},
{
"cell_type": "code",
- "execution_count": 156,
+ "execution_count": 184,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:51: RuntimeWarning: invalid value encountered in true_divide\n",
- " return self.a_u*index[i]*self.Q/(4*np.pi*self.K*R)*self.gstar(R,t)\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: invalid value encountered in add\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'displacement')"
]
},
- "execution_count": 156,
+ "execution_count": 184,
"metadata": {},
"output_type": "execute_result"
},
@@ -715,38 +617,16 @@
},
{
"cell_type": "code",
- "execution_count": 155,
+ "execution_count": 185,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:51: RuntimeWarning: invalid value encountered in true_divide\n",
- " return self.a_u*index[i]*self.Q/(4*np.pi*self.K*R)*self.gstar(R,t)\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: invalid value encountered in add\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/vtuIO.py:147: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
- " df[\"r_\"+str(i)] = (df[x]-val[x]) * (df[x]-val[x]) + (df[y]-val[y]) * (df[y]-val[y])\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:51: RuntimeWarning: invalid value encountered in true_divide\n",
- " return self.a_u*index[i]*self.Q/(4*np.pi*self.K*R)*self.gstar(R,t)\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: divide by zero encountered in true_divide\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n",
- "/home/buchwalj/.local/lib/python3.10/site-packages/heatsource.py:32: RuntimeWarning: invalid value encountered in add\n",
- " return (ka*t/R**2+(1/2-ka*t/R**2)*special.erfc(R/(2*np.sqrt(ka*t)))-np.sqrt(ka*t/(np.pi*R**2))*np.exp(-R**2/(4*ka*t)))\n"
- ]
- },
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'displacement error')"
]
},
- "execution_count": 155,
+ "execution_count": 185,
"metadata": {},
"output_type": "execute_result"
},
@@ -772,14 +652,23 @@
"plt.title(\"displacement error\")"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The differences observed for the OGS6 results in comparision to the analytical solution can be primarily explained by mesh discretization and finite size effects.\n",
+ "\n",
+ "## Execution times"
+ ]
+ },
{
"cell_type": "code",
- "execution_count": 164,
+ "execution_count": 186,
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8UAAAL5CAYAAACZ/YYOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA3kklEQVR4nO3de7h1ZVkv/u8diJp4Bg+FAeZhl+UhIE1NVHaWaSUbvSx3O91m7gA756mD27QUUysTRG1r7Ep/JpSa29TtKcRDKmLmRjFNQURBPISgqCj37485li4Xay3euU7vXDyfz3XN63nHGM895rMmXGvM7xpjPKO6OwAAADCi79jbAwAAAIC9RSgGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIa1794ewKgOOOCAPuSQQ/b2MAAAAK7x3vve9362uw9cbZtQvJcccsghOfPMM/f2MAAAAK7xquq8tba5fBoAAIBhLUworqrbV9WvVdXfVNU5VXVlVXVVPXgPah9WVWdU1SVVdVlVnVlVx1fVuj/fTtcBAACwWBbp8uljk/zavEVVdVKS45J8JcmbklyR5KgkJyY5qqoe0t3f2Nt1AAAALJ5FOrP5/5I8M8lDk9wmyelXV1BVx2QWUC9McsfufmB3H53ktkk+lOToJI/Z23UAAAAspoUJxd39v7r7cd398u7+9z0se+LUPr67P7JsXxdlduY5SZ6wymXNO10HAADAAtq14a2qDkpyWJKvJTl15fbuPj3JBUlukeRue6sOAACAxbVrQ3GSu0zt2d19+Rp93rOi796oAwAAYEHt5lB86NSu+bypJJ9Y0Xdv1AEAALCgdnMo3n9qv7ROn8um9vp7se6bqurR0+Obzrz44ovX2Q0AAAA7YTeH4praXvC6b+ruF3b34d19+IEHHrjR3QAAALBFdnMovnRq91+nz9K2S5et2+k6AAAAFtRuDsXnTu3B6/S51Yq+e6MOAACABbWbQ/H7pvYOVXXdNfocsaLv3qgDAABgQe3aUNzd5yc5K8l+SR6ycntVHZnkoCQXJnnn3qoDAABgce3aUDx5+tQ+o6pus7Syqm6W5HnT4gndfeVergMAAGABVfeGJ1PeUlX1Q/lWsEyS78/s0UYfSfL5pZXdfbcVdc9LcmySryR5Y5IrkhyV5AZJXpnkwd39jVXeb0frVjr88MP7zDPPvLpuAAAAbFJVvbe7D19t2747PZh13CDJXVdZf9v1irr7uKp6W5LjkxyZZJ8k5yR5cZKT1zpru9N1AAAALJ6FOVM8GmeKAQAAdsZ6Z4p3+z3FAAAAsGFCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwrH339gAAALbLIU94zd4eAsAwzj3hAXt7CBviTDEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGEJxQAAAAxLKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhiUUAwAAMCyhGAAAgGFdI0JxVR1UVc+tqg9X1eVV9ZWq+khVPb+qbr1O3cOq6oyquqSqLquqM6vq+Kpa93PZaB0AAACLZdeHuKq6S5IPJHlMku9M8vokr0ty3ST/I8n7q+ruq9SdlOQlSQ5PckaSNyS5XZITk5xWVfus8X4bqgMAAGDx7PpQnOSkJDdK8hdJbt3dD+ruByU5NMmLk+yf5OTlBVV1TJLjklyY5I7d/cDuPjrJbZN8KMnRmYXsbEUdAAAAi2lXh+Kquk6SH5kWn9TdVyxtm/79+9PiHavqO5eVPnFqH9/dH1lWc1GSY6fFJ6xyOfRG6wAAAFhAuz28fSPJ16d/1yrbe2q/lOTyZHb/cZLDknwtyalXKeg+PckFSW6R5G5L6zdaBwAAwOLa1aF4Ohv8pmnxD6rqWkvbpn//4bT4ou5eCsh3mdqzu/vyNXb9nhV9N1MHAADAgtp3bw9gCxyX2cRav5Tk/lV15rT+iCQ3TvKcJI9d1v/QqT1vnX1+YkXfzdQBAACwoHZ9KO7uj02zS/9VkvsnOWjZ5jOTvHX5vcaZTbyVzC6pXstlU3v9Laj7pqp6dJJHJ8n3fM/3rLMbAAAAdsKuvnw6SaZA/P+S3CbJzyQ5IMmBSR6U2Zniv6uqJy0vmdrOfDZa903d/cLuPry7Dz/wwAM3uhsAAAC2yK4+U1xVN0ryyiTXS3L37v7Yss2vqqqzk/xrkt+vqv9vmjH60mn7/lnb0rZLl63baB0AAAALarefKX5AZmeF/3lFIE6SdPdHk7wrs/B/72n1uVN78Dr7vdWKvpupAwAAYEHt9lC8dGPuJev0+Y+pvcnUvm9q71BV112j5ogVfTdTBwAAwILa7aH4U1N72PLHMS2Z1h02LX48Sbr7/CRnJdkvyUNWqTkys8m6LkzyzqX1G60DAABgce32UPzaJF/O7Izxn1bVtZc2TP/+88wuaf5Cktcvq3v61D6jqm6zrOZmSZ43LZ7Q3VeueL+N1gEAALCAdvVEW939mao6LsmLkhyf5Oiqem9mM0UfluSWSb6a5JHdfcmyutOq6uQkxyb5QFW9MckVSY5KcoPMJu86cZX321AdAAAAi2lXh+Ik6e7/XVUfSPLrSX40yf2mTRdkFpb/pLs/uErdcVX1tszC9JFJ9klyTpIXJzl5rbO9G60DAABg8ez6UJwk3X1Wkl/YQN1Lk7x0p+oAAABYLLv9nmIAAADYMKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFjXmFBcVdetqsdV1Xuq6j+q6stV9fGqOrWq7rFGzcOq6oyquqSqLquqM6vq+Kpa93PZaB0AAACLZd+9PYCtUFWHJvm/SW6T5DNJTk/y1SSHJPmZJO9P8vYVNSclOS7JV5K8KckVSY5KcmKSo6rqId39jVXea0N1AAAALJ4tCcXTGdJHJrlTkvOSvKC7L92Kfe/Be18vyRuSfG+SpyZ5andfsWz7TZPcdEXNMZkF2wuT3Ku7PzKtv3mStyQ5OsljkjxnK+oAAABYTHNd7ltVT5guS773ik2vSfKCJMcneUaSd05hdSf8XmaB+K+6+0nLA3GSdPfnuvvfVtQ8cWofvxRsp74XJTl2WnzCKpdDb7QOAACABTRvePvxJF/M7PLkJElV3W9af0GSP0zy7iTfl9mZ421VVfsl+aVp8YQ9rDkoyWFJvpbk1JXbu/v0zH6WWyS522brAAAAWFzzhuLbJPlgd/eydcck6SQ/291PSnLfJF9I8rCtGeK6Dsvs0ujzu/tDVXX3qnpaVb2gqv6gqn5klZq7TO3Z3X35Gvt9z4q+m6kDAABgQc17T/FNk7x1xbp7Jrmwu9+RJN19eVW9I8kRWzC+q/ODU/uRqjolycNXbH9SVf1dkv+2LMgeOrXnrbPfT6zou5k6AAAAFtS8Z4o7yTfvFa6qGyb5T1kxs3OSS5LcaFMj2zM3mdp7JfmFJM/K7Gz2jTObdfqCzM5kn7SsZv+p/dI6+71saq+/BXUAAAAsqHlD8ceT3HXZRFIPTFJJ3rai34FJPrvJse2JpXHsm+RF3f3Y7v737v6P7v6HJA/KLMg/vKpuPfWtqe3MZ6N139pB1aOnZxqfefHFF290NwAAAGyReUPxPyS5eZJXVNWvJnlmkm8kedVSh6qqzO6p/fhWDXIdyx/79BcrN3b3mUnem9nPee8VNfuv7L/M0rbl+99o3fLxvLC7D+/uww888MB1dgMAAMBOmDcUPyPJh5L8VJI/y2ym5Wd19/L7bO+Z2ZnilWePt8O5y/69VghfWn+LFTUHr7PfW62y/43WAQAAsKDmmmiruy+pqsOTPDizM8bv7u6VE2/dNMlzkrxsa4a4rrNWvO9q1yQfMLVL9/u+b2rvUFXXXWMm6SNW9N1MHQAAAAtq3jPF6e7Lu/uvu/tZqwTidPcru/s3uvtft2aI647lgiTvmhaPWrm9qm6c5IemxTOnmvMzC9P7JXnIKjVHJjkoyYVJ3rnsvTZUBwAAwOKaOxQvoD+a2idV1Z2XVlbVdZKcnOSGmd1XvDyoPn1qn1FVt1lWc7Mkz5sWT+juK1e810brAAAAWEDzPqd44XT3q6vqWUl+O8m7qupdST6X5IeTfFdmj2X6ue7uZTWnVdXJSY5N8oGqemOSKzI723yDJK9McuIq77WhOgAAABbTrg/FSdLdj62qdyT5lcxmvv7OJJ9I8ieZnbm9yr3G3X1cVb0tyfFJjkyyT5Jzkrw4yclrne3daB0AAACL5xoRipOku1+R5BVz1rw0yUs38F4bqgMAAGCxXBPuKQYAAIANEYoBAAAY1rqhuKputVMDAQAAgJ12dWeKz6uqd1fVE6rqP+3IiAAAAGCHXF0ofnWSH0jytCRnV9UHq+qpVXXY9g8NAAAAtte6obi7fybJAUkemuTlmT3393eTvLuqzquqP62qe1VVbf9QAQAAYGtd7URb3f3l7j61u38uyYFJHpjkL5NcJ8mvJXlLkgur6oVVdf+quta2jhgAAAC2yFyzT3f3Fd39j939qCS3THKfJCcl+UqSRyX5P0kurqqXVNUxVXW9LR8xAAAAbJENP5Kpu6/s7tO7+1e7++AkP5zkj5N8OsnPZXa59cVV9citGSoAAABsrS17TnF3n9ndT+zu78tscq4nJzknyXdv1XsAAADAVtp3O3ba3R9M8sEkT3WPMQAAAItqy84Ur6W7r9ju9wAAAICN2PZQDAAAAItKKAYAAGBYQjEAAADDEooBAAAYllAMAADAsIRiAAAAhrWh5xRX1Q2T/HySH0lyYJI3dfcfT9tun+TgJGd09+VbNVAAAADYanOH4qr6iSQvSXKjJJWkk1ywrMtdpu0PS/K3mx8iAAAAbI+5Lp+uqh9I8vdJrp/keUkemlkwXu4fklye5Ge2YoAAAACwXeY9U/w7Sa6d5Oju/ockqapvOxvc3V+uqnOS3GlrhggAAADbY96Jtu6d5H1LgXgd5ye55YZGBAAAADtk3lB80yQf3YN+Vya57vzDAQAAgJ0zbyj+QpKD9qDf9ya5aP7hAAAAwM6ZNxS/O8kRVXXbtTpU1RFJ7pjk7ZsZGAAAAGy3eUPxSUmuleS06XnE36aqbp3kxZk9punkzQ8PAAAAts9cobi7X5/kuUl+MMkHq+pfMwvA/7mq3pXknCR3SPKn3f22rR4sAAAAbKV5zxSnu38tyXGZ3TP8A5k9p/igJEckuSTJr3f3b2/lIAEAAGA7zPuc4iRJdz+/ql6Y5M5Jbp1kn8wew/Tu7v761g0PAAAAts+GQnGSdPeVSc6aXgAAALDrzH35NAAAAFxTbOhMcVXdKsmRSb4ryXXW6Nbd/dSNDgwAAAC221yhuKr2TXJikkdlNsFWlrVLelrXSYRiAAAAFta8Z4qfnOTRSb6e5B+TfCTJZVs8JgAAANgR84bi/5bkS0nu0d3/ug3jAQAAgB0z70RbN0tyukAMAADANcG8ofgTSb66HQMBAACAnTZvKH5ZkiOrav/tGAwAAADspHlD8dOSfDjJa6rqdtswHgAAANgxc0201d1frar7JXlnkrOr6rwkn0xy5erd+6gtGCMAAABsi3mfU3xAkjckuUNmzyK+9fRaTW9uaAAAALC95n0k0wlJ7pTZJdTPT/LReE4xAAAAu9S8ofgBST6d5G7dfck2jAcAAAB2zLwTbV0/yTsEYgAAAK4J5g3FH8osGAMAAMCuN28oPinJvT2OCQAAgGuCuUJxd5+S5M+S/FNV/WJVHbQdgwIAAICdMO8jmb6xbPGF07q1und3zzuRFwAAAOyYeUPrmgl4k30BAABgx80Virt73nuQAQAAYGEJuQAAAAxLKAYAAGBYQjEAAADDWvee4qr6WJJO8p+7++PT8p7q7v7eTY0OAAAAttHVTbR1SGah+FrLlvdUb2A8AAAAsGOuLhQfOrUXrFgGAACAXW/dUNzd5623DAAAALvZXBNtVdW9qup2e9DvtlV1r40PCwAAALbfvLNP/1OSx+9Bv8clecvcowEAAIAdtJFHMtWWjwIAAAD2gu16TvHNkly+TfsGAACALXF1s09nlXuDb7HO/cL7Jvm+JPdL8qFNjg0AAAC21dWG4szuI17+zOEfn17rqSQv2OCYAAAAYEfsSSh+a74Vio9M8pkk56zR92uZPdP4Fd396s0PDwAAALbP1Ybi7r730r+r6sokr+3uR27noAAAAGAn7MmZ4uXuk+TC7RgIAAAA7LS5QnF3n75dAwEAAICdtl2PZAIAAICFJxQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCw9t3qHVbVKUm+J0l391FbvX8AAADYKlseipPcNcntk/Q27BsAAAC2zHaE4hOTHLAN+wUAAIAtteWhuLtP2up9AgAAwHYw0RYAAADDEooBAAAY1lyhuKruX1Vvrqr7rNPnvlOfH9v88AAAAGD7zHum+L8nOTzJu9fp8+4kRyR5xAbHBAAAADti3lB8WJL3d/eX1urQ3Zcl+ZfMHs0EAAAAC2veUHzLJOfvQb/zk9xi/uEAAADAzpk3FH81yQ33oN8Nk3xj/uEAAADAzpk3FH8oyT2ras1gXFU3SHLPJP+2mYEBAADAdps3FP99kusneXFVXXvlxqraL8mLk+yf5O82PzwAAADYPvvO2f95SR6V5EFJPlhVL0lyzrTt9kl+PskhST6a5LlbM0QAAADYHnOF4u7+clXdL8krk9w5ye+u6FKZzTz9X9aboRoAAAAWwbxnitPdn6iqw5L8dJKfSHLwtOm8JK9P8qru7q0bIgAAAGyPuUNxkkyh91XTCwAAAHaleSfaAgAAgGuMDYXiqrpNVT2zqt5WVR+uqj9etu1uVfXoqrrRlo0SAAAAtsHcl09X1S8mOSnJftOqTnLAsi4HJjk5yRVJ/nKzAwQAAIDtMteZ4qq6R5IXJPlKkscmuWtmM04v97okX8xsIi4AAABYWPOeKX5cZmeG79/d70ySqm/PxN19RVV9OMn3bckIAQAAYJvMe0/xjyR591IgXsf5SW65sSEBAADAzpg3FN8wySf3oN9+2eDjngAAAGCnzBuKP5Pk0D3od/skF8w/HAAAANg584bityf5oao6fK0OVfVjSW6X5J82MS4AAADYdvOG4j/NbLbpv6+q+1XVt9VX1b2SvDjJ15M8d2uGCAAAANtjrlDc3e/KbAbqg5K8NsnnMpuN+kFVdVGStyT57iSP6+4PbPFYAQAAYEvNe6Y43f3sJD+Z5MwkN8jszPGNkhyY5P8leVB3/9nWDREAAAC2x4ZmiO7u1yV5XVXdNLOJt/ZJcn53f2orBwcAAADbaa5QXFX7dvfXl5a7+3OZXUK9Wt+DuntPHt8EAAAAe8W8l0+/s6oOubpOVfVTSf5lIwMCAACAnTJvKD4syVlV9eDVNlbVvlX17CSvzOw+YwAAAFhY84bip2Q2udbfVtWJVbXf0obpDPLbk/x6ks8mecAWjREAAAC2xbyPZHpykvsl+UySYzO7nPo2VXVMkrOSHJHkrUnu3N2v3+KxAgAAwJaae/bp7n5zVd05yUuS3DfJ+5NcJ7PnFT8lyVO6+8qtHCQAAABsh7mfU5wk3X1RkuOSXJLkutPqv+ruJwvEAAAA7BYbCsVV9ZAk787s/uJ/TvLVJA+vqtOq6oZbOD4AAADYNnOF4qrar6pOTvKyJNdL8nvdffckd03yb0n+S5L3VdUPb/lIAQAAYIvNe6b4XUkeneRTSe7T3U9Pku7+QGaPa/rrJIckOaOqfmsLxwkAAABbbt5QfKckr8tsdum3Ld/Q3V/u7ocneWSSryf5460ZIgAAAGyPeUPx73T3A7r7c2t16O5Tkhye5OzNDAwAAAC227zPKT5hD/t9KIn7igEAAFhocz+neMk0y/QRSQ5Mcl53v2P59u7+yibHxl5yyBNes7eHADCUc094wN4eAgAMa+5HMlXVDavqxUk+k+T1Sf4myaOWbT+uqj5VVXfbumECAADA1pv3kUzXS/JPSR6R5AtJXpukVnR7XZJbJHnQpkcHAAAA22jeM8W/ndkM1H+T5Nbd/cCVHbr7Y5k9s/i+mx8eAAAAbJ95Q/FDMntG8S9195fX6feJJN+94VEBAADADpg3FN86yXu6+6tX0++zSW66sSEBAADAzpg3FF+R5Dp70O+gJJfNP5zNq6qnVVVPr99ep9/DquqMqrqkqi6rqjOr6viqWvcz2WgdAAAAi2feIPfhJHepqjWDcVXdOLP7jj+wmYFtRFUdkeRxSfpq+p2U5CVJDk9yRpI3JLldkhOTnFZV+2xlHQAAAItp3lB8WpKbJTlhnT5PS7J/kpdvdFAbUVXXTnJKkouSvGqdfsckOS7JhUnu2N0P7O6jk9w2yYeSHJ3kMVtVBwAAwOKaNxSfmFkA/JWqeltV/ea0/pCqOraq3pzk0ZmdJX7RFo5zTzwlyfcn+eUkl6zT74lT+/ju/sjSyu6+KMmx0+ITVrkceqN1AAAALKi5Atw04/T9krwryd2TPHPadGRmgfneSc5K8oDu/trWDXN9VXXXJL+V5KXd/ep1+h2U5LAkX0ty6srt3X16kgsye87y3TZbBwAAwGLbd96C7r4gyd2r6ieS/GRmM1Lvk+T8JK9N8sruXvee3q003d/8v5N8PsmvXU33u0zt2d19+Rp93pPZ46TukuQdm6wDAABggc0dipd09+uSvG4Lx7JRf5Tk9kl+trs/ezV9D53a89bp84kVfTdTBwAAwALb1fe/VtXdk/x6Zmen/3YPSvaf2i+t02fpUVLX34I6AAAAFtiuDcVVdd0kf5nki5nNCr1HZVM77+XdG6379p1UPXp6rvGZF1988WZ2BQAAwBbYtaE4s0c/3S7Jb3b3p/ew5tKp3X+dPkvbLl22bqN136a7X9jdh3f34QceeOC6AwUAAGD7bfie4gVwdJIrkzy8qh6+Ytt/mtpjq+qBST7a3Y9Kcu60/uB19nurqT132bqN1gEAALDAdnMoTmZnuo9cZ/utp9eNpuX3Te0dquq6a8wkfcSKvpupAwAAYIHt2sunu/uQ7q7VXpk9oilJHjutu/NUc35mz1HeL8lDVu6zqo5MclCSC5O8c9l7bagOAACAxbZrQ/EmPH1qn1FVt1laWVU3S/K8afGE7r5yi+oAAABYULv98um5dfdpVXVykmOTfKCq3pjkiiRHJblBklcmOXGr6gAAAFhcw4XiJOnu46rqbUmOz+ye5H2SnJPkxUlOXuts70brAAAAWEzXyFDc3Y9I8oir6fPSJC/dwL43VAcAAMDiGfGeYgAAAEgiFAMAADAwoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWEIxAAAAwxKKAQAAGJZQDAAAwLCEYgAAAIYlFAMAADAsoRgAAIBhCcUAAAAMSygGAABgWLs6FFfVtarqqKp6dlX9c1V9uqq+VlUXVNVpVXXvq6l/WFWdUVWXVNVlVXVmVR1fVet+LhutAwAAYLHs9hB3ZJI3JvnNJAcneW+SVyT5fJJjkrylqp6yWmFVnZTkJUkOT3JGkjckuV2SE5OcVlX7bGUdAAAAi2e3h+Irk/xdknt19y27+4Hd/dDu/sEkP5vkG0l+v6rus7yoqo5JclySC5Pccao7Osltk3woydFJHrPyzTZaBwAAwGLa1aG4u9/c3Q/u7jNW2fa3SU6ZFn9+xeYnTu3ju/sjy2ouSnLstPiEVS6H3mgdAAAAC+iaHt7eN7UHLa2oqoOSHJbka0lOXVnQ3acnuSDJLZLcbbN1AAAALK5reii+7dR+etm6u0zt2d19+Rp171nRdzN1AAAALKhrbCiuqlskecS0+HfLNh06teetU/6JFX03UwcAAMCCukaG4qraN8nfJLlhkjd196uXbd5/ar+0zi4um9rrb0EdAAAAC+oaGYqTPD/JUUnOz1Un2aqp7Tn3udG6b+2g6tHTM43PvPjiize6GwAAALbINS4UV9VzkvxiZo9NOqq7L1zR5dKp3T9rW9p26bJ1G637pu5+YXcf3t2HH3jggevsBgAAgJ1wjQrFVfXsJL+a5OLMAvFHVul27tQevM6ubrWi72bqAAAAWFDXmFBcVX+c5DeTfC7Jj3X3B9fouvSYpjtU1XXX6HPEir6bqQMAAGBBXSNCcVWdkOSxSb6QWSB+/1p9u/v8JGcl2S/JQ1bZ15GZPdf4wiTv3GwdAAAAi2vXh+KqemqSxyf5j8wC8Z6cpX361D6jqm6zbF83S/K8afGE7r5yi+oAAABYQPvu7QFsRlX9dJLfmxY/muRXqmq1rud09wlLC919WlWdnOTYJB+oqjcmuSKzGatvkOSVSU5cuZON1gEAALCYdnUoTnKTZf8+fHqt5vQkJyxf0d3HVdXbkhyf5Mgk+yQ5J8mLk5y81tnejdYBAACweHZ1KO7uU5Kcson6lyZ56U7VAQAAsFh2/T3FAAAAsFFCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADEsoBgAAYFhCMQAAAMMSigEAABiWUAwAAMCwhGIAAACGJRRvUFU9rKrOqKpLquqyqjqzqo6vKp8pAADALiHAbUBVnZTkJUkOT3JGkjckuV2SE5OcVlX77MXhAQAAsIeE4jlV1TFJjktyYZI7dvcDu/voJLdN8qEkRyd5zF4cIgAAAHtIKJ7fE6f28d39kaWV3X1RkmOnxSe4jBoAAGDxCW5zqKqDkhyW5GtJTl25vbtPT3JBklskudvOjg4AAIB5CcXzucvUnt3dl6/R5z0r+gIAALCghOL5HDq1563T5xMr+gIAALCghOL57D+1X1qnz2VTe/1tHgsAAACbtO/eHsAuU1PbGyquenSSR0+Ll1XVh7dkVMCSA5J8dm8PAuZVz9jbIwAWjOMZu9KCH88OXmuDUDyfS6d2/3X6LG27dOWG7n5hkhdu9aCAmao6s7sP39vjAIDNcDyDneXy6fmcO7Vr/pUhya1W9AUAAGBBCcXzed/U3qGqrrtGnyNW9AUAAGBBCcVz6O7zk5yVZL8kD1m5vaqOTHJQkguTvHNnRwfE7QkAXDM4nsEOqu4NzRk1rKp6cJJTMwu+P9rdH53W3yzJW5J8f5Jf7+7n7L1RAgAAsCeE4g2oquclOTbJV5K8MckVSY5KcoMkr0zy4O7+xl4bIAAAAHvE5dMb0N3HJfmvmV1KfWSSH0/y0SSPSXKMQMzeVFXnVlVX1SEr1p8yrX/E3hkZGzH9N/PXS4BdqKqePP0ef/LeHsveVFWHTJ/DuXt7LLAaj2TaoO5+aZKX7u1xAAAAsHHOFMM4npjk+5K8Ym8PBAAAFoUzxTCI7v50kk/v7XEAAMAicaYYBrHWPcXL73eqqptX1Quq6pNV9dWq+nhVnVBV11lnv3etqpdNNV+rqour6h+q6p7r9H9mVZ1ZVRdNNZ+qqtOq6m5r1Cwf48FV9ZfT+329qv5sD372R0z1p1TVjavqz6vqE1V1eVV9qKp+eVnfO1TVy6exXV5V766qH19n39erqsdV1Xuq6otTzdnTWPdfpf8+VfXLVfWOqrpk+vkvqqqzqurZVXXgOu/10Kp6Z1VdVlWXVtWb1vqcAa4JquoHq+oVVfX5qvrS9LvyUdO2q8y5sCf3rq41V8NGjk9T3bWq6rer6oNV9ZWqurCq/rqqDt7Ej77Wey0/Hh40Hdc+XVVfnj6bBy/re4+q+seq+ty0/S1VdcQ6+75pVf1hVX1gOs4sfd6/UVXXWqX/darqCVOfy6bvDZ+ejlN/uNZ3h5o5rqr+ZRrXF6rqVVX1A1vzKcH8nCkGltwqyXuTVJJ3ZDab+j2TPD6zR4399MqCqvqtJM+cFs/K7PncByV5QJIHVNUvd/dfrCj7oyT3TnJ2kncn+WqS2yc5JsmDqurnuvvUNcZ42yTvy2zm97dn9jvsP+b4GW80jfEGSd6W5KZJ7pXk5Kq6YZK3Jvm/Sc7L7BFrt01yRJLXVNV9u/utK37+g5K8PrPP5+Jp31+Zav5nkqOr6t7d/YVlZS9K8vAkl09j+GySA5J8b5LfzOyRbxevHHhVPSXJ7041r0lyxyT3TXLP6T08Gx24RqmqI5O8Nsl1k3w4s9//t0zygqr6/m14y7mPT1X1HUn+PskDM/v9/+Ykl2b2VJL7Z/b7ejscnNkx+7Ikp2d27L1HkpdX1cOmsf9tkn9J8oYkd5p+trdU1Q9197+t+Dl+MMnrknxXkk8m+afMTp7dNcmfZHZM/8nu/trU/zumn+2+SS6ZxnBJkptn9pn9bpITM3uE6UqnJHloZsfcj2R2zPzpJPeuqrt098c288HAhnS3l5fXNeiV5NwkneSQFetPmdY/YsX6J0/rO8lfJNlv2bbvy+zg3knusaLuJ6b1FyS564pt98js4Pi1JLdbpe7mq4z7p6b+n0vyneuM8S+Xj3EPP5NHLKs/Ncl1lm27/7T+0umz+60Vtc+ctr9pxfqlPx50kucuH3NmX+D+etp2yrL1B0/rPrHGZ3DnJDdbsW5p3J9Lctiy9d+R5IXTtjfs7f/vvLy8vLbyNf0e/eT0O+5pmR4jOm07MsmXln4/rqg7ZFp/7jr7vkrdtH4jx6dfmfb3ySS3Wbb+OklOW/Y7/Mlb9LksPx7+WZJ9lm07dlp/fpLPJ3nIsm3fkeRl0/YXrfJZf2za9sQk+y7bdpPMQvW3/QyZ/UG5Mwvm11uxv8rse8Dy4+LSf5ee3ut7l227dmYBu5P8xd7+f89rzJfLp4El5yf51Z7+Cpwk3f2hzMJdMvur93J/MLWP6u53Ld/Q3W9P8tQk10ryP1Zse113X7Tyzbv71ZkF1pskuc8aY/z8yjHO6dIkx3b3V5a972uTvD/J/kk+1d3PXlHz9Km954rLx34iyY8k+eckv9bdX162z8uT/HKSzyT5r1V142nTzab2rDU+g3/p7s+sMfb/2d3vXdb3yiS/Ny3+6GqXtgHsYg9O8t1J/j3J73f3Ny937u7Tkzx/q99wg8enX5/a3+vujy6r+UqS4zK7Kmg7nJfkcf3tjwF9YWbB/aAkr+tlZ7WnY8YzpsWVP8Mjkhya5OXd/fTu/vqyus9ndnXTFUmOr6qaNt18as/o7i8t31nPvH35cXGFX+3uf1/W/6v51neKld81YEcIxcCSN09hbqVzpva7llZU1QGZXe70xcwuN17N6VP7Iys3VNUBNbvP91lV9b+me6JOSbJ0P9Ht1tjnG7r70qv5OdZzZnd/dpX1S19kXrdyw/SF4HNJ9svscuslPzm1fzd92VhZ96UkZ2Z2iffSPVznZBbMH1BVvzPn/Wb/Z5X3+EySL2T2V/abXqUCYPc6cmpftiL4LfnrVdZt2jzHp+kWmlsnuTKrPKZz+h291jFys9688g/E0+d07rR4leNZZpcqJ8uO55Ol49mqty5196em2gMyu60omd0y9Y0kvzjdH3zz1WpX8fU1xnaV7xqwk9xTDCz5xBrrvzi1yyfMODSzy6NukOTr3/rD8aq+beKoqvofmd2f9J3r1NxgjfXnrfdGe+CTa6y/bA+23zTf/hncemqfWVXPvGrJtzkwSbr70qp6ZJIXZ3bv2h9V1QWZ3Yv8msy+/H1ljX2s99/nxivGBrDbHTS1H19j+7lb/YYbOD4tjfFT61zBdO4WDG01cx/Puvuy6Xh97RWblo5np17N8TyZHc/+rbv/vap+I8mzkpyU5KSq+lhmtxW9Kskr1vhjxqeXn4leNrYvrjE22BFCMbDkKmc717HP1F6S5JVX0/ebZ2ar6vAkJ2f2l+LHJnl1ZgfuL3d3V9XTMrufaa2j8mYvQ7u6n3Ejn8HpufovPd8M8919WlW9McnPZHZP1j0yu0zwwUmeXFU/2t3nr9zBamejAQZ2ldmj98Q0QdRq6zd7fNpp23E8e02WHbPX8Lmlf3T3c6vq1CQPymxiznsm+fnp9S9VdWR3f3FFvWMZC0koBjZiKbRd0d2PmKPuwZl9ofjz7n7WKttvs9mB7aClz+DU7j5pnsLu/o8k/3t6paq+N7NJzu6T2T1fD9u6YQLsShdM7SFrbD90jfVLZ2yv8ki8yVq3rWzk+LQ0xu+qqv3WOFt8yBrvt0jOz2zG6JO7e67Zsrv7wszu735+klTVnTK7tP3OSZ6Q5He2dKSwTdxTDMytuy9I8oEkB1TVvecovcnUXuVMaM2ez/tjmx7cznnt1D5kszuaJhz5o2nxTpvdH8A1wNK8FD9bVfussv2/rlF3cWbB+Ka1+nPff3KVdckGjk/TVT0fz+z79M/uad0C2srj2fuTPGdadDxj1xCKgY36/an9m6q638qNVbVfVf10VS2faGtpIo1fqKr9l/W9fmb32d5ouwa7DV6Z2aMojqyq51fVTVZ2qKpbV9Xxy5bvUlUPrarrrrK/n5razd43DXBNcFqST2d2hvbJy2Y9TlXdM7PHD11Fd1+R5Ixp8Smr1D1ljffb6PHpz6f2D6tq6d7cVNW1M7vXdtX7k6vqu6vqnOn13Wvse6e8MLM/Bjy8qv6gqq4y5qr6gar678uW71tVP1lV+67ot0++9YcHxzN2DZdPAxvS3a+qqt9K8sdJXl9V/5bkw5n9hf5WmV2KdcPMvri8cyr7y8weX/FDST5WVW/L7HK1e011L07yyB38MTasu6+sqgcl+cfMHjv1sKp6f2b3oB2Q5Hsym6X0osy+GCWzy/ZeluTLVXVWZl9C9ktyl8wmOrk0yZN28McAWEjd/eWq+vnM7nP9vSQPrqr3JbllZseM5yT5jTXKn5TkRzN7NN6RVXV2Zr9/D8vsmce/t0rNRo9Pz01yv8yeeX92Vb05s8mu7pnZBIh/leQXVqm7VmbHyaV/7zXTBFwPyOwpB09K8piq+tckF2b26KVDM7sM/F2ZfU5Jcsckf5rkkul49unM/gBw18z+G12Ybz0CChaeM8XAhnX3n2T2JeNFmU3U8WNJfjyz2ZBPT/JLSV6+rP8Xkhye2V+lL0vygGn57zP7InKVy9YWWXd/MskPJ3lMkvcluUOSYzJ7dMelmc3K+V+WlfxzZhO1vDWzWUsflOQ/J/lykmcn+cHuPnOHhg+w0Lr7zUnuluQfktwis9+ZN05yfHf/5jp178jsebdvyuyPtEtnLn+hu39/jZoNHZ+mGZZ/JrP7Z8/N7Hf6fTL7PX941p49e6F09wcyC7q/k9njl34os+PX7TILuE9N8uhlJa/O7NnCZ2V2Nv+YzP4QcWGS/5nkjt3tTDG7Ri17FjoAAOwKVdVJ0t2LMiM0sEs5UwwAAMCwhGIAAACGJRQDAAAwLPcUAwAAMCxnigEAABiWUAwAAMCwhGIAAACGJRQDAAAwLKEYAACAYQnFAAAADOv/B1L0u84IOnp4AAAAAElFTkSuQmCC",
+ "image/png": "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",
"text/plain": [
"<Figure size 864x720 with 1 Axes>"
]
@@ -800,13 +689,6 @@
"plt.show()"
]
},
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The differences observed for the OGS6 results in comparision to the analytical solution can be primarily explained by mesh discretization and finite size effects."
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -842,7 +724,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.4"
+ "version": "3.9.10"
}
},
"nbformat": 4,