From c5a2b2214ed4d8774913466ab2a1cc91c3099f83 Mon Sep 17 00:00:00 2001 From: Adam Cheng <52572642+adamchengtkc@users.noreply.github.com> Date: Fri, 1 Nov 2024 12:41:34 +0000 Subject: [PATCH] implement erosion --- docs/notebooks/Build_within_Python.ipynb | 521 ++++++++++++++++-- .../temperer3D_hypothetical_extended.py | 297 ---------- warmth/build.py | 2 + warmth/forward_modelling.py | 60 +- warmth/postprocessing.py | 4 + 5 files changed, 527 insertions(+), 357 deletions(-) delete mode 100644 tests/benchmark/temperer3D_hypothetical_extended.py diff --git a/docs/notebooks/Build_within_Python.ipynb b/docs/notebooks/Build_within_Python.ipynb index 56fef24..5597c3e 100644 --- a/docs/notebooks/Build_within_Python.ipynb +++ b/docs/notebooks/Build_within_Python.ipynb @@ -39,20 +39,42 @@ "source": [ "import pandas as pd\n", "node_template=model.builder.single_node_sediments_inputs_template\n", - "h1 = [152.0,0.0,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0]\n", - "h2=[810.0,20.0,1.538462,2.079433e-09,0.599730,0.490,2708.0,2437.2]\n", - "h3=[1608.0,66,1.500000,2.301755e-09,0.2,0.500,2720.0,2448.0]\n", - "h4=[1973.0,100,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0]\n", - "h5=[2262.0,145,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0]\n", - "h6=[2362.0,152,1.904762,4.719506e-10,0.447705,0.415,2618.0,2356.2]\n", - "h7=[2427.0,160,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0]\n", + "h1 = [152.0,0.0,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0,0]\n", + "h2=[810.0,20.0,1.538462,2.079433e-09,0.599730,0.490,2708.0,2437.2, 0,0]\n", + "h3=[1608.0,66,1.500000,2.301755e-09,0.2,0.500,2720.0,2448.0, 0,0]\n", + "h4=[1973.0,100,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 100, 5]\n", + "h5=[2262.0,145,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0,0]\n", + "h6=[2362.0,152,1.904762,4.719506e-10,0.447705,0.415,2618.0,2356.2, 0,0]\n", + "h7=[2362.0,160,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0,0]\n", "horizons=[h1,h2,h3,h4,h5,h6,h7]\n", "for i in horizons:\n", - " new =pd.DataFrame.from_dict({'top': [i[0]], 'topage': [int(i[1])], 'k_cond': [i[2]], 'rhp':[i[3]], 'phi':[i[4]], 'decay':[i[5]], 'solidus':[i[6]],'liquidus':[i[7]]})\n", + " new =pd.DataFrame.from_dict({'top': [i[0]], 'topage': [int(i[1])], 'k_cond': [i[2]], 'rhp':[i[3]], 'phi':[i[4]], 'decay':[i[5]], 'solidus':[i[6]],'liquidus':[i[7]], 'erosion': [i[8]], \"erosion_duration\": [i[9]]})\n", " node_template = pd.concat([node_template, new], ignore_index=True)\n", " " ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas as pd\n", + "# node_template=model.builder.single_node_sediments_inputs_template\n", + "# h1 = [152.0,0.0,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0,0]\n", + "# h2=[810.0,20.0,1.538462,2.079433e-09,0.599730,0.490,2708.0,2437.2, 0,0]\n", + "# h3=[1608.0,66,1.500000,2.301755e-09,0.2,0.500,2720.0,2448.0, 0,0]\n", + "# h4=[1973.0,100,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0, 0]\n", + "# h5=[2262.0,145,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0,0]\n", + "# h6=[2362.0,152,1.904762,4.719506e-10,0.447705,0.415,2618.0,2356.2, 0,0]\n", + "# h7=[2427.0,160,1.500000,2.301755e-09,0.620000,0.500,2720.0,2448.0, 0,0]\n", + "# horizons=[h1,h2,h3,h4,h5,h6,h7]\n", + "# for i in horizons:\n", + "# new =pd.DataFrame.from_dict({'top': [i[0]], 'topage': [int(i[1])], 'k_cond': [i[2]], 'rhp':[i[3]], 'phi':[i[4]], 'decay':[i[5]], 'solidus':[i[6]],'liquidus':[i[7]], 'erosion': [i[8]], \"erosion_duration\": [i[9]]})\n", + "# node_template = pd.concat([node_template, new], ignore_index=True)\n", + " " + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -62,14 +84,18 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/workspaces/warmth/warmth/build.py:199: FutureWarning: In a future version, the Index constructor will not infer numeric dtypes when passed object-dtype sequences (matching Series behavior)\n", + "/workspaces/warmth/warmth/build.py:224: FutureWarning: In a future version, the Index constructor will not infer numeric dtypes when passed object-dtype sequences (matching Series behavior)\n", + " check_ascending = df.apply(lambda x: x.is_monotonic_increasing)\n", + "/workspaces/warmth/warmth/build.py:224: FutureWarning: In a future version, the Index constructor will not infer numeric dtypes when passed object-dtype sequences (matching Series behavior)\n", + " check_ascending = df.apply(lambda x: x.is_monotonic_increasing)\n", + "/workspaces/warmth/warmth/build.py:224: FutureWarning: In a future version, the Index constructor will not infer numeric dtypes when passed object-dtype sequences (matching Series behavior)\n", " check_ascending = df.apply(lambda x: x.is_monotonic_increasing)\n" ] }, @@ -102,11 +128,14 @@ " decay\n", " solidus\n", " liquidus\n", + " erosion\n", + " erosion_duration\n", " base\n", " baseage\n", " thickness\n", " grain_thickness\n", " phi_mean\n", + " eroded_grain_thickness\n", " \n", " \n", " \n", @@ -120,11 +149,14 @@ " 0.500\n", " 2720.0\n", " 2448.0\n", + " 0\n", + " 0\n", " 810.0\n", " 20\n", " 658.0\n", " 0.310357\n", " 0.528332\n", + " 0.000000\n", " \n", " \n", " 1\n", @@ -136,11 +168,14 @@ " 0.490\n", " 2708.0\n", " 2437.2\n", + " 0\n", + " 0\n", " 1608.0\n", " 66\n", " 798.0\n", " 0.511062\n", " 0.359571\n", + " 0.000000\n", " \n", " \n", " 2\n", @@ -152,11 +187,14 @@ " 0.500\n", " 2720.0\n", " 2448.0\n", + " 0\n", + " 0\n", " 1973.0\n", " 100\n", " 365.0\n", " 0.332780\n", " 0.088275\n", + " 0.000000\n", " \n", " \n", " 3\n", @@ -168,11 +206,14 @@ " 0.500\n", " 2720.0\n", " 2448.0\n", + " 100\n", + " 5\n", " 2262.0\n", " 145\n", " 289.0\n", " 0.221878\n", " 0.232256\n", + " 0.076774\n", " \n", " \n", " 4\n", @@ -184,11 +225,14 @@ " 0.500\n", " 2720.0\n", " 2448.0\n", + " 0\n", + " 0\n", " 2362.0\n", " 152\n", " 100.0\n", " 0.078943\n", " 0.210571\n", + " 0.000000\n", " \n", " \n", " 5\n", @@ -200,11 +244,14 @@ " 0.415\n", " 2618.0\n", " 2356.2\n", - " 2427.0\n", + " 0\n", + " 0\n", + " 2362.0\n", " 160\n", - " 65.0\n", - " 0.053525\n", - " 0.176536\n", + " 0.0\n", + " 0.000000\n", + " 0.000000\n", + " 0.000000\n", " \n", " \n", "\n", @@ -219,16 +266,24 @@ "4 2262.0 145 1.500000 2.301755e-09 0.620000 0.500 2720.0 2448.0 \n", "5 2362.0 152 1.904762 4.719506e-10 0.447705 0.415 2618.0 2356.2 \n", "\n", - " base baseage thickness grain_thickness phi_mean \n", - "0 810.0 20 658.0 0.310357 0.528332 \n", - "1 1608.0 66 798.0 0.511062 0.359571 \n", - "2 1973.0 100 365.0 0.332780 0.088275 \n", - "3 2262.0 145 289.0 0.221878 0.232256 \n", - "4 2362.0 152 100.0 0.078943 0.210571 \n", - "5 2427.0 160 65.0 0.053525 0.176536 " + " erosion erosion_duration base baseage thickness grain_thickness \\\n", + "0 0 0 810.0 20 658.0 0.310357 \n", + "1 0 0 1608.0 66 798.0 0.511062 \n", + "2 0 0 1973.0 100 365.0 0.332780 \n", + "3 100 5 2262.0 145 289.0 0.221878 \n", + "4 0 0 2362.0 152 100.0 0.078943 \n", + "5 0 0 2362.0 160 0.0 0.000000 \n", + "\n", + " phi_mean eroded_grain_thickness \n", + "0 0.528332 0.000000 \n", + "1 0.359571 0.000000 \n", + "2 0.088275 0.000000 \n", + "3 0.232256 0.076774 \n", + "4 0.210571 0.000000 \n", + "5 0.000000 0.000000 " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -241,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -251,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -263,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -272,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -282,59 +337,437 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model.simulator.run(parallel=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 392.18966294])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].sed[3,:,105]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 100.00000003])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].sed[4,:,145]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[106.69464777, 96.0018977 , 85.3144162 , 74.63216746,\n", + " 63.95511599, 53.28322661, 42.61646442, 31.95479482,\n", + " 21.29818352, 10.64659649, 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ,\n", + " 0. , 0. , 0. , 0. ,\n", + " 0. , 0. ],\n", + " [395.69464785, 385.00189778, 374.31441628, 363.63216754,\n", + " 352.95511607, 342.28322669, 331.6164645 , 320.9547949 ,\n", + " 310.2981836 , 299.64659657, 289.00000008, 309.49292264,\n", + " 330.05683797, 350.69323438, 371.40364761, 392.18966294,\n", + " 382.07291794, 371.97424472, 361.89345648, 351.83036934,\n", + " 341.78480222, 331.75657683, 321.74551762, 311.75145167,\n", + " 301.77420866, 291.81362086, 281.869523 , 271.94175228,\n", + " 262.03014828, 252.13455294]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].sed[3,:,90:120]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'depth': array([1101.24337715, 1390.24337723]),\n", + " 'layerId': array([3], dtype=int32),\n", + " 'values': array([ 5. , 29.85663711])}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t100=model.builder.nodes[0][0].result.temperature(100,3)\n", + "t100" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'depth': array([1132.49870093, 1514.57161886]),\n", + " 'layerId': array([3], dtype=int32),\n", + " 'values': array([ 5. , 35.76844093])}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t106=model.builder.nodes[0][0].result.temperature(106,3)\n", + "t106" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(382.0729179378675, 289.00000008015945, True)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check if approx. 100m is eroded\n", + "t106[\"depth\"][-1]-t106[\"depth\"][0], t100[\"depth\"][-1]-t100[\"depth\"][0],t106[\"depth\"][-1]-t106[\"depth\"][0]> t100[\"depth\"][-1]-t100[\"depth\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'depth': array([1101.24337715, 1390.24337723]),\n", + " 'layerId': array([3], dtype=int32),\n", + " 'values': array([ 5. , 29.85663711])}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].result.temperature(100,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[106.6570553 , 105.11554665, 103.591928 , 102.08327862,\n", + " 100.58708382, 99.1011563 , 97.62357829, 96.15265939,\n", + " 94.68690698, 93.22500735, 91.76581749, 90.30836846,\n", + " 88.85188384, 87.39581967, 85.93993931, 84.48445037,\n", + " 83.03026552, 81.57954601, 80.13702106, 78.71409179,\n", + " 77.3623651 , 76.43814443, 75.51263858, 74.58565072,\n", + " 73.65698814, 72.72646146, 71.79388402, 70.85907131,\n", + " 69.92184055, 68.9820103 , 68.03940012, 67.09383013,\n", + " 66.14512073, 65.19309225, 64.23756455, 63.27835673,\n", + " 62.31528676, 61.34817109, 60.37682435, 59.40105892,\n", + " 58.42068463, 57.43550839, 56.44533391, 55.44996138,\n", + " 54.4491873 , 53.44280441, 52.43060164, 51.41236437,\n", + " 50.38787481, 49.35691261, 48.31925582, 47.27468209,\n", + " 46.2229703 , 45.16390251, 44.09726668, 43.02286015,\n", + " 41.9404948 , 40.85000472, 39.7512583 , 38.644178 ,\n", + " 37.52877339, 36.40519966, 35.27386756, 34.13567221,\n", + " 32.99254109, 31.84896434, 30.72706537, 30.32354689,\n", + " 29.92027549, 29.51726579, 29.11453301, 28.71209295,\n", + " 28.30996203, 27.90815733, 27.50669657, 27.10559818,\n", + " 26.7048814 , 26.30456636, 25.90467422, 25.5052274 ,\n", + " 25.10624986, 24.70776751, 24.30980874, 23.91240515,\n", + " 23.5155926 , 23.11941257, 22.7239142 , 22.32915727,\n", + " 21.93521718, 21.54219439, 21.15023686, 20.75961049,\n", + " 20.37102305, 19.98900372, 19.60190241, 19.21687054,\n", + " 18.83041082, 18.45480869, 18.0871706 , 17.73530965,\n", + " 17.42831856, 18.14931725, 18.84770421, 19.51827317,\n", + " 20.14970949, 20.72683418, 20.38422047, 20.03984211,\n", + " 19.69366033, 19.34563472, 18.99572309, 18.64388142,\n", + " 18.29006376, 17.93422214, 17.57630648, 17.21626435,\n", + " 16.85404078, 16.48957771, 16.12281328, 15.75368048,\n", + " 15.38210494, 15.00800072, 14.63126142, 14.25173706,\n", + " 13.86915348, 13.48269239, 13.0828468 , 12.69321528,\n", + " 12.30055568, 11.90476492, 11.50573626, 11.10336462,\n", + " 10.69756342, 10.28832791, 9.87606774, 9.46547053,\n", + " 9.04251561, 8.6150054 , 8.18268437, 7.74527456,\n", + " 7.30247879, 6.85399218, 6.39953383, 5.93892351,\n", + " 5.47223937]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].result.temperature_history(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 612 ms, sys: 0 ns, total: 612 ms\n", - "Wall time: 624 ms\n" + "50 289.00000008015934 623.8586733813934\n", + "51 289.00000008015934 607.2213071302128\n", + "52 289.00000008015934 590.6507413446849\n", + "53 289.00000008015934 574.1456471968345\n", + "54 289.00000008015945 557.7047365658027\n", + "55 289.00000008015945 541.3267603247834\n", + "56 289.00000008015934 525.0105067194031\n", + "57 289.0000000801595 508.7547998316465\n", + "58 289.0000000801594 492.55849812388595\n", + "59 289.0000000801594 476.420493057967\n", + "60 289.00000008015945 460.3397077846812\n", + "61 289.00000008015934 444.3150958992925\n", + "62 289.00000008015945 428.34564025909697\n", + "63 289.0000000801594 412.4303518592812\n", + "64 289.00000008015945 396.56826876360594\n", + "65 289.00000008015945 380.75845508668704\n", + "66 289.0000000801594 365.0000000248629\n", + "67 289.0000000801594 354.16920791639967\n", + "68 289.0000000801595 343.3446447066356\n", + "69 289.00000008015934 332.52626612615256\n", + "70 289.0000000801594 321.7140283081515\n", + "71 289.0000000801595 310.9078877836543\n", + "72 289.0000000801594 300.1078014767773\n", + "73 289.0000000801594 289.31372670007676\n", + "74 289.0000000801595 278.52562114996414\n", + "75 289.00000008015934 267.7434429021904\n", + "76 289.0000000801594 256.9671504073976\n", + "77 289.00000008015945 246.19670248673742\n", + "78 289.00000008015945 235.43205832755396\n", + "79 289.0000000801595 224.67317747913108\n", + "80 289.0000000801594 213.9200198485026\n", + "81 289.00000008015934 203.17254569632357\n", + "82 289.00000008015934 192.43071563280276\n", + "83 289.00000008015934 181.69449061369423\n", + "84 289.0000000801594 170.9638319363474\n", + "85 289.0000000801594 160.23870123581463\n", + "86 289.00000008015945 149.51906048101495\n", + "87 289.00000008015945 138.80487197095349\n", + "88 289.00000008015945 128.0960983309948\n", + "89 289.0000000801594 117.39270250919022\n", + "90 289.00000008015945 106.69464777265725\n", + "91 289.0000000801594 96.00189770401083\n", + "92 289.0000000801594 85.3144161978452\n", + "93 289.0000000801594 74.63216745726561\n", + "94 289.00000008015945 63.95511599046893\n", + "95 289.0000000801594 53.28322660737255\n", + "96 289.00000008015945 42.61646441629042\n", + "97 289.00000008015945 31.954794820655565\n", + "98 289.00000008015945 21.298183515788494\n", + "99 289.0000000801594 10.64659648571028\n", + "100 289.0000000801594 0.0\n", + "101 309.49292263544874 0.0\n", + "102 330.0568379682975 0.0\n", + "103 350.69323438305656 0.0\n", + "104 371.403647614353 0.0\n" ] } ], "source": [ - "%%time\n", - "model.simulator.run(parallel=False)\n" + "# Check no decompaction with eroded\n", + "for i in np.arange(50,105,1, dtype=int):\n", + " val=model.builder.nodes[0][0].sed[3,:,i]\n", + " print(i,val[-1]-val[0],val[0])" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([1.24])" + "{'depth': array([1388.00031556, 1532.29690032]),\n", + " 'layerId': array([3], dtype=int32),\n", + " 'values': array([ 5. , 18.01147252])}" ] }, - "execution_count": 10, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model.builder.nodes[0][0].beta" + "model.builder.nodes[0][0].result.temperature(130,3)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'depth': array([1419.71836667, 1467.48613325]),\n", + " 'layerId': array([3], dtype=int32),\n", + " 'values': array([5. , 9.60495758])}" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].result.temperature(140,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'depth': array([1101.24337715, 1390.24337723]),\n", + " 'layerId': array([3], dtype=int32),\n", + " 'values': array([ 5. , 29.85663711])}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].result.temperature(100,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.57257098, 0.56449831, 0.5557808 , 0.54636738, 0.53660084,\n", + " 0.52699765, 0.51803655, 0.51003539, 0.5030884 , 0.49700575,\n", + " 0.49129801, 0.48532988, 0.47862181, 0.47108245, 0.46300757,\n", + " 0.45489378, 0.44722622, 0.44034833, 0.43442679, 0.42947088,\n", + " 0.42535714, 0.42176267, 0.41838187, 0.41502835, 0.41150027,\n", + " 0.40762814, 0.40331713, 0.39856731, 0.39346663, 0.38816341,\n", + " 0.38283101, 0.37763611, 0.37271715, 0.36817366, 0.36406297,\n", + " 0.36039718, 0.35713368, 0.35416115, 0.35129674, 0.3483129 ,\n", + " 0.34499494, 0.34120534, 0.33692373, 0.33224567, 0.32734682,\n", + " 0.32243298, 0.31769597, 0.31328594, 0.30930071, 0.30578612,\n", + " 0.30273703, 0.30008969, 0.29771081, 0.29540695, 0.2929723 ,\n", + " 0.29025855, 0.28722598, 0.28394732, 0.28056944, 0.27725996,\n", + " 0.27416383, 0.27138075, 0.2689615 , 0.26691575, 0.26522406,\n", + " 0.26384954, 0.26274523, 0.26179052, 0.26089588, 0.26005943,\n", + " 0.25927872, 0.25855073, 0.2578719 , 0.25723812, 0.25664476,\n", + " 0.25608681, 0.2555589 , 0.25505556, 0.25457137, 0.25410119,\n", + " 0.25364036, 0.25318486, 0.25273147, 0.25227783, 0.25182247,\n", + " 0.25136476, 0.25090484, 0.25044349, 0.24998204, 0.24952216,\n", + " 0.24906577, 0.24861488, 0.24817145, 0.24773708, 0.24731359,\n", + " 0.24690283, 0.24650625, 0.24612462, 0.24575808, 0.24540637,\n", + " 0.24506758, 0.24469605, 0.24423462, 0.24366052, 0.24294545,\n", + " 0.24205559, 0.24106188, 0.24006738, 0.23907848, 0.23810123,\n", + " 0.23714118, 0.23620331, 0.235292 , 0.23441096, 0.23356323,\n", + " 0.23275124, 0.23197678, 0.23124108, 0.23054486, 0.22988835,\n", + " 0.22927139, 0.22869346, 0.22815375, 0.22765121, 0.22718459,\n", + " 0.22675254, 0.22635408, 0.22598739, 0.22565016, 0.22534073,\n", + " 0.22505741, 0.22479855, 0.22456252, 0.22434773, 0.22415264,\n", + " 0.22397565, 0.22381545, 0.22367088, 0.22354069, 0.22342369,\n", + " 0.22331876, 0.22322487, 0.22314105, 0.22306637, 0.223 ]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.builder.nodes[0][0].result.vitrinite_reflectance_history(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/workspaces/warmth/warmth/postprocessing.py:199: RuntimeWarning: invalid value encountered in divide\n", + "/workspaces/warmth/warmth/postprocessing.py:194: RuntimeWarning: invalid value encountered in divide\n", " v=-1*initial_poro/initial_decay*phi1\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGwCAYAAACzXI8XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfkklEQVR4nO3dd1xV9f8H8Ne5l40s2cgWBWUobtwDV6U5SjM102yYaVo2/JWm38rRtGmlldlSy5WWe+DCBYIiiggKyhAB2fve8/sDvUmIwuVezr2X1/PxuI/knMu574/SvS8+5zMEURRFEBEREekhmdQFEBEREamLQYaIiIj0FoMMERER6S0GGSIiItJbDDJERESktxhkiIiISG8xyBAREZHeMpK6AG1TKpVIT0+HlZUVBEGQuhwiIiKqB1EUUVhYCDc3N8hkdfe7GHyQSU9Ph4eHh9RlEBERkRquXbsGd3f3Os8bfJCxsrICUP0XYW1tLXE1REREVB8FBQXw8PBQfY7XxeCDzJ3bSdbW1gwyREREeuZBw0I42JeIiIj0FoMMERER6S0GGSIiItJbDDJERESktxhkiIiISG8xyBAREZHeYpAhIiIivcUgQ0RERHqLQYaIiIj0FoMMERER6S0GGSIiItJbDDJERESktxhk1CSKIvbE34AoilKXQkRE1GwxyKhBFEXMXR+DZ9eexvdHrkhdDhERUbPFIKMGQRDQwcMWALB0x0UcS8qWtiAiIqJmikFGTU/39Mbo0FZQKEXM+u0M0vNKpS6JiIio2WGQUZMgCFgyOhjtXa2RU1yBF36JQlmlQuqyiIiImhUGmUYwN5Hj28mdYWthjLPX8/H1wSSpSyIiImpWGGQayaOlBd4fFQwA+OZgEpJvFklcERERUfPBIKMBDwW7oG9bR1QolFi49TynZBMRETURBhkNEAQB/xsZCBMjGY5czsb2sxlSl0RERNQsMMhoiLeDJWb29wMAvLs9HkXlVRJXREREZPgYZDTohf6+8La3QFZhOVYevCx1OURERAaPQUaDTI3k+L+H2gEAVh2+guu3SiSuiIiIyLAxyGjY4PbOCPO1R0WVEst3JkhdDhERkUFjkNEwQRDw9iPtIAjAtth0RKXckrokIiIig8UgowWBbjZ4vLM7gOqBv5yOTUREpB0MMloyb4g/LEzkiLmWh3/OZUpdDhERkUFikNESJ2szPNfXFwDwwa6LqKhSSlwRERGR4WGQ0aJn+/jC0coUKTkl+PVEitTlEBERGRwGGS2yNDXC3PC2AIDP9yUiv7RS4oqIiIgMC4OMlo3r4g4/pxa4VVKJbyK4OzYREZEmMchomZFchjeHBQAAfjhyBel5pRJXREREZDgYZJrAoHZO6ObTEuVVSny8+5LU5RARERkMBpkmIAiCauuCTWeuIz69QOKKiIiIDAODTBPp6GGLR0JcIYrA0h0XpC6HiIjIIDDINKHXhwbAWC7gcGI2Dl26KXU5REREeo9Bpgl52ltgcg9vAMDSHRehUHLrAiIiosZgkGliswb6wcrMCBcyCrDlTJrU5RAREek1SYPMokWLIAhCjUdAQIDqfGZmJiZPngwXFxdYWlqiU6dO2Lhxo4QVN56dpQlmDvADAHy8OwFllQqJKyIiItJfkvfIBAYGIiMjQ/U4cuSI6txTTz2FhIQE/PXXXzh37hzGjBmDcePG4cyZMxJW3HhP9/RGK1tzpOeX4cejV6Uuh4iISG9JHmSMjIzg4uKiejg4OKjOHTt2DLNmzUK3bt3g6+uLt99+G7a2toiKipKw4sYzM5bj1SHVWxd8feAycosrJK6IiIhIP0keZBITE+Hm5gZfX19MnDgRqampqnM9e/bE+vXrkZubC6VSiXXr1qGsrAz9+/ev83rl5eUoKCio8dBFozq2QntXaxSWV+GL/YlSl0NERKSXJA0y3bt3x5o1a7Bz506sXLkSV65cQZ8+fVBYWAgA2LBhAyorK2Fvbw9TU1M8//zz2Lx5M/z8/Oq85tKlS2FjY6N6eHh4NFVzGkQm+3eRvF+OpyAlp1jiioiIiPSPIIqizswBzsvLg5eXFz755BM888wzmDVrFk6ePIklS5bAwcEBW7ZswaefforDhw8jODj4ntcoLy9HeXm56uuCggJ4eHggPz8f1tbWTdWUepvyw0lEXLqJh0Nc8dWTnaQuh4iISCcUFBTAxsbmgZ/fOhVkAKBr164IDw/H9OnT4efnh7i4OAQGBqrOh4eHw8/PD9988029rlffvwipXMgowEOfH4YoAptf7IlQTzupSyIiIpJcfT+/JR8jc7eioiIkJSXB1dUVJSUlAACZrGaJcrkcSqVSivK0op2rNR7r5A4AWPrPRehYriQiItJpkgaZefPmISIiAlevXsWxY8cwevRoyOVyTJgwAQEBAfDz88Pzzz+PkydPIikpCR9//DH27NmDUaNGSVm2xr0ypC3MjGU4eTUXe+JvSF0OERGR3pA0yFy/fh0TJkyAv78/xo0bB3t7exw/fhyOjo4wNjbGP//8A0dHR4wYMQIhISFYu3YtfvrpJzz00ENSlq1xrjbmeKa3DwBg2c6LqFIYTo8TERGRNuncGBlN0/UxMncUlFWi/4cHkVtcgfdGBWFSDy+pSyIiIpKMXo6Rac6szYzx8qA2AIAVey+hqLxK4oqIiIh0H4OMDpnQzRPe9hbILqrAd4eSpS6HiIhI5zHI6BATIxneGFa9aebqw8kor+KGkkRERPfDIKNjhgW5wMJEjpIKBa7fKpW6HCIiIp3GIKNjBEGAZ0sLAOC2BURERA/AIKODvO0tAQApOSUSV0JERKTbGGR0kJf9nR4ZBhkiIqL7YZDRQV6qHhneWiIiIrofBhkd5M0eGSIionphkNFBnreDzLVbJVAoDXrhZSIiokZhkNFBrjbmMJHLUKkQkZ7HKdhERER1YZDRQXKZAPeW5gCA1FzeXiIiIqoLg4yOujMF+yoH/BIREdWJQUZH3VkUL5UDfomIiOrEIKOj7sxcYo8MERFR3RhkdJQXV/clIiJ6IAYZHXVndd/U3BKIIqdgExER3QuDjI5yt7OATABKKhS4WVQudTlEREQ6iUFGR5kYyeBmWz0Fm7eXiIiI7o1BRoeppmBnc8AvERHRvTDI6DDPu8bJEBERUW0MMjrs3ynYDDJERET3wiCjwzxb3pmCzVtLRERE98Igo8P8nFoAABJvFHEXbCIiontgkNFhPg6WsDCRo7RSgeSbRVKXQ0REpHMYZHSYXCagvas1ACAuPV/iaoiIiHQPg4yOC2plAwA4d71A4kqIiIh0D4OMjgu+HWTYI0NERFQbg4yOu9MjE59eACUH/BIREdXAIKPjWjtawsxYhqLyKlzlNGwiIqIa1A4ylZWVuHbtGhISEpCbm6vJmuguRnIZ2t0e8HsujbeXiIiI7tagIFNYWIiVK1eiX79+sLa2hre3N9q1awdHR0d4eXnh2WefxalTp7RVa7N1Z5zM+XQO+CUiIrpbvYPMJ598Am9vb/z4448IDw/Hli1bEBMTg0uXLiEyMhLvvPMOqqqqMGTIEAwbNgyJiYnarLtZCXK7M3OJPTJERER3M6rvE0+dOoVDhw4hMDDwnue7deuGadOm4ZtvvsGPP/6Iw4cPo02bNhortDkLumvmkiiKEARB4oqIiIh0Q72DzO+//16v55mamuKFF15QuyCqrY1zC5gYyVBYVoXU3BJ42VtKXRIREZFO4KwlPWAsl6GdixUAIC6N42SIiIjuaHCQiY2NxXvvvYevv/4a2dnZNc4VFBRg2rRpGiuO/hV4Z4VfzlwiIiJSaVCQ2b17N7p164Z169Zh+fLlCAgIwIEDB1TnS0tL8dNPP2m8SAJCbgeZ2Gt50hZCRESkQxoUZBYtWoR58+YhLi4OV69exeuvv46RI0di586d2qqPbuvkZQcAiLmWh0qFUuJqiIiIdEODgsz58+dVt44EQcDrr7+Ob7/9Fo899hi2b9+ulQKpmp9jC9iYG6O0UoELGRwnQ0REBDQwyJiamiIvL6/GsSeffBKrV6/G+PHjsXnzZk3WRneRyQR0vt0rc+rqLYmrISIi0g0NCjIdO3asMSbmjieeeAKrV6/G7NmzNVYY1XYnyESlcEsIIiIioAHryADAjBkzcOjQoXuemzBhAkRRxKpVqzRSGNXW5XaQOX31FhfGIyIiAiCIoihKXYQ2FRQUwMbGBvn5+bC2tpa6nEYpq1QgeNEuVCpEHH59ADxaWkhdEhERkVbU9/O70QviFRUVoaCgoMaDtMPMWK7aruDUVd5eIiIiUivIXLlyBQ8//DAsLS1hY2MDOzs72NnZwdbWFnZ2dpquke6iur2UwgG/REREDRojc8ekSZMgiiJ++OEHODs7c6xGE+rs1RKrDl9BFGcuERERqRdkYmNjERUVBX9/f03XQw9wZ+bSpaxC5JdWwsbcWOKKiIiIpKPWraWuXbvi2rVrmq6F6sHRyhTe9hYQRSA6lb0yRETUvKnVI7N69Wq88MILSEtLQ1BQEIyNa/YKhISEaKQ4urcu3i1xNacEJ6/kYoC/k9TlEBERSUatIHPz5k0kJSVh6tSpqmOCIKjWNlEoFBorkGrr4WuPP6OuIzIpR+pSiIiIJKXWraVp06YhNDQUkZGRSE5OxpUrV2r8t74WLVoEQRBqPAICAmo8JzIyEgMHDoSlpSWsra3Rt29flJaWqlO2wQhrbQ8AOHs9DwVllRJXQ0REJB21emRSUlLw119/wc/Pr9EFBAYGYu/evf8WZPRvSZGRkRg2bBjmz5+PL774AkZGRoiNjYVM1ujlb/RaK1tzeNtb4GpOCU5dycWgds5Sl0RERCQJtYLMwIEDERsbq5EgY2RkBBcXl3uemzt3LmbPno0333xTdYwzpaqFtXbA1ZxURCblMMgQEVGzpVaQGTFiBObOnYtz584hODi41mDfkSNH1vtaiYmJcHNzg5mZGcLCwrB06VJ4enoiKysLJ06cwMSJE9GzZ08kJSUhICAA77//Pnr37l3n9crLy1FeXq762lBXGg5rbY/fT6biGMfJEBFRM6bWXkv3u7XTkMG+O3bsQFFREfz9/ZGRkYHFixcjLS0NcXFxOH/+PMLCwtCyZUt89NFH6NixI9auXYuvv/4acXFxaNOmzT2vuWjRIixevLjWcUPYa+luNwvL0fX96ltyZxYMhp2licQVERERaU5991rSqU0j8/Ly4OXlhU8++QTt2rVDr169MH/+fCxZskT1nJCQEDz88MNYunTpPa9xrx4ZDw8PgwsyADDk0whculGElRM7YXiwq9TlEBERaYxWNo186qmnsHHjRhQXFze6wHuxtbVF27ZtcfnyZbi6Vn8wt2/fvsZz2rVrh9TU1DqvYWpqCmtr6xoPQ9WztQMA8PYSERE1Ww0KMn5+fliyZAkcHBwwfPhwrFy5EmlpaRorpqioCElJSXB1dYW3tzfc3NyQkJBQ4zmXLl2Cl5eXxl5Tn92Zhn0sKVviSoiIiKTRoCCzcOFCREVFITExESNGjMCWLVvQunVrdO7cGf/73/8QExPToBefN28eIiIicPXqVRw7dgyjR4+GXC7HhAkTIAgCXnvtNXz++ef4888/cfnyZSxYsAAXL17EM88806DXMVQ9fOwhCEDSzWJkFZRJXQ4REVGTU2vWkru7O1588UW8+OKLKCwsxI4dO7B161YMHDgQVlZWGDFiBGbMmIHAwMD7Xuf69euYMGECcnJy4OjoiN69e+P48eNwdHQEAMyZMwdlZWWYO3cucnNz0aFDB+zZswetW7dWp2yDY2NhjCA3G5xLy8fRpGyMDnWXuiQiIqImpdHBvgqFAgcPHsRff/2F4OBgTJ8+XVOXVlt9Bwvpq+U7L2LlwSSMDm2FT8d3lLocIiIijajv53eDemTeeecdDBo0CD169ICJSe3pvnK5HIMGDcKgQYMaXjGppW8bR6w8mITDiTehVIqQyQSpSyIiImoyDRojs3btWvTv3x+2trYYNGgQ3nvvPRw9ehRVVVXaqo8eoLOXHSxN5MguqkB8hmEu/kdERFSXBgWZO5tCfvXVV3B3d8fq1avRp08f2NnZYdiwYVi+fDlOnjyprVrpHkyMZKrZS4cSb0pcDRERUdNq9BiZK1eu4MCBAzh48CC2bt2K4uJineqhMfQxMgCwNvIqFm49jx6+LbHuuTCpyyEiImo0rSyI918pKSk4dOgQIiIicOjQIVRWVqJv376NuSSpoW+b6lleUSm3UFyuOyGSiIhI2xo02Dc1NRUHDx5U9cBkZ2ejZ8+e6NevH5599ll069btnoOASbu8HSzh2dICqbkliEzKQXh77oZNRETNQ4OCjLe3Nzw9PTFjxgzMmDEDnTt3hlwu11Zt1AB92zrgl+OpOJR4k0GGiIiajQbdWho3bhzKy8uxfPlyvPfee1ixYgWio6OhQ/tONlt3bi8dusQBv0RE1Hw0KMisW7cOGRkZOHbsGIYPH46TJ0/ioYcegp2dHR555BF8+OGHOHXqlLZqpfsIa20PI5mAqzklSMnRzqaeREREukatwb4BAQGYMWMG1q9fj8zMTBw7dgwdO3bEe++9h7AwzpqRgpWZMbp42wEA9l/MkrgaIiKipqHWXksAcOPGDRw8eFA1+PfSpUswNTVFnz59NFkfNcDAACccT87F/otZmNrLR+pyiIiItK5BQWbDhg2q8JKQkABjY2N07doV48aNw4ABA9CzZ0+Ymppqq1Z6gIEBzljyz0WcSM5FcXkVLE3VzqlERER6oUGfdJMmTUKXLl0wevRoDBgwAL169YK5ubm2aqMGau347zTso5ezMSTQReqSiIiItKpBQebWrVuwtLTUVi3USIIgYGCAE9Ycu4oDCVkMMkREZPAaFGT+G2KysrKQlZUFpVJZ43hISEjjKyO1DLgdZPZfzIIoihAE7oZNRESGS61BFFFRUZgyZQouXLigWkNGEATVB6dCodBokVR/3X1awsJEjhsF5TifXoCgVjZSl0RERKQ1agWZadOmoW3btvj+++/h7OzM3/p1iJmxHL38HLAn/gYOXMxikCEiIoOmVpBJTk7Gxo0b4efnp+l6SAMGBjhhT/wN7E/IwqxBbaQuh4iISGvUWhBv0KBBiI2N1XQtpCEDA5wAADHX8nCzsFziaoiIiLRHrR6Z1atXY8qUKYiLi0NQUBCMjY1rnB85cqRGiiP1OFubIcTdBmev52P/xRsY39VT6pKIiIi0Qq0gExkZiaNHj2LHjh21znGwr24Y3M4ZZ6/nY088gwwRERkutW4tzZo1C5MmTUJGRgaUSmWNB0OMbhgc6AwAOJyYjZKKKomrISIi0g61gkxOTg7mzp0LZ2dnTddDGuLvbAV3O3OUVylxODFb6nKIiIi0Qq0gM2bMGBw4cEDTtZAGCYKAwe2rg+ae+BsSV0NERKQdao2Radu2LebPn48jR44gODi41mDf2bNna6Q4apzB7Z3x49HqVX4VShFyGdf7ISIiwyKId5bmbQAfH5+6LygISE5OblRRmlRQUAAbGxvk5+fD2tpa6nKaVKVCiS7v7UV+aSX+eCEMXb1bSl0SERFRvdT381utHpkrV66oXRg1HWO5DAP8HbElJh2bz6Shi5cdV2EmIiKDotYYGdIfDwW7AgB+O5GK536OQlZhmcQVERERaU69g8yyZctQWlpar+eeOHECf//9t9pFkeYMbu+M14b6w1guYE/8DQz99BCOJ+dIXRYREZFG1DvIxMfHw9PTEy+++CJ27NiBmzdvqs5VVVXh7Nmz+Prrr9GzZ0+MHz8eVlZWWimYGkYQBMwc4Idts3oj0M0at0oqMfPXaGQVsGeGiIj0X4MG+8bGxuLLL7/En3/+iYKCAsjlcpiamqKkpAQAEBoaiunTp+Ppp5+GmZmZ1opuiOY82Pe/yioVGPXVUVzMLESYrz1+md6dM5mIiEgn1ffzW61ZS0qlEmfPnkVKSgpKS0vh4OCAjh07wsHBoVFFawODTE1JN4sw4osjKKlQYG54W7wczt2xiYhI92g1yOgTBpnaNp+5jrnrYyETgPXPc1o2ERHpnvp+fnPWUjM0OtQdYzu5QykC8zedQ0WVUuqSiIiI1MIg00wteKQd7C1NcDmrCKsO684ChkRERA3BINNM2VqY4O1H2gEAPt+XiJScYokrIiIiajgGmWZsVMdW6OVnj/IqJRZsPQ8DHy5FREQGSK0gs3//fpSVcR0SfScIAt59NAgmchkOXbqJXeczpS6JiIioQdQKMiNHjoStrS369OmDBQsWYO/evfVe9Zd0i69jCzzfzxcA8P4/F1BWqZC4IiIiovpTK8jcunUL+/btw/Dhw3Hy5EmMHj0atra26NWrF95++21N10ha9kK/1nC2NsW13FL8cJQbghIRkf7QyDoy58+fx4cffohff/0VSqUSCoXu/FbPdWTqZ1P0dbyyIRaWJnIcmNcfTta6sTIzERE1T1pdR+bSpUv47rvv8OSTT6JVq1bo168f8vPz8dFHHyE6Olrtokk6ozq2QgcPWxRXKPDhrgSpyyEiIqoXtXpkZDIZHB0d8fLLL+ORRx5BcHAwBEE39+xhj0z9Rafewpivj0EQgK0zeyHE3VbqkoiIqJnSao/M7Nmz0apVK/zvf//DCy+8gLfeegu7d+9WbR5J+qmTpx1GdXSDKAL/2xbP6dhERKTz1AoyK1asQHR0NDIzMzF//nxUVFTgrbfegoODA3r16qXpGqkJvTE8AObGcpxOuYVtZzOkLoeIiOi+GrUgnkKhQGVlJcrLy1FWVoby8nIkJHB8hT5ztTHHjP6tAQDL/rmA0grdGbhNRET0X2rfWgoJCYGzszOef/55pKen49lnn8WZM2dw8+ZNTddITey5vr5oZWuO9PwyfHeI+zAREZHuMlLnmzIyMvDcc8+hf//+CAoK0nRNJDEzYzneHB6AWb+fwTcRSRjX1R2uNuZSl0VERFSLRtaR0WWctaQeURQx7ttInLp6C6M6umHFE6FSl0RERM2IVmctAUBSUhJmzZqF8PBwhIeHY/bs2UhKSlL3cqRjBEHAwkcCIQjAlph0RKfekrokIiKiWtQKMrt27UL79u1x8uRJhISEICQkBCdOnEBgYCD27Nmj6RpJIsHuNniskzsAYPG2eCiVBt15R0REekitW0uhoaEYOnQoli1bVuP4m2++id27d+vU6r68tdQ4WYVlGPDhQRRXKPDx4x0wtrO71CUREVEzoNVbSxcuXMAzzzxT6/i0adMQHx9f7+ssWrQIgiDUeAQEBNR6niiKGD58OARBwJYtW9QpmdTkZGWGlwa2AQAs3XER+aWVEldERET0L7WCjKOjI2JiYmodj4mJgZOTU4OuFRgYiIyMDNXjyJEjtZ6zYsUKnd0CoTmY1tsbvo6WyC4qx8e7uU4QERHpDrWmXz/77LN47rnnkJycjJ49ewIAjh49iuXLl+OVV15pWAFGRnBxcanzfExMDD7++GOcPn0arq6uD7xeeXk5ysvLVV8XFBQ0qB6qzdRIjvceDcKTq0/g5+MpeKyzO/dhIiIinaBWj8yCBQuwcOFCfPHFF+jXrx/69euHL7/8EosWLcLbb7/doGslJibCzc0Nvr6+mDhxIlJTU1XnSkpK8OSTT+Krr766b9i529KlS2FjY6N6eHh4NKgeureefg549PY+TG9viYOCA3+JiEgHNHodmcLCQgCAlZVVg793x44dKCoqgr+/PzIyMrB48WKkpaUhLi4OVlZWeP7556FQKLB69erqYgUBmzdvxqhRo+q85r16ZDw8PDjYVwOyCssw6KMIFJZX4d1HAzE5zFvqkoiIyEDVd7CvWreW7qZOgLlj+PDhqj+HhISge/fu8PLywoYNG+Do6Ij9+/fjzJkzDbqmqakpTE1N1a6J6uZkZYZ5Q/3xzl/n8cGuBAwLcoWjFf+uiYhIOvUOMqGhofUecKvu9GtbW1u0bdsWly9fxrlz55CUlARbW9sazxk7diz69OmDgwcPqvUa1DiTenjhz6jrOJeWjyX/XMCn4ztKXRIRETVj9Q4y97udoylFRUVISkrC5MmTMW7cOEyfPr3G+eDgYHz66acYMWKE1muhe5PLBLw3Kgijvj6KzWfSMK6LB8Ja20tdFhERNVP1DjJ2dnZ47rnnYGZmhtTUVLi7u0MmU3uHAwDAvHnzMGLECHh5eSE9PR3vvPMO5HI5JkyYAEdHx3sO8PX09ISPj0+jXpcap4OHLSZ298Qvx1Px9pZz2PFyX5gYNe5ngYiISB31/vR55ZVXVFOZfXx8kJ2d3egXv379OiZMmAB/f3+MGzcO9vb2OH78OBwdHRt9bdKu14YGwKGFCZJuFuPrg5elLoeIiJqpevfIuLm5YePGjXjooYcgiiKuX7+OsrKyez7X09OzXtdct25dfV8eQPUKv6QbbMyN8c6IQMz6/Qy+3H8ZQwNd0M6Vs8KIiKhp1Xv69XfffYdZs2ahqqqqzueIoghBEKBQKDRWYGNxryXtEUURz/8chd3xNxDUyhpbXuwFIzlvMRERUePV9/O7QevIFBYWIiUlBSEhIdi7dy/s7e89yLNDhw4Nr1hLGGS0K6ugDIM/PYT80kq8NtQfMwf4SV0SEREZAK2sI2NlZYWgoCD8+OOP6NWrF9drIThZm2HhI+3x6h+x+GxvIsLbOcPfRf21hYiIiBpCrfsAU6ZMYYghlTGdWmFQgBMqFErMWR+D8irdubVIRESGjQMaqNEEQcDSscGwszDGhYwCrNibKHVJRETUTDDIkEY4WZlh6ZhgAMC3EUk4dTVX4oqIiKg5YJAhjRkW5IrHOrtDKQKv/RGLSoVS6pKIiMjAqRVk/ve//6GkpKTW8dLSUvzvf/9rdFGkv94Z0R4OLUxwNacEm6KvS11OsxZ7LQ8PfXYYRy83fvFKIiJdpVaQWbx4MYqKimodLykpweLFixtdFOkvKzNjvNCvNQDgi/2X2Ssjoc/2JSI+owDfH7kidSlERFqjVpC5s/Ddf8XGxqJly5aNLor028TuXnBoYYLrt0rZKyOR7KJyRFy6CQA4dSUXCiVXxSYiw9SgIGNnZ4eWLVtCEAS0bdsWLVu2VD1sbGwwePBgjBs3Tlu1kp4wN5GzV0Zi22PTVeGlsLwK8ekFEldERKQdDVoQb8WKFRBFEdOmTcPixYthY2OjOmdiYgJvb2+EhYVpvEjSPxO7e+GbiCRcv1WKjVHX8US3+u2/RZqx+UwaAMBYLqBSIeLElRwEu9s84LuIiPRPg4LMlClTAFTvft2zZ08YGxtrpSjSf3d6Zd77+wI+2p2Awe2dYd+Ciyg2haSbRYi9ng+5TMDUXj747lAyjifnYnofX6lLIyLSOLXGyPTr108VYsrKylBQUFDjQQQAk3p4oa1zC2QXVeCtzXHcvbyJbL3dG9O3jQMeCnYFAJy8ksNxMkRkkNQKMiUlJXjppZfg5OQES0tL2NnZ1XgQAYCZsRyfjOsII5mAneczsSUmTeqSDJ4oith8++95VGgrBLlZw9JEjoKyKlzM5C8ZRGR41Aoyr732Gvbv34+VK1fC1NQUq1evxuLFi+Hm5oa1a9dqukbSY0GtbDAnvA0AYOHW80jPK5W4IsMWlXIL13JLYWkix5D2LjCSy9DFu3om4YlkrrZMRIZHrSCzbds2fP311xg7diyMjIzQp08fvP3221iyZAl+/fVXTddIeu6Ffq3R0cMWhWVVmP37GVRUcRaTtvx9LgMAMCTQBeYmcgBAD197AMDx5BzJ6iIi0ha1gkxubi58fasHDlpbWyM3t/o3vd69e+PQoUOaq44MgpFchhXjO8LKzAinU25hyT8XpC7JIImiiF1xmQCA4UEuquPdfat7ZE5ezYWS42SIyMCoFWR8fX1x5Ur1aqEBAQHYsGEDgOqeGltbW40VR4bD28ESn47rCABYc+wqNp/hQnmaFns9H+n5ZbAwkaNvW0fV8eBWNrAwkSOvpBKXsgolrJCISPPUCjJTp05FbGwsAODNN9/EV199BTMzM8ydOxevvfaaRgskwxHe3hmzBvoBAOZvOoe4tHyJKzIsO+KqbysNCHCCmbFcddz4rnEyf8WkS1IbEZG2CKIG5sSmpKQgKioKfn5+CAkJ0URdGlNQUAAbGxvk5+fD2tpa6nKaPYVSxLQ1pxBx6SacrU2xdWZvuNiYSV2W3hNFEf0/OoiUnBJ8+WQoHglxq3F+1/lMPP9zFCxM5Dj0+gA4cE0fItJx9f38VqtH5m5lZWXw8vLCmDFjdC7EkO6RywR8PiEUbZxa4EZBOZ756RSKy6ukLkvvXcgoREpOCUyNZBjg71Tr/JD2zujgboOSCgW+PpAkQYVERNqhVpBRKBR499130apVK7Ro0QLJyckAgAULFuD777/XaIFkeGzMjfHD011hb2mC8+kFmP37GS7W1kg7b99W6tvWEZamtRfsFgQBrw7xBwD8ciIFGfmcBk9EhkGtIPP+++9jzZo1+OCDD2BiYqI6HhQUhNWrV2usODJcHi0tsGpKF5gaybDvYhbe2nyOK/82wo7bs5UeCnap8zl92jigm09LVFQp8fm+y01VGhGRVqkVZNauXYvvvvsOEydOhFz+76DCDh064OLFixorjgxbJ087fPZER8gEYN2pa/hod4LUJemlK9nFSMwqgrFcwMAA5zqfJwgCXhta3Svzx+lrOHs9r4kqJCLSHrWCTFpaGvz8/GodVyqVqKysbHRR1HwMC3LF+6ODAQBfHUjC6sPJElekfyISsgAAXb1bwsb8/hu5dvVuiWGBLqhSipj+02neYiIivadWkGnfvj0OHz5c6/iff/6J0NDQRhdFzcuEbp6qnoL3/r6AX0+kSFyRfom4dBMA0O+utWPu58PHQ+DvbIWswnI8s+Y0B1sTkV6rPSqwHhYuXIgpU6YgLS0NSqUSmzZtQkJCAtauXYvt27drukZqBl7s3xr5pZX47lAy3tocB2OZDOO6ekhdls4rq1Tg+O09lPr51y/IWJkZY/WULhj99VHEZxRg1u9n8PXETjXWniEi0hdq9cg8+uij2LZtG/bu3QtLS0ssXLgQFy5cwLZt2zB48GBN10jNgCAImD88AE/39AYAvLHpLDZFc/XfBzl99RZKKxVwtjaFv7NVvb/Po6UFvnuqC0yMZNh/MQuPfxOJzPwyLVZKRKQdavXIAECfPn2wZ88eTdZCzZwgCHhnRHtUKZX45XgqXv0jFlUKkT0z9xFxqXp8TN82jhAEoUHf28nTDmundcOMX6JwLi0fI748gs+e6IierR20USoRkVaoHWQAoKKiAllZWVAqa+5m7Onp2aiiqPkSBAH/GxkEAPjleCpe33gWZVUKPBXmLW1hOurQpWwA9b+t9F89fO3x10u9Mf2n00i4UYgnV51AFy87vNCvNQYGOEEma1g4IiJqamrdWkpMTESfPn1gbm4OLy8v+Pj4wMfHB97e3vDx8dF0jdTMyGQC3n00CM/0rv5ZWrj1PFYeTOI6M/+RkV+KhBuFkAlAbz/1e1E8Wlpg44s98WR3T5jIZTidcgvT157G0BWH8GfUdVRUKR98ESIiiai111KvXr1gZGSEN998E66urrW6tDt06KCxAhuLey3pL1EU8dHuBHx1e0n9KWFeWDgiEHL2EgAA1p9KxRsbzyHU0xabX+ylkWveKCjDD0ev4NfjqSi6PZvJ1cYM47t6YGwnd3i0tNDI6xARPUh9P7/VCjKWlpaIiopCQEBAo4psCgwy+m/14WS8/88FiCIwNNAZnz0Ryhk2AGb+Go2/z2VgTngbzAlvq9FrF5RV4tfjqfjh6BXcLCxXHQ/ztce03j4YxNtORKRlWt00sn379sjOzla7OKKGmN7HF19O6AQTuQy7zt/Ak6uO41ZxhdRlSUqpFHHkcvX/g33ruX5MQ1ibGWNG/9Y4/PoArBjfEX3aOEAQgMjkHDy79jTCP43Az5FXkV1U/uCLERFpUb17ZAoKClR/Pn36NN5++20sWbIEwcHBMDauuZqoLvV8sEfGcJy4/SFaUFYFXwdL/DStW7O91XHpRiGGfHoI5sZynFs0BEbyRm9k/0BpeaX4OTIFv55IQWFZ9W0nmQB097HHkEBn9GnjgNaOLRo8e4qI6F40fmtJJpPVeIMSRbHWG9adYwqFQs2yNY9BxrBculGIp384ifT8MthZGGNYkCt6+zmgt58DbCzuvzy/Ifn9ZCrmbzqHMF97/P5cjyZ97aLyKmw4dQ1bYtJw9np+jXOuNmbo7tMSnbzs0MnTDgEuVk0SsojI8Gg8yERERNT7xfv161fv52obg4zhuVFQhqd/PIULGf/2ElqayPF/D7fDk908m0WPwGt/xOKPqOt4aYAf5t3e3kEK13JLsDMuExGXbuLk1dxaM5wsTOTo4G6LUE9bBLrZoJ2rFbzsLTlgm4geSKuDffUJg4xhKq9S4OjlbBxJzMHBhCwkZxcDqJ6GvGxsMNztDPuW08CPDyL5ZjF+eLrLfXe8bkpllQqcupqLqJRbiEq5hZjUPBTeYx8nc2M5/F2s0M7VGu1dq//r72IFK7Pm06NGRA/GIHMbg4zhUyhFrDl2FR/uuoiySiVamBrhrYfb4YmuHgbZO5NbXIFO71avqn1mwWDYWZpIXNG9KZQiLmcVITr1FmKv5eFCRgEuZhaivI51aVrZmsPX0RK+DpZo7dQCvg4t4OtoCVcbM4P8dySi+2OQuY1Bpvm4kl2M1/6IxemUWwCqZ/MsGxMMN1tziSvTrH0XbuCZn06jtaMl9r3aX+pyGkShFHEluxgXMgruehQis6DufZ4sTOTwcbCEr2MLeLY0h2dLC3i0tIBnSwu42pjzNhWRgWKQuY1BpnlRKEX8ePQKPtyVgPIqJaxMjfD2I+0wrovh9M58uOsivjqQhMc7u+PDx3Vn8cnGuFVcgaSbRUi+WYykm0VIulmM5OwipOaUoEpZ91uUsVxAK1tzVbC58/BoaYFWtuawtTA2mH93ouamvp/fjdpriUjXyGUCpvfxxYAAJ7z2RyyiU/PwxsZz+OdcJpaNDYarjf73zkTd7nHq7GUncSWaY2dpgi6WLdHFu2WN45UKJVJzS5CUVYSrOcW4lluK1NwSXMstwbVbJahUiLiaU4KrOSX3vK6ZsQxuNuZwszWHq40ZXG3N0crWDK425nC7/V9LU74NEukztXpkBg4ciE2bNsHW1rbG8YKCAowaNQr79+/XVH2Nxh6Z5kuhFPH9kWR8tPsSKqqqx868MTwAE7t56u2qtJUKJUIW7UZppQJ75vZFG2crqUuSjEIp4kZBGVJzS1Th5u4/ZxfVb9FEG3NjuNqYoZWtOVxtzeBibQYnKzM4WZvC2doMTlamsLMw0dufGSJ9pdVbSzKZDJmZmXBycqpxPCsrC61atUJlZWXDK9YSBhm6nFWENzaeVfVkdPNuiaVjg9HasYXElTXcuev5GPHlEVibGSFm4RB+uN5HWaUCNwrKkJZXioy8MqTnlSI9vwwZ+aXVf84rU+0n9SDGcgFOVmZwtDKF810Bx8naTPVnZ2sz2PFWFpHGaOXW0tmzZ1V/jo+PR2ZmpuprhUKBnTt3olWrVmqUS6Q9fk4t8MfzYfj5eAo+2HkRJ6/mYvhnh/HyoDZ4rq8vjPVowbbo1OowFuppxxDzAGbGcnjZW8LL3rLO5xSUVVaHnNvhJiOvDDcKypBVWK76b25xBSoVItLySpGWV3rf1zSRy+BoZVrdm2NlBi8HC8wa2AYtePuKSGsa9H9Xx44dIQgCBEHAwIEDa503NzfHF198obHiiDRFJhMwpac3BrVzwlub4xBx6SY+3JWA7Wcz8N6oQHT2avngi+gAQxwfIyVrM2NYuxjD36XuW3QVVUrcLLodbArKkVVYpvrzjcJyZN0VeCoUylqBx8xIjrmDNbupJxH9q0FB5sqVKxBFEb6+vjh58iQcHf/drM7ExAROTk6Qy7krMekudzsLrJnaFVti0rB4WzwuZBRg7MpIjOnUCm8OD4CTlZnUJd7XndWMQ9xtJK6k+TAxkqGVrTlaPWAaf83AU4ZTV2/h+yNX8PvJVLw00E+vev6I9EmDgoyXlxcAQKm894JWRPpAEASMDnVH3zaO+HBXAtafvoZN0WnYc/4G5gxui6fCvHTyQ0epFJGSWz07x9dB/8b3GLr/Bp6BAc7YGpOOrMJy7Im/gYeCXSWukMgwqX3jNjExEQcOHEBWVlatYLNw4cJGF0akbfYtTLFsbAie6OaJhVvjcPZ6Pt7dHo8Np67hnRHt0dPPQeoSa0jPL0VFlRLGcgFutrrdc0TVwWZCNw98sf8yfo5MYZAh0hK1gsyqVaswY8YMODg4wMXFpcYofUEQGGRIr3T0sMWWF3thw+lrWL7zIhJuFOLJ1ScwwN8Rbw5vd9/xE03panZ1b4xHSwvuKK0nJnTzxFcHLiMyOQeXswrh56QbP0tEhkStd8P33nsP77//PjIzMxETE4MzZ86oHtHR0fW+zqJFi1SDh+88AgICAAC5ubmYNWsW/P39YW5uDk9PT8yePRv5+fnqlEx0XzKZgCe6eeLAvP54uqc3jGQCDiTcxPDPDuGNP88iM7/uJfSbytWc6o0xfe4zC4d0i5utOcLbVW/q+cvxVImrITJMagWZW7du4fHHH9dIAYGBgcjIyFA9jhw5AgBIT09Heno6PvroI8TFxWHNmjXYuXMnnnnmGY28LtG92FqYYNHIQOx5pR8eCnaBUgTWn76G/h8dwEe7EpBfKt0aSVdv7/B9v+nEpHsmh1WPLdwYdb3e69YQUf2pFWQef/xx7N69WyMFGBkZwcXFRfVwcKgelxAUFISNGzdixIgRaN26NQYOHIj3338f27ZtQ1UV3wxIu3wcLPH1xM7Y9GJPdPGyQ1mlEl8euIw+y/fjs72JKChr+kCj6pFxsGjy1yb19WrtAF8HSxSWV+Gbg0lSl0NkcNQaI+Pn54cFCxbg+PHjCA4OhrGxcY3zs2fPrve1EhMT4ebmBjMzM4SFhWHp0qXw9PS853PvrO5nZFR32eXl5SgvL1d9XVBQUO9aiP6rk6cd/nghDLvjb+Dj3Qm4dKMIn+69hB+OXsH03j54upc3rMyMH3whDbhyu0fG24E9MvpEJhPwxvAAPP9zFL47lIzHu7izV41Ig9TaosDHx6fuCwoCkpOT63WdHTt2oKioCP7+/sjIyMDixYuRlpaGuLg4WFnVHBSXnZ2Nzp07Y9KkSXj//ffrvOaiRYuwePHiWse5RQE1llIp4u9zGfhsXyIuZxUBAGwtjDG9tw8mh3nDxlx7gUahFNFuwU5UKJQ4/PoAeLRkr4w+EUURT/1wEocTszG4vTNWPdVF6pKIdJ5W91rSlry8PHh5eeGTTz6pMRamoKAAgwcPRsuWLfHXX3/V6gG62716ZDw8PBhkSGMUShHbz6bjs32JSL5Z3UvSwtQIT3b3xLRePnCx0fzU6Gu5JejzwQGYyGW48O4wyLk9gd65nFWIYSsOo0op4qdp3dCvreODv4moGatvkGnUHM6KigokJCRobMyKra0t2rZti8uXL6uOFRYWYtiwYbCyssLmzZvvG2IAwNTUFNbW1jUeRJoklwl4tGMr7JnbDyvGd4S/sxWKyqvw3aFk9PlgP17/M1bVY6Mpd8bHeLQ0Z4jRU35OVngqzBsAsHjbeZRVKqQtiMhAqBVkSkpK8Mwzz8DCwgKBgYFITa2eVjhr1iwsW7ZM7WKKioqQlJQEV9fqhaMKCgowZMgQmJiY4K+//oKZGRcBI90hlwkYFdoKO+f0wQ9Pd0E375aoVIjYcPo6Bn8agek/ncLRy9nQRKfnnRlLPhwfo9deDm8DRytTJN8sxnt/x0tdDpFBUCvIzJ8/H7GxsTh48GCNcBEeHo7169fX+zrz5s1DREQErl69imPHjmH06NGQy+WYMGGCKsQUFxfj+++/R0FBATIzM5GZmQmFgr/JkO4QBAEDA5yx4YUwbJzRE4PbO0MUgb0XsjBx9QkM+fQQfj2RgpIK9Xsur+ZUL4bHQaL6zcbcGB8/3gFA9boyO+MyJa6ISP+pNWtpy5YtWL9+PXr06FFjVd/AwEAkJdV/euH169cxYcIE5OTkwNHREb1798bx48fh6OiIgwcP4sSJEwCqZ0nd7cqVK/D29landCKt6uxlh1VPdUHSzSKsPXYVf0ZdR2JWEd7aHIflOy5ifFcPPNndq8E9K1c5Y8lg9G3riOf7+eLbiGS8sfEsQtxt4PaADSmJqG5qBZmbN2/Cycmp1vHi4uIaweZB1q1bV+e5/v37a6RLnkgKrR1bYPGjQXh1qD/+PH0dP0VeRUpOCVYdvoJVh68gzNceE7p7YmigM0yNHrxj/BWu6mtQXh3sj+NJOYi9no9Zv5/Bb892r9fPARHVptatpS5duuDvv/9WfX0nvKxevRphYWGaqYzIAFibGWNabx8ceLU/vp/SBQP8HSEIQGRyDmb/fgY9luzD+3/H43JWYZ3XqFIocS33zq0lTrs2BCZGMnw+IRRWZkaISrmF1/88y1/ciNSkVo/MkiVLMHz4cMTHx6OqqgqfffYZ4uPjcezYMURERGi6RiK9J5MJGNTOGYPaOSMtrxQbTl3D+lPXkFlQpuqlCXG3wejQVhjRwQ0OLUxV35uRX4ZKhQgTuYy3IAyIl70lvpnUGVN+OImtMenwcbDEnPC2UpdFpHfU6pHp3bs3YmJiUFVVheDgYOzevRtOTk6IjIxE586dNV0jkUFpZWuOuYPb4sgbA/D9lC4Ib+cEI5mAs9fzsXhbPLov2Ydpa07hr9h0lFUqVCv6etpbcOq1genl54D3RgUBAFbsTcTGqOsSV0Skf3RqQTxtqO+COkRSyikqx7bYdGw+k4bY6//u8N7C1Ahe9hY4n16A8HbOWD2FK8IaoqU7LuDbiGTIZQK+nBCK4cGuUpdEJLn6fn6rdWvpjqysLGRlZUGpVNY4HhIS0pjLEjU79i1M8XQvHzzdyweXs4qw5UwaNp9JQ1peKc6nV+8X5s3xMQbrjaEByC2qwB9R1zHr9zP4zliGgQHOUpdFpBfU6pGJiorClClTcOHChVoD1ARB0Kl1XtgjQ/pKqRRx6mouNp9Jw8XMQnzwWAjaOls9+BtJLymUIuauj8FfsekwMZLh28mdMcC/9uxQouZCq3stdejQAa1bt8Ybb7wBZ2fnWlOuvby8Gl6xljDIEJG+qFQoMeu3M9h5PhPGcgErxofi4RDeZqLmSatBxsrKCmfOnKm1UJ0uYpAhIn1SqVDilQ2x2BabDpkALBkdjCe6eUpdFlGT0+qmkYMGDUJsbKzaxRER0b0Zy2VYMb4jnuzuCaUIvLnpHD7bm8h1ZojqoFaPTHZ2NqZMmYJu3bohKCio1o7UI0eO1FiBjcUeGSLSR6Io4oNdCVh5sHrblzGhrbB0bDBXAKZmQ6uzliIjI3H06FHs2LGj1jldG+xLRKSPBEHAG8MC4G5njoVbz2PTmTRczyvFyomdYH/XgolEzZ1at5ZmzZqFSZMmISMjA0qlssaDIYaISHMmdvfCD093RQtTI5y8kosRXxzBubvWGiJq7tQKMjk5OZg7dy6cnbnOARGRtvVr64jNL/aEj4Ml0vPLMPabY9hw+prUZRHpBLWCzJgxY3DgwAFN10JERHVo42yFrS/1wqAAJ1RUKfH6n2fx6oZYlFRUSV0akaTUGiPTtm1bzJ8/H0eOHEFwcHCtwb6zZ8/WSHFERPQvazNjrHqqC748cBkr9l7CxujriL2ehy+fDEWACyczUPOk1qwlHx+fui8oCEhOTm5UUZrEWUtEZIiOJ+fg5XVncKOgHCZyGV4Z0hbP9vHlxqJkMLS6IJ4+YZAhIkOVU1SONzaexd4LWQCAzl52+PjxDvB2sJS4MqLG0+qCeHdUVFQgISEBVVW8R0tE1NTsW5hi1VNd8MFjIWhhaoSolFsY/tlhrI28CqXSoH9HJVJRK8iUlJTgmWeegYWFBQIDA5Gamgqgelr2smXLNFogERHVTRAEjOvigZ1z+iDM1x6llQos3Hoek384gdScEqnLI9I6tYLM/PnzERsbi4MHD8LMzEx1PDw8HOvXr9dYcUREVD/udhb4dXp3LBrRHmbGMhy9nIPBn0bgqwOXUVGllLo8Iq1RK8hs2bIFX375JXr37l1j5+vAwEAkJSVprDgiIqo/mUzA07188M/s6t6Z8iolPtyVgIc+P4zjyTlSl0ekFWoFmZs3b8LJyanW8eLi4hrBhoiImp6vYwv89mx3fDq+A+wtTXA5qwhPfHccr2yIQXZRudTlEWmUWkGmS5cu+Pvvv1Vf3wkvq1evRlhYmGYqIyIitQmCgNGh7tj/an9M7O4JQQA2RadhwEcHsepQMsqruJ0MGQa1FsRbsmQJhg8fjvj4eFRVVeGzzz5DfHw8jh07hoiICE3XSEREarKxMMb7o4PxWGd3vLU5DvEZBXj/nwv45UQK5g8PwNBAF/akk15Tq0emd+/eiImJQVVVFYKDg7F79244OTkhMjISnTt31nSNRETUSKGedtg2qzc+GBsCRytTpOSU4IVfojH+u+PchJL0GhfEIyJqZorLq/BtRBK+PZSM8tszmkZ2cMPcwW3hw8X0SEdodUG86OhonDt3TvX11q1bMWrUKPzf//0fKioq1LkkERE1EUtTI7wyxB8H5vXH6NBWAIC/YtMR/kkE3tx4Ful5pRJXSFR/agWZ559/HpcuXQIAJCcnY/z48bCwsMAff/yB119/XaMFEhGRdrjZmuPT8R2xfVZvDAxwgkIpYt2pa+j/4UEs3nYeNws5w4l0n1q3lmxsbBAdHY3WrVtj+fLl2L9/P3bt2oWjR4/iiSeewLVr17RRq1p4a4mIqH6iUnLx4a4EHE/OBQCYG8sxsbsnnuvrCydrswd8N5FmafXWkiiKUCqr76vu3bsXDz30EADAw8MD2dnZ6lySiIgk1tmrJX5/tgd+eaY7OnjYorRSgdVHrqD3BwewYEscrt/ilgeke9TqkRk4cCA8PDwQHh6OZ555BvHx8fDz80NERASmTJmCq1evaqFU9bBHhoio4URRRMSlm/hy/2WcTrkFADCSCRjTqRVm9PfjoGDSuvp+fqsVZM6ePYuJEyciNTUVr7zyCt555x0A1ZtG5uTk4LffflO/cg1jkCEiUp8oijienIsvDyTi6OXqbQ4EARjS3hnP9fVFZ6+WEldIhkqrQaYuZWVlkMvlMDY21tQlG41BhohIM6JTb+Gr/Zex72KW6lgnT1s819cXg9u7QC7jwnqkOZIEGV3EIENEpFmXswqx+vAVbIpOQ4Wierykl70FpoR547Eu7rA2051fZkl/aTXIKBQKfPrpp9iwYQNSU1NrrR2Tm5vb8Iq1hEGGiEg7sgrLsPZYCn4+noL80koAgIWJHKNCW+GpMC8EuPA9l9Sn1VlLixcvxieffILx48cjPz8fr7zyCsaMGQOZTIZFixapWzMREekRJyszzBvqj8j5A/HuqCC0dW6BkgoFfjuRimErDmP8t5H4+2wGKm/32hBpg1o9Mq1bt8bnn3+Ohx9+GFZWVoiJiVEdO378OAf7EhE1Q3cGBv98/Cp2nb8BhbL648XZ2hRPdvPChG4eXI+G6k2rt5YsLS1x4cIFeHp6wtXVFX///Tc6deqE5ORkhIaGIj9fdzYgY5AhImp6Gfml+P1EKn47eQ3ZRdUrBMtlAgYGOGF8Fw/093eEkVytmwLUTGj11pK7uzsyMjIAVPfO7N69GwBw6tQpmJqaqnNJIiIyIK425nhliD+OvTkQnz3REZ297KBQitgTfwPT155Gz2X7sXznRVzJLpa6VNJzavXIvPnmm7C2tsb//d//Yf369Zg0aRK8vb2RmpqKuXPnYtmyZdqoVS3skSEi0g2JNwqx4fQ1bIpOQ07xv5NEuvm0xPguHngo2BXmJnIJKyRd0qTTryMjIxEZGYk2bdpgxIgRjb2cRjHIEBHplooqJfZfvIF1p67h0KWbuD2UBlamRngo2BWjQluhu09LyLguTbPGdWRuY5AhItJdGfml+PP0dWyIuoZruaWq4242Zng0tBVGh7ZCW2crCSskqWg1yOTk5MDe3h4AcO3aNaxatQqlpaUYOXIk+vTpo37VWsAgQ0Sk+5RKESeu5GJrTBr+PpeBwrIq1bn2rtYYHdoKj3Z046ynZkQrQebcuXMYMWIErl27hjZt2mDdunUYNmwYiouLIZPJUFxcjD///BOjRo3SRBs0gkGGiEi/lFUqsP9iFjafScPBhCxUKqo/pmQCENbaHg8Hu2FYkAtaWppIXClpk1aCzPDhw2FkZIQ333wTP//8M7Zv346hQ4di1apVAKo3jYyKisLx48cb3wINYZAhItJft4orsP1cBracSUPU7V24geqp3D1b2+PhYFcMDXSBHUONwdFKkHFwcMD+/fsREhKCoqIiWFtb49SpU+jcuTMA4OLFi+jRowfy8vIa3QBNYZAhIjIMqTkl+PtcBv4+l464tALVcSOZgJ5+Dngk2BVDAp1ha8FQYwi0EmRkMhkyMzPh5OQEALCyskJsbCx8fX0BADdu3ICbmxsUCkUjy9ccBhkiIsNzNbu4OtSczUB8Rs1Q07uNAx4OdsWQ9i6wseAGlvqqvp/fRg29sCAI9/2aiIhI27wdLDFzgB9mDvBD8s0i/HMuA9vPZuBiZiEOJtzEwYSbmC87h7DW9hjS3hmD27vAxYYDhQ1Rg3tkhg8frlq9d9u2bRg4cCAsLS0BAOXl5di5cyd7ZIiISBKXs+6EmnRculFU41wHD1sMae+MoYHOaO3Ygr+I6zit3FqaOnVqvZ73448/1veSWscgQ0TUPCXfLMLu+BvYfT4TZ67l4e5PO18HSwwOdMaQ9i4I9bDl4ns6iAvi3cYgQ0REWQVl2HshC7vjM3Hscg4qFErVOUcrU4S3q+6pCWttD1MjbpOgC/QiyCxatAiLFy+ucczf3x8XL14EAJSVleHVV1/FunXrUF5ejqFDh+Lrr7+Gs7NzvV+DQYaIiO5WWFaJgwk3sTv+Bg5czEJR+b+L77UwNUI/f0eEt3NCv7ZOXKtGQlob7KtpgYGB2Lt3r+prI6N/S5o7dy7+/vtv/PHHH7CxscFLL72EMWPG4OjRo1KUSkREBsDKzBgjOrhhRAc3lFcpcDw5F7vPZ2JP/A1kFZbj77PVs6FkAhDqaYeBAU4YGOCEABcrjqvRQZL3yGzZsgUxMTG1zuXn58PR0RG//fYbHnvsMQDV69S0a9cOkZGR6NGjR71egz0yRERUH0qliJjredh34Qb2XcjCxczCGufdbMwwsF11qOnZ2gFmxrwFpU160yOTmJgINzc3mJmZISwsDEuXLoWnpyeioqJQWVmJ8PBw1XMDAgLg6el53yBTXl6O8vJy1dcFBQX3fB4REdHdZDIBnTzt0MnTDq8NDUBaXikOXMzC/otZOHo5G+n5ZfjleCp+OZ4KM2MZerV2wIDbvTVutuZSl99sSRpkunfvjjVr1sDf3x8ZGRlYvHgx+vTpg7i4OGRmZsLExAS2trY1vsfZ2RmZmZl1XnPp0qW1xt0QERE1VCtbc0zq4YVJPbxQWqFAZHI29l3IwoGLWUjPL8O+i1nYdzELANDO1RoDAxwxMMAZHT1sIecsqCajU7OW8vLy4OXlhU8++QTm5uaYOnVqjd4VAOjWrRsGDBiA5cuX3/Ma9+qR8fDw4K0lIiLSCFEUcTGzEPtv99ZEp96qMbW7paUJ+vs7YmCAE/q2dYS1GVcXVofe3Fq6m62tLdq2bYvLly9j8ODBqKioQF5eXo1emRs3bsDFxaXOa5iamqoW7CMiItI0QRDQztUa7VytMXOAH3KKyhFx6Sb2X8xCxKWbyC2uwKboNGyKToORTMDYTu5YOiaYa9VoiUzqAu5WVFSEpKQkuLq6onPnzjA2Nsa+fftU5xMSEpCamoqwsDAJqyQiIvqXfQtTjOnkji+f7IToBYPx+7M98FxfX7R2tESVUsT609ewI67uIRHUOJLeWpo3bx5GjBgBLy8vpKen45133kFMTAzi4+Ph6OiIGTNm4J9//sGaNWtgbW2NWbNmAQCOHTtW79fgrCUiIpLKJ7sT8Pn+y/B1sMTuuX1hJNep/gOdVt/Pb0n/Rq9fv44JEybA398f48aNg729PY4fPw5HR0cAwKeffopHHnkEY8eORd++feHi4oJNmzZJWTIREVG9PdvXFy0tTZCcXYw/o65LXY5B0qnBvtrAHhkiIpLS6sPJeO/vC3C1McOBef25/kw96UWPDBERkaGb1MMLbjZmyMgvw8+RKVKXY3AYZIiIiLTIzFiOOeFtAQCf70/EjYIyiSsyLAwyREREWja2szs6uNugsKwK72w9L3U5BoVBhoiISMvkMgHLxobASCZg5/lM7IzLkLokg8EgQ0RE1ATauVrjhX6tAQALtp5HfmmlxBUZBgYZIiKiJvLSQD/4OlriZmE5Fv11HgY+cbhJMMgQERE1ETNjOT4YGwKZAGw+k4b1p65JXZLeY5AhIiJqQl28W2LeUH8AwMK/zuN8er7EFek3BhkiIqIm9kLf1hgU4ISKKiVe/DWa42UagUGGiIioiclkAj4e1wGtbM2RklOCl36LRqVCKXVZeolBhoiISAK2Fib4dnJnmBvLcTgxGwu3cvCvOhhkiIiIJBLUygafTwiFIAC/n0zFt4eSpS5J7zDIEBERSWhwe2cseLg9AGDZjovYfIa7ZDcEgwwREZHEpvX2wdRe3gCAeX+cxa7zmdIWpEcYZIiIiHTAgofbY2wndyiUImb9dgaHE29KXZJeYJAhIiLSATKZgOVjgzE8yAUVCiWeXXsaxy5nS12WzmOQISIi0hFGchk+eyIUA/wdUVapxNQ1p3DoEntm7odBhoiISIeYGMnwzeTOGBTghPIqJaavPY0DCVlSl6WzGGSIiIh0jKmRHCsndcaQ9s6oqFLiubWnsTUmTeqydBKDDBERkQ4yMZLhq4mdMKKDGyoVIl5eF4Pvj1yRuiydwyBDRESko4zlMnw2vqNqava72+OxbMdFrgB8FwYZIiIiHSaTCVj4SHu8MSwAAPBNRBLm/XGWezPdxiBDRESk4wRBwIz+rfHhYyGQywRsjL6O59aeRklFldSlSY5BhoiISE883sUDq57qDDNjGQ4k3MS4byORmV8mdVmSYpAhIiLSIwMDnPHr9B6wtzRBXFoBRn55BGev50ldlmQYZIiIiPRMZy87bJnZC/7OVsgqLMfj30Ri+9l0qcuSBIMMERGRHvJoaYE/Z4Rh4O2F81767Qw+25vY7GY0McgQERHpKSszY6x6qgue7eMDAPh07yXM+v0MSisUElfWdBhkiIiI9JhcJuCth9tj+dhgGMkEbD+bgdFfH0VKTrHUpTUJBhkiIiIDML6rJ36d3h0OLUxwMbMQI744ggMXDX+PJgYZIiIiA9Hd1x7bZ/VBqKctCsqqMO2nU1ix9xKUSsMdN8MgQ0REZEBcbMyw/rkwTO7hBVEEVuxNxPS1p5FfUil1aVrBIENERGRgTIxkeHdUED56vANMjWTYfzELI786ggsZBVKXpnEMMkRERAbqsc7u2DijJ9ztzJGSU4LRXx/F1pg0qcvSKAYZIiIiAxbUygbbXuqNvm0dUVapxMvrYrB423mD2XSSQYaIiMjA2Vma4Menu+KlAX4AgB+PXsXEVSeQVaj/+zQxyBARETUDcpmAeUP98d3kzrAyNcLJq7kY8cURRKXkSl1aozDIEBERNSNDAl2w9aVeaOPUAjcKyvHEd8fxc+RVvd3agEGGiIiomfF1bIEtM3vh4RBXVCpELNh6Hq/+EYuySv3b2oBBhoiIqBmyNDXClxNC8dZD7SCXCdgUnYaxK4/hWm6J1KU1CIMMERFRMyUIAp7t64tfnukOe0sTnE8vwMgvj+BIYrbUpdUbgwwREVEzF9baHttm9UaIuw1ulVTiqR9O4JuIJL0YN8MgQ0RERHCzNceG58Mwros7lCKwbMdFzPwtGkXlVVKXdl8MMkRERAQAMDOWY/nYELw3KgjGcgH/nMvE6K+OIvlmkdSl1YlBhoiIiFQEQcCkHl5Y91wYnKxMkZhVhEe/PIq98TekLu2eGGSIiIiols5edtg+qze6eNmhsLwK09eexoq9l3Ru3AyDDBEREd2Tk7UZfnu2B6aEeQEAVuxNxKzfz+jUejMMMkRERFQnEyMZFj8ahOVjg2EkE7D9bAbGfxuJGwW6sU8TgwwRERE90PiunvhlenfYWhgj9no+Hv3yKOLS8qUui0GGiIiI6qeHrz22zuyF1o6WyCwow2PfHMOOcxmS1sQgQ0RERPXmZW+JzTN7oW9bR5RVKjHj12h8f+SKZPUwyBAREVGDWJsZ44cpXTC1lzeMZALauVpJVovOBJlly5ZBEATMmTNHdSwzMxOTJ0+Gi4sLLC0t0alTJ2zcuFG6IomIiAgAYCSX4Z0Rgdg5py96tnaQrA6dCDKnTp3Ct99+i5CQkBrHn3rqKSQkJOCvv/7CuXPnMGbMGIwbNw5nzpyRqFIiIiK6m59TC0lfX/IgU1RUhIkTJ2LVqlWws7Orce7YsWOYNWsWunXrBl9fX7z99tuwtbVFVFRUndcrLy9HQUFBjQcREREZJsmDzMyZM/Hwww8jPDy81rmePXti/fr1yM3NhVKpxLp161BWVob+/fvXeb2lS5fCxsZG9fDw8NBi9URERCQlSYPMunXrEB0djaVLl97z/IYNG1BZWQl7e3uYmpri+eefx+bNm+Hn51fnNefPn4/8/HzV49q1a9oqn4iIiCRmJNULX7t2DS+//DL27NkDMzOzez5nwYIFyMvLw969e+Hg4IAtW7Zg3LhxOHz4MIKDg+/5PaampjA1NdVm6URERKQjBFGi3Z+2bNmC0aNHQy6Xq44pFAoIggCZTIaEhAT4+fkhLi4OgYGBqueEh4fDz88P33zzTb1ep6CgADY2NsjPz4e1tbXG20FERESaV9/Pb8l6ZAYNGoRz587VODZ16lQEBATgjTfeQElJCQBAJqt590sul0OpVDZZnURERKS7JAsyVlZWCAoKqnHM0tIS9vb2CAoKQmVlJfz8/PD888/jo48+gr29PbZs2YI9e/Zg+/btElVNREREukTyWUt1MTY2xj///ANHR0eMGDECISEhWLt2LX766Sc89NBDUpdHREREOkCyMTJNhWNkiIiI9E99P791tkeGiIiI6EEYZIiIiEhvMcgQERGR3mKQISIiIr0l2fTrpnJnLDM3jyQiItIfdz63HzQnyeCDTGFhIQBw80giIiI9VFhYCBsbmzrPG/z0a6VSifT0dFhZWUEQBI1dt6CgAB4eHrh27ZrBTus29DYaevsAw28j26f/DL2NbJ/6RFFEYWEh3Nzcaq3yfzeD75GRyWRwd3fX2vWtra0N8ofzbobeRkNvH2D4bWT79J+ht5HtU8/9emLu4GBfIiIi0lsMMkRERKS3GGTUZGpqinfeeQempqZSl6I1ht5GQ28fYPhtZPv0n6G3ke3TPoMf7EtERESGiz0yREREpLcYZIiIiEhvMcgQERGR3mKQISIiIr3FIPMfhw4dwogRI+Dm5gZBELBly5Zaz7lw4QJGjhwJGxsbWFpaomvXrkhNTVWdLysrw8yZM2Fvb48WLVpg7NixuHHjRhO2om71ad8dL7zwAgRBwIoVK2ocz83NxcSJE2FtbQ1bW1s888wzKCoq0m7hDXC/NlZWVuKNN95AcHAwLC0t4ebmhqeeegrp6ek1rqHLbXzQv6Eoili4cCFcXV1hbm6O8PBwJCYm1niOLrfvvxQKBRYsWAAfHx+Ym5ujdevWePfdd2vsv1KfNuuytLQ0TJo0Cfb29jA3N0dwcDBOnz6tOq/v7fuvZcuWQRAEzJkzR3VMl983H2Tp0qXo2rUrrKys4OTkhFGjRiEhIaHGc/S5fffz1VdfwdvbG2ZmZujevTtOnjzZ5DUwyPxHcXExOnTogK+++uqe55OSktC7d28EBATg4MGDOHv2LBYsWAAzMzPVc+bOnYtt27bhjz/+QEREBNLT0zFmzJimasJ9Pah9d2zevBnHjx+Hm5tbrXMTJ07E+fPnsWfPHmzfvh2HDh3Cc889p62SG+x+bSwpKUF0dDQWLFiA6OhobNq0CQkJCRg5cmSN5+lyGx/0b/jBBx/g888/xzfffIMTJ07A0tISQ4cORVlZmeo5uty+/1q+fDlWrlyJL7/8EhcuXMDy5cvxwQcf4IsvvlA9pz5t1lW3bt1Cr169YGxsjB07diA+Ph4ff/wx7OzsVM/R5/b916lTp/Dtt98iJCSkxnFdft98kIiICMycORPHjx/Hnj17UFlZiSFDhqC4uFj1HH1uX13Wr1+PV155Be+88w6io6PRoUMHDB06FFlZWU1biEh1AiBu3ry5xrHx48eLkyZNqvN78vLyRGNjY/GPP/5QHbtw4YIIQIyMjNRWqWq5V/tEURSvX78utmrVSoyLixO9vLzETz/9VHUuPj5eBCCeOnVKdWzHjh2iIAhiWlpaE1TdMHW18W4nT54UAYgpKSmiKOpXG//bPqVSKbq4uIgffvih6lheXp5oamoq/v7776Io6lf7RFEUH374YXHatGk1jo0ZM0acOHGiKIr1a7Mue+ONN8TevXvXeV7f23e3wsJCsU2bNuKePXvEfv36iS+//LIoivr1vlkfWVlZIgAxIiJCFEXDa98d3bp1E2fOnKn6WqFQiG5ubuLSpUubtA72yDSAUqnE33//jbZt22Lo0KFwcnJC9+7da3TtR0VFobKyEuHh4apjAQEB8PT0RGRkpARVN4xSqcTkyZPx2muvITAwsNb5yMhI2NraokuXLqpj4eHhkMlkOHHiRFOWqjH5+fkQBAG2trYA9LuNV65cQWZmZo2fPxsbG3Tv3l3186dv7evZsyf27duHS5cuAQBiY2Nx5MgRDB8+HED92qzL/vrrL3Tp0gWPP/44nJycEBoailWrVqnO63v77jZz5kw8/PDDNdoC6P/75n/l5+cDAFq2bAnA8NoHABUVFYiKiqrRJplMhvDw8CZvE4NMA2RlZaGoqAjLli3DsGHDsHv3bowePRpjxoxBREQEACAzMxMmJiaqD8U7nJ2dkZmZKUHVDbN8+XIYGRlh9uzZ9zyfmZkJJyenGseMjIzQsmVLvWjff5WVleGNN97AhAkTVBue6XMb79Tn7Oxc4/jdP3/61r4333wTTzzxBAICAmBsbIzQ0FDMmTMHEydOBFC/Nuuy5ORkrFy5Em3atMGuXbswY8YMzJ49Gz/99BMA/W/fHevWrUN0dDSWLl1a65y+v2/eTalUYs6cOejVqxeCgoIAGFb77sjOzoZCodCJn0uD3/1ak5RKJQDg0Ucfxdy5cwEAHTt2xLFjx/DNN9+gX79+UpbXaFFRUfjss88QHR0NQRCkLkfrKisrMW7cOIiiiJUrV0pdDtVhw4YN+PXXX/Hbb78hMDAQMTExmDNnDtzc3DBlyhSpy2s0pVKJLl26YMmSJQCA0NBQxMXF4ZtvvjGI9gHAtWvX8PLLL2PPnj01xhMaopkzZyIuLg5HjhyRupRmgz0yDeDg4AAjIyO0b9++xvF27dqpZi25uLigoqICeXl5NZ5z48YNuLi4NFWpajl8+DCysrLg6ekJIyMjGBkZISUlBa+++iq8vb0BVLfvvwO5qqqqkJubq/Ptu9udEJOSkoI9e/bU2H5en9t4p77/zoa4++dP39r32muvqXplgoODMXnyZMydO1f1m3192qzLXF1dH/ieAuhv+4DqX5KysrLQqVMn1XtLREQEPv/8cxgZGcHZ2Vlv3zfv9tJLL2H79u04cOAA3N3dVcf1+XOhLg4ODpDL5Trxc8kg0wAmJibo2rVrrWl1ly5dgpeXFwCgc+fOMDY2xr59+1TnExISkJqairCwsCatt6EmT56Ms2fPIiYmRvVwc3PDa6+9hl27dgEAwsLCkJeXh6ioKNX37d+/H0qlEt27d5eq9Aa5E2ISExOxd+9e2Nvb1zivz2308fGBi4tLjZ+/goICnDhxQvXzp2/tKykpgUxW861KLperekjr02Zd1qtXr/u+p+h7+wBg0KBBOHfuXI33li5dumDixImqP+vr+yZQPT3+pZdewubNm7F//374+PjUOK/Pnwt1MTExQefOnWu0SalUYt++fU3fpiYdWqwHCgsLxTNnzohnzpwRAYiffPKJeObMGdWMlk2bNonGxsbid999JyYmJopffPGFKJfLxcOHD6uu8cILL4ienp7i/v37xdOnT4thYWFiWFiYVE2q4UHt+6//zloSRVEcNmyYGBoaKp44cUI8cuSI2KZNG3HChAlNUH393K+NFRUV4siRI0V3d3cxJiZGzMjIUD3Ky8tV19DlNj7o33DZsmWira2tuHXrVvHs2bPio48+Kvr4+IilpaWqa+hy+/5rypQpYqtWrcTt27eLV65cETdt2iQ6ODiIr7/+uuo59Wmzrjp58qRoZGQkvv/++2JiYqL466+/ihYWFuIvv/yieo4+t68ud89aEkXdft98kBkzZog2NjbiwYMHa7ynlJSUqJ6jz+2ry7p160RTU1NxzZo1Ynx8vPjcc8+Jtra2YmZmZpPWwSDzHwcOHBAB1HpMmTJF9Zzvv/9e9PPzE83MzMQOHTqIW7ZsqXGN0tJS8cUXXxTt7OxECwsLcfTo0WJGRkYTt+Te6tO+u90ryOTk5IgTJkwQW7RoIVpbW4tTp04VCwsLtV98Pd2vjVeuXLnnOQDigQMHVNfQ5TY+6N9QqVSKCxYsEJ2dnUVTU1Nx0KBBYkJCQo1r6HL7/qugoEB8+eWXRU9PT9HMzEz09fUV33rrrRrBsz5t1mXbtm0Tg4KCRFNTUzEgIED87rvvapzX9/bdy3+DjC6/bz5IXe8pP/74o+o5+ty++/niiy9ET09P0cTEROzWrZt4/PjxJq9BEMW7lsckIiIi0iMcI0NERER6i0GGiIiI9BaDDBEREektBhkiIiLSWwwyREREpLcYZIiIiEhvMcgQERGR3mKQISIiIr3FIENEWvH0009j1KhRkr3+5MmTVTtKa0N8fDzc3d1RXFystdcgogdjkCGiBhME4b6PRYsW4bPPPsOaNWskqS82Nhb//PMPZs+erTrWv39/CIKAZcuW1Xr+ww8/rKq7vtq3b48ePXrgk08+0UTJRKQmBhkiarCMjAzVY8WKFbC2tq5xbN68ebCxsYGtra0k9X3xxRd4/PHH0aJFixrHPTw8aoWrtLQ07Nu3D66urg1+nalTp2LlypWoqqpqTLlE1AgMMkTUYC4uLqqHjY0NBEGocaxFixa1bi31798fs2bNwpw5c2BnZwdnZ2esWrUKxcXFmDp1KqysrODn54cdO3bUeK24uDgMHz4cLVq0gLOzMyZPnozs7Ow6a1MoFPjzzz8xYsSIWuceeeQRZGdn4+jRo6pjP/30E4YMGQInJ6caz/3555/RpUsXWFlZwcXFBU8++SSysrJqPGfw4MHIzc1FREREQ/76iEiDGGSIqMn89NNPcHBwwMmTJzFr1izMmDEDjz/+OHr27Ino6GgMGTIEkydPRklJCQAgLy8PAwcORGhoKE6fPo2dO3fixo0bGDduXJ2vcfbsWeTn56NLly61zpmYmGDixIn48ccfVcfWrFmDadOm1XpuZWUl3n33XcTGxmLLli24evUqnn766VrX69ixIw4fPqzm3wgRNRaDDBE1mQ4dOuDtt99GmzZtMH/+fJiZmcHBwQHPPvss2rRpg4ULFyInJwdnz54FAHz55ZcIDQ3FkiVLEBAQgNDQUPzwww84cOAALl26dM/XSElJgVwur9XDcse0adOwYcMGFBcX49ChQ8jPz8cjjzxyz+cNHz4cvr6+6NGjBz7//HPs2LEDRUVFNZ7n5uaGlJSURv7NEJG6jKQugIiaj5CQENWf5XI57O3tERwcrDrm7OwMAKpbOLGxsThw4ECtsS4AkJSUhLZt29Y6XlpaClNTUwiCcM8aOnTogDZt2uDPP//EgQMHMHnyZBgZ1X4rjIqKwqJFixAbG4tbt25BqVQCAFJTU9G+fXvV88zNzVU9SETU9BhkiKjJGBsb1/haEIQax+6EjzuhoaioCCNGjMDy5ctrXauuwbkODg4oKSlBRUUFTExM7vmcadOm4auvvkJ8fDxOnjxZ63xxcTGGDh2KoUOH4tdff4WjoyNSU1MxdOhQVFRU1Hhubm4uWrdufZ9WE5E28dYSEemsTp064fz58/D29oafn1+Nh6Wl5T2/p2PHjgCq13mpy5NPPolz584hKCioRu/KHRcvXkROTg6WLVuGPn36ICAgoNZA3zvi4uIQGhra8MYRkUYwyBCRzpo5cyZyc3MxYcIEnDp1CklJSdi1axemTp0KhUJxz+9xdHREp06dcOTIkTqva2dnh4yMDOzbt++e5z09PWFiYoIvvvgCycnJ+Ouvv/Duu+/Wet7Vq1eRlpaG8PBw9RpIRI3GIENEOsvNzQ1Hjx6FQqHAkCFDEBwcjDlz5sDW1hYyWd1vX9OnT8evv/5632vb2trW2avj6OiINWvW4I8//kD79u2xbNkyfPTRR7We9/vvv2PIkCHw8vJqWMOISGMEURRFqYsgItKk0tJS+Pv7Y/369QgLC9PKa1RUVKBNmzb47bff0KtXL628BhE9GHtkiMjgmJubY+3atfddOK+xUlNT8X//938MMUQSY48MERER6S32yBAREZHeYpAhIiIivcUgQ0RERHqLQYaIiIj0FoMMERER6S0GGSIiItJbDDJERESktxhkiIiISG8xyBAREZHe+n84s/zzoIRXTwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -355,13 +788,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "594913154d98431994a8c4a3808e006b", + "model_id": "f70eeefae1bf408fb5038ff1a0136b64", "version_major": 2, "version_minor": 0 }, @@ -378,7 +811,7 @@ "" ] }, - "execution_count": 12, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -401,13 +834,13 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f71f1c3e04b54b47bd8402b597b926d5", + "model_id": "79ba1eb98f85496aaf9db68a0d533334", "version_major": 2, "version_minor": 0 }, @@ -424,7 +857,7 @@ "" ] }, - "execution_count": 17, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } diff --git a/tests/benchmark/temperer3D_hypothetical_extended.py b/tests/benchmark/temperer3D_hypothetical_extended.py deleted file mode 100644 index e84ac87..0000000 --- a/tests/benchmark/temperer3D_hypothetical_extended.py +++ /dev/null @@ -1,297 +0,0 @@ -import numpy as np -import pickle -import itertools -from warmth3d.fixed_mesh_model import UniformNodeGridFixedSizeMeshModel -from warmth3d.Helpers import NodeGrid -from warmth3d.resqpy_helpers import read_mesh_resqml - -def tic(): - #Homemade version of matlab tic and toc functions - import time - global startTime_for_tictoc - startTime_for_tictoc = time.time() - -def toc(msg=""): - import time - if 'startTime_for_tictoc' in globals(): - delta = time.time() - startTime_for_tictoc - print (msg+": Elapsed time is " + str(delta) + " seconds.") - return delta - else: - print ("Toc: start time not set") - -def nodeFromDataArray(nodeGrid, node_data_array, nodeid_x, nodeid_y): - origin_x = nodeGrid.origin_x - origin_y = nodeGrid.origin_y - stepx = nodeGrid.step_x - stepy = nodeGrid.step_y - class GenericObject(object): - pass - node = GenericObject - node.X, node.Y = node_data_array[0:2] - node.subsidence = node_data_array[3] - node.crust_ls = node_data_array[4] - node.lith_ls = node_data_array[5] - node.sed = node_data_array[2] - node.X, node.Y = (origin_x + stepx*nodeid_x, origin_y + stepy*nodeid_y) - node.sed_thickness_ls = node.sed[-1,1,:] - node.sed[0,0,:] - node.sediments = node_data_array[6] - if len(node_data_array)>7: - node.beta = node_data_array[7] - if len(node_data_array)>9: - node.depth_out = node_data_array[8].copy() - node.temperature_out = node_data_array[9].copy() - if len(node_data_array)>10: - node.parameters = node_data_array[10] - return node - -def interpolateNode(interpolationNodes, interpolationWeights): - assert len(interpolationNodes)>0 - assert len(interpolationNodes)==len(interpolationWeights) - wsum = np.sum(np.array(interpolationWeights)) - iWeightNorm = [ w/wsum for w in interpolationWeights] - class GenericObject(object): - pass - node = GenericObject - node.X = np.sum( np.array( [node.X * w for node,w in zip(interpolationNodes,iWeightNorm)] ) ) - node.Y = np.sum( np.array( [node.Y * w for node,w in zip(interpolationNodes,iWeightNorm)] ) ) - node.subsidence = np.sum( np.array( [node.subsidence * w for node,w in zip(interpolationNodes,iWeightNorm)] ) , axis = 0) - node.crust_ls = np.sum( np.array( [node.crust_ls * w for node,w in zip(interpolationNodes,iWeightNorm)] ) , axis = 0) - node.lith_ls = np.sum( np.array( [node.lith_ls * w for node,w in zip(interpolationNodes,iWeightNorm)] ) , axis = 0) - node.beta = np.sum( np.array( [node.beta * w for node,w in zip(interpolationNodes,iWeightNorm)] ) , axis = 0) - # node.kAsth = np.sum( np.array( [node.kAsth * w for node,w in zip(interpolationNodes,iWeightNorm)] ) , axis = 0) - # node.kLith = np.sum( np.array( [node.kLith * w for node,w in zip(interpolationNodes,iWeightNorm)] ) , axis = 0) - node.sediments = interpolationNodes[0].sediments.copy() - return node - -def loadOrInterpolateNode(nodeGrid, nodeDirectoryPrefix, nodeid_x, nodeid_y): - # full_simulation = (nodeid_x % 10 == 0) and (nodeid_y % 10 == 0) - full_simulation = False - if not full_simulation: - # - # TODO: replace the hard-coded min/max node ranges - nodeid_x_expanded = max(min(nodeid_x,96),2) - nodeid_y_expanded = max(min(nodeid_y,96),2) - - sedFileName = nodeDirectoryPrefix+"node-sed-"+str(nodeid_x_expanded)+"-"+str(nodeid_y_expanded)+".pkl" - try: - sed_data_array = pickle.load( open(sedFileName,"rb") ) - # X, Y = sed_data_array[0], sed_data_array[1] - sed = sed_data_array[2] - except FileNotFoundError as e: - print("1D sediment solution not found: ", sedFileName) - breakpoint() - return - # node = interpolateNode(interpolationNodes, interpolationWeight) - class GenericObject(object): - pass - node = GenericObject - node.subsidence = np.zeros(sed.shape[2]) - node.crust_ls = np.zeros(sed.shape[2]) - node.lith_ls = np.zeros(sed.shape[2]) - node.beta = 1 - - props_shale = { - 'k_cond': 1.64, - 'rhp': 2.034, - 'phi': 0.7, - 'decay': 0.83, - 'solidus': 2700, - } - props_sand = { - 'k_cond': 3.95, - 'rhp': 0.703, - 'phi': 0.41, - 'decay': 0.31, - 'solidus': 2720, - } - props_salt = { - 'k_cond': 6.5, - 'rhp': 0.012, - 'phi': 0.01, - 'decay': 0.0001, - 'solidus': 2200, - } - - num_sed = len(node.sediments['k_cond']) - props = [props_sand, props_sand] - # props = [props_sand, props_sand, props_salt] - - for key in ['k_cond', 'rhp', 'phi', 'decay', 'solidus']: - node.sediments[key] = [props[sed][key] for sed in range(num_sed) ] - - node.sed = sed - node.sed_thickness_ls = node.sed[-1,1,:] - node.sed[0,0,:] - origin_x = nodeGrid.origin_x - origin_y = nodeGrid.origin_y - stepx = nodeGrid.step_x - stepy = nodeGrid.step_y - node.X = origin_x + stepx*nodeid_x - node.Y = origin_y + stepy*nodeid_y - - expandEdgeElements = 1200 - if (expandEdgeElements>0): - if (nodeid_x== nodeGrid.start_index_x): - node.X = node.X - 6*expandEdgeElements - if (nodeid_x== nodeGrid.start_index_x+1): - node.X = node.X - 3*expandEdgeElements - if (nodeid_x== nodeGrid.start_index_x+2): - node.X = node.X - expandEdgeElements - if (nodeid_x== nodeGrid.start_index_x+nodeGrid.num_nodes_x-1): - node.X = node.X + 6*expandEdgeElements - if (nodeid_x== nodeGrid.start_index_x+nodeGrid.num_nodes_x-2): - node.X = node.X + 3*expandEdgeElements - if (nodeid_x== nodeGrid.start_index_x+nodeGrid.num_nodes_x-3): - node.X = node.X + expandEdgeElements - if (nodeid_y== nodeGrid.start_index_y): - node.Y = node.Y - 6*expandEdgeElements - if (nodeid_y== nodeGrid.start_index_y+1): - node.Y = node.Y - 3*expandEdgeElements - if (nodeid_y== nodeGrid.start_index_y+2): - node.Y = node.Y - expandEdgeElements - if (nodeid_y== nodeGrid.start_index_y+nodeGrid.num_nodes_y-1): - node.Y = node.Y + 6*expandEdgeElements - if (nodeid_y== nodeGrid.start_index_y+nodeGrid.num_nodes_y-2): - node.Y = node.Y + 3*expandEdgeElements - if (nodeid_y== nodeGrid.start_index_y+nodeGrid.num_nodes_y-3): - node.Y = node.Y + expandEdgeElements - - return node - else: - nodeFileName = nodeDirectoryPrefix+"node-slim-"+str(nodeid_x)+"-"+str(nodeid_y)+".pkl" - try: - node_data_array = pickle.load( open(nodeFileName,"rb") ) - except FileNotFoundError as e: - print("1D Node solution not found: ", nodeFileName) - breakpoint() - return - node = nodeFromDataArray(nodeGrid, node_data_array, nodeid_x, nodeid_y) - return node - -def run( nodeGrid, run_simulation=True, start_time=182, end_time=0, out_dir = "out-hypothetical/"): - nodes = [] - modelNamePrefix = ng.modelNamePrefix - - cols = ng.num_nodes_x - rows = ng.num_nodes_y - ind_step = ng.step_index - start_index_x = ng.start_index_x - start_index_y = ng.start_index_y - - print("PING A") - tic() - - nodeFileName = nodeGrid.nodeDirectoryPrefix+"nodeX.pkl" - # node_data_array = pickle.load( open(nodeFileName,"rb") ) - # nodeX = nodeFromDataArray(nodeGrid, node_data_array, nodeid_x, nodeid_y) - nodeX = pickle.load( open(nodeFileName,"rb") ) - - for j in range(rows): - for i in range(cols): - nodeid_x = start_index_x + i * ind_step - nodeid_y = start_index_y + j * ind_step - - node = loadOrInterpolateNode(nodeGrid , nodeGrid.nodeDirectoryPrefix, nodeid_x, nodeid_y) - node.sediments = nodeX.sediments.copy() - nodes.append(node) - - print("PING B") - toc("load nodes") - - # - # shift sediments to lower base - # - for ti in range(nodes[0].sed_thickness_ls.shape[0]): - maxes = [ np.amax(n.sed[:,:,ti]) for n in nodes ] - globalmax = np.amax(np.array(maxes)) - for i,n in enumerate(nodes): - diff = (globalmax - np.amax(n.sed[:,:,ti])) - n.sed[:,:,ti] = n.sed[:,:,ti] + diff - n.subsidence[ti] = diff - - - print("=====",nodes[0].subsidence) - characteristic_length = ind_step * ng.step_x - - nums = 4 - dt = 314712e8 / nums - - mms2 = [] - mms_tti = [] - - tti = 0 - - writeout = True - - if not run_simulation: - return - time_solve = 0.0 - - for tti in range(start_time, end_time-1,-1): - rebuild_mesh = (tti==start_time) - - build_tti = 0 # use the full stack at every time step - # build_tti = tti # do sedimentation: update stack positions at time steps - - if rebuild_mesh: - print("Rebuild/reload mesh at tti=", tti) - mm2 = UniformNodeGridFixedSizeMeshModel(nodeGrid, nodes, modelName=modelNamePrefix+str(tti), sedimentsOnly=True) - mm2.buildMesh(build_tti) - else: - print("Re-generating mesh vertices at tti=", tti) - mm2.updateMesh(build_tti) - - mm2.baseFluxMagnitude = 0.04 if (tti>50) else 0.04 - print("===",tti," ",mm2.baseFluxMagnitude,"=========== ") - if ( len(mms2) == 0): - tic() - mm2.setupSolverAndSolve(no_steps=nums, time_step = dt, skip_setup=False) - time_solve = time_solve + toc(msg="setup solver and solve") - else: - tic() - # mm2.setupSolverAndSolve( initial_state_model=mms2[-1], no_steps=nums, time_step=dt, skip_setup=(not rebuild_mesh)) - mm2.setupSolverAndSolve( no_steps=nums, time_step=dt, skip_setup=(not rebuild_mesh)) - time_solve = time_solve + toc(msg="setup solver and solve") - # subvolumes.append(mm2.evaluateVolumes()) - if (writeout): - tic() - mm2.writeLayerIDFunction(out_dir+"LayerID-"+str(tti)+".xdmf", tti=tti) - mm2.writeTemperatureFunction(out_dir+"Temperature-"+str(tti)+".xdmf", tti=tti) - toc(msg="write function") - if (tti==0): - fn = out_dir+"mesh-pos-"+str(tti)+".npy" - np.save(fn, mm2.mesh.geometry.x) - fn = out_dir+"T-value-"+str(tti)+".npy" - np.save(fn, mm2.uh.x.array[:]) - fn = out_dir+"cell-pos-"+str(tti)+".npy" - np.save(fn, mm2.getCellMidpoints()) - fn = out_dir+"k-value-"+str(tti)+".npy" - np.save(fn, mm2.thermalCond.x.array[:]) - fn = out_dir+"phi-value-"+str(tti)+".npy" - np.save(fn, mm2.mean_porosity.x.array[:]) - - mms2.append(mm2) - mms_tti.append(tti) - print("total time solve: " , time_solve) - EPCfilename = mm2.write_hexa_mesh_resqml("temp/") - print("RESQML model written to: " , EPCfilename) - # read_mesh_resqml(EPCfilename, meshTitle="hexamesh") # test reading of the .epc file - - -# -# NOTE: to compute the required 1D node solutions, you must first run warmth3d/parallel-1Dsed.py using the same NodeGrid parameters as below! -# - -# ng = NodeGrid(0, 0, 97, 97, 2, 2, 1, 100, 100) -ng = NodeGrid(0, 0, 97+27+25, 97+27+25, -25, -25, 1, 100, 100) # pad/extend the system by 25 nodes in each direction - -ng.modelNamePrefix = "hypo-all-nodes-" -ng.nodeDirectoryPrefix = "nodes-hypothetical/" - -import os -for output_dir in ["out-hypothetical/", "mesh", "temp"]: - if not os.path.exists(output_dir): - os.makedirs(output_dir) - -run( ng, run_simulation=True, start_time=2, end_time=0, out_dir = "out-hypothetical/") - diff --git a/warmth/build.py b/warmth/build.py index b058086..f498cc6 100644 --- a/warmth/build.py +++ b/warmth/build.py @@ -231,6 +231,8 @@ def _tidy_sediments(df:pd.DataFrame)->pd.DataFrame: df['erosion'] = 0 if 'erosion_duration' not in df: df['erosion_duration'] = 0 + df['erosion'] = df['erosion'].fillna(0) + df['erosion_duration'] = df['erosion_duration'].fillna(0) base = df["top"].values[1:] top = df["top"].values[:-1] diff --git a/warmth/forward_modelling.py b/warmth/forward_modelling.py index 4162daf..33854df 100644 --- a/warmth/forward_modelling.py +++ b/warmth/forward_modelling.py @@ -860,7 +860,6 @@ def _sedimentation(self): elif layer_total_duration > 0 and erosion_started and layer_has_erosion: sedrate[i,active_index] = eroded_grain_thickness[active_index]/erosion_duration[active_index] *-1 if layer_has_erosion: - #print(erosion_start_age,erosion_started,i,deposition_duration) sed_rate_before_erosion_starts = paleo_total_grain_thickness[active_index]/deposition_duration sed_rate_during_erosion = eroded_grain_thickness[active_index]/erosion_duration[active_index] *-1 s_e = sed_rate_during_erosion *sedrate[i:erosion_start_age].size @@ -868,7 +867,6 @@ def _sedimentation(self): total_size = sedrate[i:erosion_start_age].size +sedrate[erosion_start_age:baseage[active_index]].size mean_sed = (s_e+s_f)/total_size seddep[active_index] = mean_sed*(baseage[active_index] - i) - #print(seddep[active_index],sedrate[i,active_index],i) else: seddep[active_index] = sedrate[i,active_index]*(baseage[active_index] - i) @@ -881,8 +879,6 @@ def _sedimentation(self): if seddep[0] < 0: seddep[0] = 0 maximum_burial_depth = np.maximum(maximum_burial_depth, sed[:, 1, i-1]) - if layer_has_erosion: - print(maximum_burial_depth) # Compact if baseage[active_index] > i: # We have at least one layer layer_thickness = self._compact_many_layers(seddep[active_index:], @@ -900,6 +896,39 @@ def _sedimentation(self): self.current_node.sedrate = sedrate * 1000 return + def get_sediments(self, time:int, Tsed_old: np.ndarray): + #xsed = np.append(self.current_node.sed[:,:,time][:,0], self.current_node.sed[:,:,time][-1,-1]) + idsed = np.argwhere(self.current_node.sed[:,:,time][:,-1] >0).flatten() + HPsed = self.current_node.sediments["rhp"].values[idsed] + seabed_idx = np.argwhere(self.current_node.sed[:,:,time][:,0] == 0).flatten()[-1] + if np.sum(self.current_node.sed[:,:,time]) == 0: # no sediment for all layers at this time step + xsed = self.current_node.sed[:,:,time][seabed_idx:,0] + else: + xsed = np.append(self.current_node.sed[:,:,time][seabed_idx:,0], self.current_node.sed[:,:,time][-1,-1]) + # remove hiatus layer + idsed = np.argwhere(self.current_node.sed[:,:,time][:,-1] >0).flatten() + + # layers with no thickness + hiatus_layers = np.argwhere((self.current_node.sed[:,:,time][:,1]-self.current_node.sed[:,:,time][:,0]==0) & (self.current_node.sed[:,:,time][:,1]!=0)).flatten() + if hiatus_layers.size > 0: + xsed = np.unique(xsed) + indx = np.ravel([np.where(idsed == i) for i in hiatus_layers]) + idsed = np.delete(idsed, indx) + ##### + HPsed = self.current_node.sediments["rhp"].values[idsed] + if Tsed_old.size < xsed.size: # new layer added + Tsed = np.append(np.zeros(xsed.size-Tsed_old.size), Tsed_old) + else: + Tsed = Tsed_old + active_layer = np.argwhere((self.current_node.sediments['baseage'].values >time)).flatten()[0] + if self.current_node.sedrate[time,active_layer] > 0: # has new sediment but no new layer + Tsed[0] = 0 # set new sediment to 0 degree. Solver will set top boundary condition to 5 + sedflag = xsed.size > 1 + assert xsed.size == Tsed.size + assert xsed.size -1 == HPsed.size + assert HPsed.size == idsed.size + return sedflag, xsed, Tsed, HPsed, idsed + def compaction(self,top_m: float, base_m: float, phi0: float, phi_decay: float, sed_id:int, base_maximum_burial_depth_m: float = 0) -> float: """Compact sediment at depth @@ -1121,9 +1150,7 @@ def _combine_new_old_sediments( xsed_old_recompacted[0]=0 HPsed_old = HPsed_old[n_node_to_delete:] idsed_old = idsed_old[n_node_to_delete:] - Tsed_old = Tsed_old[n_node_to_delete:] - # print(xsed_old_recompacted[-1], xsed_old[-1]) - + Tsed_old = Tsed_old[n_node_to_delete:] xsed = xsed_old_recompacted HPsed = HPsed_old idsed = idsed_old @@ -1335,14 +1362,15 @@ def simulate_one_rift_event( # print("Lith", i, hLith, lithUpdated) # Take care of sedimentation - sedflag, xsed, Tsed, HPsed, idsed = self.add_sediments( - self.current_node.sedrate[i, :], - self.current_node.sed[:, :, i], - xsed, - Tsed, - HPsed, - idsed, - ) + # sedflag, xsed, Tsed, HPsed, idsed = self.add_sediments( + # self.current_node.sedrate[i, :], + # self.current_node.sed[:, :, i], + # xsed, + # Tsed, + # HPsed, + # idsed, + # ) + sedflag, xsed, Tsed, HPsed, idsed = self.get_sediments(i, Tsed) ( T_newtemp, densityeff_crust_lith, @@ -1363,7 +1391,6 @@ def simulate_one_rift_event( HPsed, idsed, ) - # Interpolate temperature back to original coord T_new = np.interp(coord_start_this_rift, coord_current, T_newtemp) @@ -1605,6 +1632,7 @@ def calculate_new_temperature(self, coord_all = coord_crust_lith T_all = t_old HP_all = HP + mean_porosity_arr, sed_idx_arr = self._sediments_mean_porosity( xsed, idsed) # if (self.current_node.X==12150) and (self.current_node.Y==12000): diff --git a/warmth/postprocessing.py b/warmth/postprocessing.py index e416b19..eb00f13 100644 --- a/warmth/postprocessing.py +++ b/warmth/postprocessing.py @@ -25,6 +25,10 @@ class resultValues(TypedDict): layerId: np.ndarray[np.int32] values:np.ndarray[np.float64] + @property + def ages(self)-> np.ndarray: + return np.arange(self._depth.shape[1]) + def top_crust(self,age:int)->float: """Depth of crust