diff --git a/dynamic_model/pump_transient_benchmark/__pycache__/parameters_U235.cpython-312.pyc b/dynamic_model/pump_transient_benchmark/__pycache__/parameters_U235.cpython-312.pyc new file mode 100644 index 0000000..63c0dfa Binary files /dev/null and b/dynamic_model/pump_transient_benchmark/__pycache__/parameters_U235.cpython-312.pyc differ diff --git a/dynamic_model/pump_transient_benchmark/data/ornl_spindown.csv b/dynamic_model/pump_transient_benchmark/data/ornl_spindown.csv new file mode 100644 index 0000000..a7275cc --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/data/ornl_spindown.csv @@ -0,0 +1,73 @@ +0.0, 205.26315789473685 +0.9046563192904662, 206.3397129186603 +1.9157427937915745, 208.4928229665072 +2.926829268292683, 186.96172248803828 +3.884700665188471, 171.88995215311007 +4.8957871396895785, 144.97607655502395 +5.906873614190688, 142.82296650717706 +6.917960088691797, 130.622009569378 +7.929046563192904, 119.4976076555024 +8.886917960088692, 104.42583732057417 +9.951219512195124, 99.04306220095697 +10.90909090909091, 88.99521531100478 +11.92017738359202, 86.84210526315792 +12.931263858093129, 83.61244019138758 +13.942350332594234, 81.45933014354068 +15.059866962305989, 79.66507177033495 +15.964523281596453, 71.77033492822966 +16.922394678492243, 64.23444976076556 +17.98669623059867, 66.02870813397129 +18.944567627494457, 62.08133971291866 +19.955654101995567, 53.82775119617227 +20.966740576496676, 60.28708133971293 +21.924611973392462, 56.3397129186603 +22.988913525498894, 57.057416267942614 +23.946784922394677, 59.21052631578948 +25.01108647450111, 59.9282296650718 +25.9689578713969, 52.03349282296651 +26.926829268292682, 41.626794258373224 +27.937915742793795, 44.85645933014354 +28.9490022172949, 40.550239234449776 +29.960088691796006, 40.550239234449776 +30.97117516629712, 36.961722488038305 +31.982261640798225, 43.42105263157896 +33.046563192904664, 35.5263157894737 +33.95121951219513, 31.57894736842107 +35.06873614190688, 28.708133971291886 +35.97339246119735, 28.708133971291886 +37.03769401330377, 31.937799043062228 +37.99556541019957, 30.143540669856492 +39.00665188470067, 32.655502392344516 +39.85809312638582, 30.143540669856492 +40.97560975609757, 35.88516746411486 +41.880266075388036, 30.861244019138752 +42.99778270509979, 25.837320574162703 +43.902439024390254, 16.14832535885168 +45.019955654102, 20.095693779904337 +45.97782705099779, 20.813397129186626 +46.988913525498894, 24.401913875598098 +48.00000000000001, 20.813397129186626 +48.9578713968958, 24.401913875598098 +50.07538802660755, 20.454545454545467 +50.980044345898015, 21.889952153110073 +51.9379157427938, 16.866028708133967 +52.89578713968958, 19.01913875598089 +53.96008869179602, 19.01913875598089 +54.97117516629712, 18.66028708133973 +55.92904656319291, 19.37799043062202 +56.99334811529934, 18.301435406698573 +57.951219512195124, 21.531100478468915 +58.90909090909092, 19.37799043062202 +59.97339246119734, 15.43062200956939 +60.931263858093125, 6.818181818181841 +61.94235033259424, 9.330143540669894 +63.006651884700666, 11.84210526315789 +63.96452328159645, 7.894736842105289 +64.97560975609755, 7.177033492823 +65.98669623059867, 8.612440191387549 +67.0509977827051, 8.612440191387549 +67.90243902439025, 8.971291866028707 +68.96674057649668, 8.253588516746419 +69.97782705099779, 7.177033492823 +70.93569844789357, 7.894736842105289 +72, 8.971291866028707 diff --git a/dynamic_model/pump_transient_benchmark/data/ornl_spinup.csv b/dynamic_model/pump_transient_benchmark/data/ornl_spinup.csv new file mode 100644 index 0000000..739f1ae --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/data/ornl_spinup.csv @@ -0,0 +1,48 @@ +0.0, 0.35928164309859767 +1.0136592379583034, -2.046391876691928 +1.99352983465133, 3.3239141576573275 +2.93961179007908, -6.257502949583625 +3.9532710280373826, 20.045387470375147 +4.966930265995687, 42.75976114392245 +5.98058950395399, 72.05308218589082 +6.960460100647017, 100.74874707191478 +8.007907979870597, 129.4435520210237 +8.987778576563624, 164.1200781510668 +9.967649173256651, 190.42339853948312 +10.947519769949677, 225.09992466952622 +11.961179007907981, 250.20664284068118 +12.974838245866282, 280.0980500070515 +13.988497483824586, 278.2908925801203 +14.96836808051761, 278.8765096192543 +16.015815959741193, 247.16461600376994 +17.029475197699497, 219.0416691031546 +17.975557153127244, 223.8143189815595 +18.98921639108555, 221.4090754302264 +19.969086987778574, 216.61191734974324 +20.9489575844716, 200.4511229056236 +22.03019410496046, 205.2220529101985 +22.97627606038821, 201.02341092257473 +23.989935298346513, 201.0105118688493 +25.037383177570096, 204.58569959307783 +26.01725377426312, 200.38662763699654 +27.030913012221426, 204.56033145408452 +28.044572250179726, 207.5378630223687 +28.9568655643422, 203.3396510032024 +30.00431344356578, 205.1205803542252 +30.984184040258803, 199.72533614934008 +31.930265995686554, 215.26353626697946 +32.97771387491014, 206.8770015031697 +33.99137311286844, 209.25644694705196 +34.97124370956146, 211.63632235939173 +36.018691588785046, 214.01533783481642 +36.99856218547807, 219.98372999356766 +38.04601006470165, 214.58762585176748 +38.92451473759885, 209.79175767665683 +40.005751258087706, 204.39522356639915 +40.95183321351546, 209.1678734448041 +41.96549245147376, 216.93009400830357 +42.979151689432065, 218.11336720338198 +44.02659956865565, 207.3344879419646 +44.97268152408339, 204.3320182031446 +46.020129403306974, 198.93591406134445 +46.966211358734725, 203.11047781534745 diff --git a/dynamic_model/pump_transient_benchmark/data/spindown.csv b/dynamic_model/pump_transient_benchmark/data/spindown.csv new file mode 100644 index 0000000..1066b41 --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/data/spindown.csv @@ -0,0 +1,29 @@ +0.0, 100.00 +0.44195755537515935, 99.52055134938121 +0.6700104372028297, 98.59561637481153 +0.912849356372492, 97.06151322874041 +1.064420735242955, 95.83655009029007 +1.2906181143453552, 92.47825582743823 +1.6068073756233332, 87.13788704627159 +2.0433723762031772, 79.66170209241065 +2.4787776875797283, 70.66466758337336 +2.8983532413313227, 60.90803664617882 +3.0331671112141945, 57.70679743543015 +3.5299199814449724, 49.162704395222065 +3.906645019134871, 43.21068239426117 +4.389423634465963, 36.340352214178026 +4.8273802620897595, 30.689186726528717 +5.7500869766902465, 20.75313530259605 +6.568943523135799, 14.625006212620733 +7.00979937376783, 12.775964612912304 +8.409776179983766, 8.745547621808768 +9.76562681201438, 6.846805056244918 +10.847326916386407, 5.419227646990592 +12.005276585874984, 3.987508490581675 +12.995941087788474, 3.1732409999834346 +14.61150411689667, 1.8687563161644078 +15.404267656268118, 1.5215122347211008 +16.639278673315548, 1.1502460197809654 +17.843789864316363, 0.7806365037027234 +18.956685608256986, 0.2639121286923398 +20.0, 0.25 diff --git a/dynamic_model/pump_transient_benchmark/data/spinup.csv b/dynamic_model/pump_transient_benchmark/data/spinup.csv new file mode 100644 index 0000000..349665d --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/data/spinup.csv @@ -0,0 +1,37 @@ +0.0, 0.04304757443473761 +0.2471035766638533, 0.22234516401286442 +0.5283342688575431, 0.40358110591076013 +0.9885233389734, 0.7621762850669995 +1.413967443757496, 7.260179378354252 +1.6260171301886257, 16.8204560781479 +1.8210214309078352, 26.380086660501618 +1.9986714210141616, 38.838846195781656 +2.2107574515512876, 48.05797288729693 +2.40581626842949, 57.105878457233075 +2.618174879761583, 63.76638008666049 +2.830660695464659, 69.23285668711358 +3.0262101577738023, 73.67523714529162 +3.2133096154389755, 77.43499452819293 +3.4090226262251, 80.34219994911825 +3.613294673973177, 82.90857842048514 +3.8176394099332476, 84.79265687529528 +4.004938760181397, 86.67608921266552 +4.200778975338504, 88.3892696046165 +4.41368274826053, 89.93252110986822 +4.609559307523633, 91.30455149354084 +4.796895001877778, 92.84683382263268 +5.018375983814757, 93.87868337418679 +5.205784366380893, 94.73866568672187 +5.401733613855988, 95.42839605383773 +5.623250939898963, 96.11909559711347 +5.802209317821131, 96.29645483437183 +5.9982130814552175, 96.47446018907011 +6.245316658119071, 96.99555390436655 +6.509483792547842, 97.3467187329637 +6.765146406173652, 97.5269854987017 +6.995349973549566, 96.68283306344469 +7.268003456728303, 97.37547095904019 +7.498079819733233, 97.72534355275751 +7.770787819070964, 97.90625643593543 +7.992341489219934, 98.25580597093278 +8.239445065883785, 98.77689968622921 diff --git a/dynamic_model/pump_transient_benchmark/model.ipynb b/dynamic_model/pump_transient_benchmark/model.ipynb new file mode 100644 index 0000000..9f7af70 --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/model.ipynb @@ -0,0 +1,348 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from parameters_U235_pump_transient import *\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from jitcdde import t\n", + "from msrDynamics import Node, System\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "MSRE = System()\n", + "\n", + "# radiator\n", + "T_out_rc = Node(m = mn_rp, scp = mcp_rpn/mn_rp, W = W_rp, y0 = T0_rp)\n", + "T_out_air = Node(m = mn_rs, scp = mcp_rsn/mn_rs, W = W_rs, y0 = T0_rs)\n", + "\n", + "# heat exchanger\n", + "T_hf1 = Node(m = mn_p, scp = mcp_pn/mn_p, W = W_p, y0 = T0_p1)\n", + "T_hf2 = Node(m = mn_p, scp = mcp_pn/mn_p, W = W_p, y0 = T0_p2)\n", + "T_hf3 = Node(m = mn_p, scp = mcp_pn/mn_p, W = W_p, y0 = T0_p3)\n", + "T_hf4 = Node(m = mn_p, scp = mcp_pn/mn_p, W = W_p, y0 = T0_p4)\n", + "T_ht1 = Node(m = m_tn, scp = scp_t, y0 = T0_t1)\n", + "T_ht2 = Node(m = m_tn, scp = scp_t, y0 = T0_t2)\n", + "T_hc1 = Node(m = mn_s, scp = mcp_sn/mn_s, W = W_s, y0 = T0_s1)\n", + "T_hc2 = Node(m = mn_s, scp = mcp_sn/mn_s, W = W_s, y0 = T0_s2)\n", + "T_hc3 = Node(m = mn_s, scp = mcp_sn/mn_s, W = W_s, y0 = T0_s3)\n", + "T_hc4 = Node(m = mn_s, scp = mcp_sn/mn_s, W = W_s, y0 = T0_s4)\n", + "\n", + "# core \n", + "n = Node(y0 = n_frac0)\n", + "C1 = Node(y0 = C0[0])\n", + "C2 = Node(y0 = C0[1])\n", + "C3 = Node(y0 = C0[2])\n", + "C4 = Node(y0 = C0[3])\n", + "C5 = Node(y0 = C0[4])\n", + "C6 = Node(y0 = C0[5])\n", + "rho = Node(y0 = rho_0)\n", + "\n", + "T_cg = Node(m = mcp_g1/scp_g, scp = scp_g, y0 = T0_g1)\n", + "T_cf1 = Node(m = mn_f, scp = scp_f, W = W_f, y0 = T0_f1)\n", + "T_cf2 = Node(m = mn_f, scp = scp_f, W = W_f, y0 = T0_f1)\n", + "\n", + "MSRE.add_nodes([T_out_rc,T_out_air,T_hf1,T_hf2,T_hf3,T_hf4,T_ht1,T_ht2,T_hc1,\n", + " T_hc2,T_hc3,T_hc4,n,C1,C2,C3,C4,C5,C6,T_cg,T_cf1,T_cf2,rho])\n", + "\n", + "\n", + "# dynamics \n", + "\n", + "# radiator\n", + "T_out_rc.set_dTdt_advective(source = T_hc4.y(t-tau_hx_r))\n", + "T_out_rc.set_dTdt_convective(source = [T_out_air.y()], hA = [hA_rpn])\n", + "\n", + "T_out_air.set_dTdt_advective(source = Trs_in)\n", + "T_out_air.set_dTdt_convective(source = [T_out_rc.y()], hA = [hA_rsn])\n", + "\n", + "# heat exchanger\n", + "T_hf1.set_dTdt_advective(source = T_cf2.y(t-tau_c_hx))\n", + "T_hf1.set_dTdt_convective(source = [T_ht1.y()], hA = [hA_pn])\n", + "\n", + "T_hf2.set_dTdt_advective(source = T_hf1.y())\n", + "T_hf2.dTdt_convective = T_hf1.dTdt_convective\n", + "\n", + "T_hf3.set_dTdt_advective(source = T_hf2.y())\n", + "T_hf3.set_dTdt_convective(source = [T_ht2.y()], hA = [hA_pn])\n", + "\n", + "T_hf4.set_dTdt_advective(source = T_hf3.y())\n", + "# T_hf4.set_dTdt_convective(source = [T_ht2.y()], hA = [hA_pn])\n", + "T_hf4.dTdt_convective = T_hf3.dTdt_convective\n", + "\n", + "# T_ht1.set_dTdt_convective(source = [T_hf1.y(),T_hf2.y(),T_hc3.y(),T_hc4.y()], hA = [hA_pn,hA_pn,hA_sn,hA_sn])\n", + "# T_ht2.set_dTdt_convective(source = [T_hf3.y(),T_hf4.y(),T_hc1.y(),T_hc2.y()], hA = [hA_pn,hA_pn,hA_sn,hA_sn])\n", + "T_ht1.set_dTdt_convective(source = [T_hf1.y(),T_hf1.y(),T_hc3.y(),T_hc3.y()], hA = [hA_pn,hA_pn,hA_sn,hA_sn])\n", + "T_ht2.set_dTdt_convective(source = [T_hf3.y(),T_hf3.y(),T_hc1.y(),T_hc1.y()], hA = [hA_pn,hA_pn,hA_sn,hA_sn])\n", + "\n", + "T_hc1.set_dTdt_advective(source = T_out_rc.y(t-tau_r_hx))\n", + "T_hc1.set_dTdt_convective(source = [T_ht2.y()], hA = [hA_sn])\n", + "\n", + "T_hc2.set_dTdt_advective(source = T_hc1.y())\n", + "T_hc2.dTdt_convective = T_hc1.dTdt_convective\n", + "\n", + "T_hc3.set_dTdt_advective(source = T_hc2.y())\n", + "T_hc3.set_dTdt_convective(source = [T_ht1.y()], hA = [hA_sn])\n", + "\n", + "T_hc4.set_dTdt_advective(source = T_hc3.y())\n", + "T_hc4.dTdt_convective = T_hc3.dTdt_convective\n", + "\n", + "# core\n", + "n.set_dndt(r = rho.y(), beta_eff = beta_t, Lambda = Lam, lam = lam, C = [C1.y(),C2.y(),C3.y(),C4.y(),C5.y(),C6.y()])\n", + "C1.set_dcdt(n.y(),beta = beta[0],Lambda = Lam,lam = lam[0],t_c=tau_c,t_l = tau_l, flow = True)\n", + "C2.set_dcdt(n.y(), beta = beta[1],Lambda = Lam,lam = lam[1],t_c=tau_c,t_l = tau_l, flow = True)\n", + "C3.set_dcdt(n.y(),beta = beta[2],Lambda = Lam,lam = lam[2],t_c=tau_c,t_l = tau_l, flow = True)\n", + "C4.set_dcdt(n.y(),beta = beta[3],Lambda = Lam,lam = lam[3],t_c=tau_c,t_l = tau_l, flow = True)\n", + "C5.set_dcdt(n.y(),beta = beta[4],Lambda = Lam,lam = lam[4],t_c=tau_c,t_l = tau_l, flow = True)\n", + "C6.set_dcdt(n.y(),beta = beta[5],Lambda = Lam,lam = lam[5],t_c=tau_c,t_l = tau_l, flow = True)\n", + "\n", + "T_cg.set_dTdt_convective(source = [T_cf1.y()], hA = [hA_fg])\n", + "T_cg.set_dTdt_internal(source = [n.y()], k = [k_g*P])\n", + "\n", + "T_cf1.set_dTdt_advective(source = T_hf4.y(t-tau_hx_c))\n", + "T_cf1.set_dTdt_convective(source = [T_cg.y()], hA = [k_1*hA_fg])\n", + "T_cf1.set_dTdt_internal(source = [n.y()], k = [k_f1*P])\n", + "\n", + "T_cf2.set_dTdt_advective(source = T_cf1.y())\n", + "T_cf2.dTdt_convective = T_cf1.dTdt_convective\n", + "T_cf2.set_dTdt_internal(source = [n.y()], k = [k_f2*P])\n", + "\n", + "rho.set_drdt(sources = [T_cf1.dydt, T_cg.dydt], coeffs = [a_f/2,a_g])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finalizing integrator...\n", + "integrating...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Integration progress: 0%| | 0/500000 [00:00" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(3,1)\n", + "\n", + "axs[0].set_ylim([0,20])\n", + "# axs[0].set_xlim([0,100])\n", + "axs[0].plot(T, P*n.y_out*(1e6), label = 'Power (W)')\n", + "\n", + "# axs[1].set_ylim([600,700])\n", + "# axs[1].set_xlim([0,100])\n", + "axs[1].plot(T, T_hf4.y_out, label = 'Core Fuel Inlet')\n", + "axs[1].plot(T, T_cf2.y_out, label = 'Core Fuel Outlet')\n", + "axs[1].plot(T, T_cg.y_out, label = 'Graphite Temp')\n", + "axs[1].plot(T, T_hf2.y_out, label = 'Hx Fuel Temp')\n", + "axs[1].plot(T, T_hc2.y_out, label = 'Hx Coolant Temp')\n", + "axs[1].legend()\n", + "\n", + "axs[2].plot(T, rho.y_out, label = 'feedback')\n", + "axs[2].legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# fig,axs = plt.subplots(2,3,figsize=(18,12))\n", + "\n", + "# # Set a professional color scheme\n", + "# colors = ['tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:brown']\n", + "\n", + "# # Function to update the style of each axis\n", + "# def update_axis_style(ax, title, x_label='', y_label='', x_ticks=True):\n", + "# ax.set_xlim([t0,tf])\n", + "# ax.set_title(title)\n", + "# ax.set_xlabel(x_label)\n", + "# ax.set_ylabel(y_label)\n", + "# ax.grid(True, which='both', linestyle='--', linewidth=0.5)\n", + "# ax.tick_params(axis='x', which='both', bottom=x_ticks, top=False, labelbottom=x_ticks)\n", + "# ax.tick_params(axis='y', which='both', left=True, right=False, labelleft=True)\n", + "\n", + "# # Applying the updated style to the subplots\n", + "# # Fuel temperatures\n", + "# sol_jit = np.array(sol_jit)\n", + "# update_axis_style(axs[0, 0], \"Fuel Node Temperatures (C)\", y_label=r\"$^\\circ$ C\")\n", + "# axs[0,0].plot(T,[s[20] for s in sol_jit],label=\"core 1\",color=colors[0]) \n", + "# axs[0,0].plot(T,[s[21] for s in sol_jit],label=\"core 2\",color=colors[1]) \n", + "# axs[0,0].plot(T,[s[2] for s in sol_jit],label=\"hx 1\",color=colors[2]) \n", + "# axs[0,0].plot(T,[s[3] for s in sol_jit],label=\"hx 2\",color=colors[3])\n", + "# axs[0,0].plot(T,[s[4] for s in sol_jit],label=\"hx 3\",color=colors[4])\n", + "# axs[0,0].plot(T,[s[5] for s in sol_jit],label=\"hx 4\",color=colors[5]) \n", + "\n", + "# # Coolant temperatures\n", + "# update_axis_style(axs[0, 1], \"Coolant Node Temperatures (C)\", y_label=r\"$^\\circ$ C\")\n", + "# axs[0, 1].plot(T, sol_jit[:, 6], label=f\"hx 1\", color=colors[0])\n", + "# axs[0, 1].plot(T, sol_jit[:, 7], label=f\"hx 1\", color=colors[1])\n", + "# axs[0, 1].plot(T, sol_jit[:, 8], label=f\"hx 1\", color=colors[2])\n", + "# axs[0, 1].plot(T, sol_jit[:, 9], label=f\"hx 1\", color=colors[3])\n", + "# axs[0, 1].plot(T, sol_jit[:, 0], label=f\"r 1\", color=colors[4])\n", + "\n", + "# # Tube node temperatures\n", + "# update_axis_style(axs[0, 2], \"Tube Node Temperatures (C)\", y_label=r\"$^\\circ$ C\")\n", + "# axs[0,2].plot(T,[s[6] for s in sol_jit],label=\"hx 1\",color=colors[0]) \n", + "# axs[0,2].plot(T,[s[7] for s in sol_jit],label=\"hx 2\",color=colors[1]) \n", + "\n", + "# # Precursor concentrations\n", + "# update_axis_style(axs[1, 2], \"Precursor Concentrations\", x_label=\"t (s)\", y_label=r\"concentration (1/cm$^3$)\")\n", + "# for i in range(6):\n", + "# axs[1, 2].plot(T, sol_jit[:, i+13], label=f\"C{i+1}\", color=colors[i])\n", + "# axs[1, 2].set_yscale(\"log\")\n", + "\n", + "# # Multiplication factor temp\n", + "# update_axis_style(axs[1, 0], r\"$n$\", x_label=\"t (s)\", y_label=r\"$\\frac{n}{n_0}$\")\n", + "# axs[1, 0].plot(T, sol_jit[:, 12], label=\"n\", color='tab:blue')\n", + "\n", + "# # Reactivity\n", + "# update_axis_style(axs[1, 1], r\"$\\rho$\", x_label=\"t (s)\")\n", + "# axs[1, 1].plot(T, sol_jit[:, 22], label=\"n\", color='tab:orange')\n", + "\n", + "# # Adding legends\n", + "# for ax in axs.flat:\n", + "# ax.legend()\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "onion_dynamics_py312", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/dynamic_model/pump_transient_benchmark/parameters_U233.py b/dynamic_model/pump_transient_benchmark/parameters_U233.py new file mode 100644 index 0000000..aab95ea --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/parameters_U233.py @@ -0,0 +1,154 @@ +import numpy as np + + + +# domain +t0 = 0.0 +tf = 1000.00 +T = np.arange(t0,tf,0.01) + +# REACTIVITY INSERTION +inserted = 1.39e-4 # 1MW +# inserted = 1.96e-4 # 5MW +# inserted = 2.48e-4 # 8MW + +# NEUTRONICS DATA +tau_l = 16.73 +tau_c = 8.46 +# P = 0.1 +P = 1 +# P = 5 +# P = 8 +n_frac0 = 1 # initial fractional neutron density n/n0 +Lam = 4.0E-04 +lam = np.array([1.260E-02, 3.370E-02, 1.390E-01, 3.250E-01, 1.130E+00, 2.500E+00]) +beta = np.array([0.00023, 0.00079, 0.00067, 0.00073, 0.00013, 0.00009]) +beta_t = np.sum(beta) # total delayed neutron fraction MSRE +rho_0 = beta_t-sum(np.divide(beta,1+np.divide(1-np.exp(-lam*tau_l),lam*tau_c))) # reactivity change in going from stationary to circulating fuel +C0 = beta / Lam * (1.0 / (lam - (np.exp(-lam * tau_l) - 1.0) / tau_c)) + +# Feedback coefficients +a_f = -11.034E-5 +a_g = -05.814E-5 + +# CORE HEAT TRANSFER PARAMETERS +vdot_f = 7.5708E-02 +rho_f = 2.14647E+03 +W_f = 1.623879934566580e+02 +m_f = W_f * tau_c +nn_f = 2 +mn_f = m_f / nn_f +scp_f = 1.9665E-3 + +# Core Upflow +v_g = 1.95386 +rho_g = 1.860E3 +m_g = v_g * rho_g +scp_g = 1.773E-3 +mcp_g1 = m_g * scp_g +mcp_f1 = mn_f * scp_f +mcp_f2 = mn_f * scp_f +hA_fg = 0.02 * 9 / 5 +k_g = 0.07 +k_1 = 0.5 +k_2 = 0.5 +k_f = 0.93 +k_f1 = k_f / nn_f +k_f2 = k_f / nn_f + +# Heat Exchanger +d_he = 16 +h_he = 72 +od_tube = 0.5 +id_tube = od_tube - 2 * 0.042 +n_tube = 159 +a_tube = 254 * 144 +l_tube = a_tube / n_tube / (np.pi * od_tube) +v_tube = n_tube * np.pi * (od_tube / 2) ** 2 * l_tube +v_cool = n_tube * np.pi * (id_tube / 2) ** 2 * l_tube +v_he = (d_he / 2) ** 2 * np.pi * h_he +v_he_fuel = v_he - v_tube +in_m = 1.63871e-5 +W_p = W_f +m_p = v_he_fuel * in_m * rho_f +nn_p = 4 +mn_p = m_p / nn_p +cp_p = scp_f +vdot_s = 5.36265E-02 +rho_s = 1.922e3 +W_s = 1.005793369810108e+02 +m_s = v_cool * in_m * rho_s +nn_s = 4 +mn_s = m_s / nn_s +scp_s = 2.39E-3 +A_phe = 2.359E+01 +ha_p = 6.480E-01 +ha_s = 3.060E-01 +mcp_pn = mn_p * cp_p +hA_pn = ha_p / nn_s +nn_t = 2 +rho_tube = 8.7745E+03 +m_tn = (v_tube - v_cool) * in_m * rho_tube / nn_t +scp_t = 5.778E-04 +mcp_tn = m_tn * scp_t +mcp_sn = mn_s * scp_s +hA_sn = ha_s / nn_s + +# Initial conditions +Tf_in = 6.3222E+02 +T0_f2 = 6.5727E+02 +T0_f1 = Tf_in + (T0_f2 - Tf_in) / 2 +T0_g1 = T0_f1 + (k_g * P / hA_fg) +Tp_in = T0_f2 +T0_p4 = Tf_in +T0_p1 = Tp_in - (Tp_in - T0_p4) / 4 +T0_p2 = Tp_in - 2 * (Tp_in - T0_p4) / 4 +T0_p3 = Tp_in - 3 * (Tp_in - T0_p4) / 4 +Ts_in = 5.4611E+02 +T0_s4 = 5.7939E+02 +T0_s1 = Ts_in + (T0_s4 - Ts_in) / nn_s +T0_s2 = Ts_in + 2 * (T0_s4 - Ts_in) / nn_s +T0_s3 = Ts_in + 3 * (T0_s4 - Ts_in) / nn_s +T0_t1 = (T0_p1 * hA_pn + T0_s3 * hA_sn) / (hA_pn + hA_sn) +T0_t2 = (T0_p3 * hA_pn + T0_s1 * hA_sn) / (hA_pn + hA_sn) + +# Radiator Parameters +Trp_in = T0_s4 +T0_rp = Ts_in +Trs_in = 37.78 +T0_rs = 148.9 +od_rad = 0.01905 +tube_wall_thick = 0.0018288 +id_rad = od_rad - 2 * tube_wall_thick +n_rtubes = 120 +l_rtube = 9.144 +v_rp = np.pi * (id_rad / 2) ** 2 * l_rtube * n_rtubes +n_tpr = 12 +n_row = 10 +tube_space = 0.0381 +v_rs = (n_row * od_rad + (n_row - 1) * tube_space) * (n_tpr * od_rad + (n_tpr - 1) * tube_space) * l_rtube +W_rp = W_s +m_rp = v_rp * rho_s +nn_rp = 1 +mn_rp = m_rp / nn_rp +cp_rp = scp_s +vdot_rs = 94.389 +rho_rs = 1.1237 +W_rs = vdot_rs * rho_rs +m_rs = v_rs * rho_rs +nn_rs = 1 +mn_rs = m_rs / nn_rs +scp_rs = 1.0085E-3 +A_rad = 6.503E1 +h_roverall = P / A_rad / ((T0_rp + Trp_in) / 2 - (T0_rs + Trs_in) / 2) +mcp_rpn = mn_rp * cp_rp +hA_rpn = h_roverall * A_rad / nn_rs +mcp_rsn = mn_rs * scp_rs +hA_rsn = h_roverall * A_rad / nn_rs + +# Pure time delays between components +tau_hx_c = 8.67 #+2.145 +tau_c_hx = 3.77 #+2.145 +tau_hx_r = 4.71 +tau_r_hx = 8.24 + diff --git a/dynamic_model/pump_transient_benchmark/parameters_U235.py b/dynamic_model/pump_transient_benchmark/parameters_U235.py new file mode 100644 index 0000000..95e6c15 --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/parameters_U235.py @@ -0,0 +1,202 @@ +import numpy as np +import math +pi = math.pi + +# domain +t0 = 0.0 +tf = 50000.00 +T = np.arange(t0,tf,1.0) + +# NEUTRONICS DATA +tau_l = 16.73 # ORNL-TM-0728 %16.44; % (s) +tau_c = 8.46 # ORNL-TM-0728 %8.460; % (s) +# P = 8.0 # Thermal Power in MW ORNL-TM-1070, p.2 +P = 1.0e-5 +n_frac0 = 1.0 # initial fractional neutron density n/n0 (n/cm^3/s) +Lam = 2.400E-04 # mean generation time ORNL-TM-1070 p.15 U235 +# Lam = 4.0E-04; # mean generation time ORNL-TM-1070 p.15 U233 +lam = np.array([1.240E-02, 3.05E-02, 1.11E-01, 3.01E-01, 1.140E+00, 3.014E+00]) +beta = np.array([0.000223, 0.001457, 0.001307, 0.002628, 0.000766, 0.00023]) # U235 +# beta = np.array([0.00023, 0.00079, 0.00067, 0.00073, 0.00013, 0.00009]) # U233 +beta_t = np.sum(beta) # total delayed neutron fraction MSRE +rho_0 = beta_t-sum(np.divide(beta,1+np.divide(1-np.exp(-lam*tau_l),lam*tau_c))) # reactivity change in going from stationary to circulating fuel +C0 = beta / Lam * (1.0 / (lam - (np.exp(-lam * tau_l) - 1.0) / tau_c)) + +# Feedback co-efficients +a_f = -8.71E-05 # U235 (drho/°C) fuel salt temperature-reactivity feedback coefficient ORNL-TM-1647 p.3 % -5.904E-05; % ORNL-TM-0728 p. 101 % +a_g = -6.66E-05 # U235 (drho/°C) graphite temperature-reactivity feedback coefficient ORNL-TM-1647 p.3 % -6.624E-05; % ORNL-TM-0728 p.101 + +# CORE HEAT TRANSFER PARAMETERS +# FUEL PARAMETERS - DONE +vdot_f = 7.5708E-02 # ORNL-TM-0728 % 7.571e-2; % vol. flow rate (m^3/s) ORNL-TM-1647 p.3, ORNL-TM-0728 p.12 +rho_f = 2.14647E+03 # (partially enriched U-235)ORNL-TM-0728 p.8 2.243E+03; % (Th-U) density of fuel salt (kg/m^3) ORNL-TM-0728 p.8 +W_f = 1.623879934566580e+02 # 1.83085e+02;%vdot_f*rho_f; % 182.78; % calcd from m_dot*cp*delT=P; vdot_f*rho_f; % fuel flow rate (kg/s) +# tau_f_c = tau_c; % ORNL-TM-0728 % 8.45; % transit time of fuel in core (s) ORNL-TM-1070 p.15, TDAMSRE p.5 +m_f = W_f * tau_c # fuel mass in core (kg) +nn_f = 2 # number of fuel nodes in core model +mn_f = m_f / nn_f # fuel mass per node (kg) +# cp_f = 4.2*9/5; % (MJ/deg-C) total fuel heat capacity TDAMSRE p.5 +scp_f = 1.9665E-3 # specific heat capacity of fuel salt (MJ/kg-C) ORNL-TM-0728 p.8 + +# Core Upflow - DONE +v_g = 1.95386 # graphite volume(m^3) ORNL-TM-0728 p. 101 +rho_g = 1.860E3 # graphite density (kg/m^3) ORNL-3812 p.77, ORNL-TM-0728 p.87 +m_g = v_g * rho_g # graphite mass (kg) +cp_g = 3.6 * 9 / 5 # TDAMSRE p.5 graphite total heat capacity (MW-s/C) ORNL-TM-1647 p.3 +scp_g = 1.773E-3 # cp_g/m_g; % graphite specific heat capacity (MW-s/kg-C) ORNL-TM-1647 p.3 +mcp_g1 = m_g * scp_g # (mass of material x heat capacity of material) of graphite per lump (MW-s/°C) +mcp_f1 = mn_f * scp_f # (mass of material x heat capacity of material) of fuel salt per lump (MW-s/°C) +mcp_f2 = mn_f * scp_f # (mass of material x heat capacity of material) of fuel salt per lump (MW-s/°C) +hA_fg = 0.02 * 9 / 5 # (fuel to graphite heat transfer coeff x heat transfer area) (MW/°C) ORNL-TM-1647 p.3, TDAMSRE p.5 +k_g = 0.07 # fraction of total power generated in the graphite ORNL-TM-0728 p.9 +k_1 = 0.5 # fraction of heat transferred from graphite which goes to the first fuel lump +k_2 = 0.5 # fraction of heat transferred from graphite which goes to the second fuel lump +k_f = 0.93 # fraction of heat generated in fuel - that generated in the external loop ORNL-TM-0728 p.9 +k_f1 = k_f / nn_f # fraction of total power generated in lump f1 +k_f2 = k_f / nn_f # fraction of total power generated in lump f2 + +# New node for power deposited in fuel outside the core +k_out = 1 - (k_g + k_f) # fraction of power generated in fuel in external loop ORNL-TM-0728 p.9 +m_out = W_f # (kg) Mass of node such that resident time is 1 sec (W_f needs to be defined) + +# Initial conditions - DONE +Tf_in = 6.3222E+02 # in °C ORNL-TM-1647 p.2 +T0_f2 = 6.5727E+02 # 6.5444E+02; % in °C 6.461904761904777e+02; ORNL-TM-1647 p.2 +T0_f1 = Tf_in + (T0_f2 - Tf_in) / 2 # 6.405952380952389e+02; in °C +T0_g1 = T0_f1 + (k_g * P / hA_fg) # 6.589285714285924e+02; in °C +# T0_out = k_out * P / m_out / scp_f + T0_f2 # in °C (scp_f needs to be defined) + + +# Heat Exchanger - DONE +# Geometry +d_he = 16 # (in) he diameter ORNL-TM-0728 p. 164 +h_he = 72 # (in) active height % 96; %(in) he height ORNL-TM-0728 p. 164 +od_tube = 0.5 # (in) coolant tube OD ORNL-TM-0728 p. 164 +id_tube = od_tube - 2 * 0.042 # (in) coolant tube ID ORNL-TM-0728 p. 164 +n_tube = 159 # number of coolant tubes ORNL-TM-0728 p. 164 +a_tube = 254 * 144 # (in^2) total area of tubes ORNL-TM-0728 p. 164 +l_tube = a_tube / n_tube / (np.pi * od_tube) # (in) tube length +v_tube = n_tube * np.pi * (od_tube / 2) ** 2 * l_tube # (in^3) hx shell volume occupied by tubes +v_cool = n_tube * np.pi * (id_tube / 2) ** 2 * l_tube # (in^3) hx volume occupied by coolant +v_he = (d_he / 2) ** 2 * np.pi * h_he # (in^3) volume of heat exchanger shell +v_he_fuel = v_he - v_tube # (in^3) volume available to fuel in shell + +# Unit conversions +in_m = 1.63871e-5 # 1 cubic inch = 1.63871e-5 cubic meters + +# PRIMARY FLOW PARAMETERS - DONE +W_p = W_f # fuel flow rate (kg/s) + +m_p = v_he_fuel * in_m * rho_f # fuel mass in PHE (kg) +nn_p = 4 # number of fuel nodes in PHE +mn_p = m_p / nn_p # fuel mass per node (kg) +cp_p = scp_f # fuel heat capacity (MJ/(kg-C)) + +# SECONDARY FLOW PARAMETERS - DONE +vdot_s = 5.36265E-02 # ORNL-TM-0728 p. 164 % 5.236E-02; % coolant volume flow rate (m^3/s) ORNL-TM-1647 p.3 +rho_s = 1.922e3 # coolant salt density (kg/m^3) ORNL-TM-0728 p.8 +W_s = 1.005793369810108e+02 # vdot_s*rho_s; % calcd from mdot*cp*delT; vdot_s*rho_s; % coolant flow rate (kg/s) ORNL-TM-1647 p.3 + +m_s = v_cool * in_m * rho_s # coolant mass in PHE (kg) +nn_s = 4 # number of coolant nodes in PHE +mn_s = m_s / nn_s # coolant mass per node (kg) +scp_s = 2.39E-3 # cp_s/m_s; % specific heat capacity of coolant (MJ/(kg-C) ORNL-TM-0728 p.8 + +A_phe = 2.359E+01 # effective area for heat transfer (primary and secondary, m^2) ORNL-TM-0728 p.164 + +ha_p = 6.480E-01 # heat transfer*area coefficient from primary to tubes (MW/C) ORNL-TM-1647 p.3 +ha_s = 3.060E-01 # heat transfer*area coefficient from tubes to secondary (MW/C) ORNL-TM-1647 p.3 + +# Primary Side +mcp_pn = mn_p * cp_p # (mass of material x heat capacity of material) of fuel salt per lump in MW-s/°C +hA_pn = ha_p / nn_s # 3.030; % (primary to tube heat transfer coeff x heat transfer area) in MW/°C + +# Tubes - DONE +nn_t = 2 # number of nodes of tubes in the model +rho_tube = 8.7745E+03 # (kg/m^3) density of INOR-8 ORNL-TM-0728 p.20 +m_tn = (v_tube - v_cool) * in_m * rho_tube / nn_t # mass of tubes (kg) +scp_t = 5.778E-04 # specific heat capacity of tubes (MJ/(kg-C)) ORNL-TM-0728 p.20 +mcp_tn = m_tn * scp_t # mass*(heat capacity) of tubes per lump in MW-s/°C + +# Secondary Side - DONE +mcp_sn = mn_s * scp_s # (mass of material x heat capacity of material) of coolant salt per lump in MW-s/°C +hA_sn = ha_s / nn_s # (tube to secondary heat transfer coeff x heat transfer area) in MW/°C + +# Initial conditions - DONE +# Primary nodes +Tp_in = T0_f2 # in °C ORNL-TM-1647 p.2 +T0_p4 = Tf_in # 6.5444E+02; % in °C 6.461904761904777e+02; ORNL-TM-1647 p.2 +T0_p1 = Tp_in + (T0_p4 - Tp_in) / 4 # in °C +T0_p2 = Tp_in + 2 * (T0_p4 - Tp_in) / 4 # in °C +T0_p3 = Tp_in + 3 * (T0_p4 - Tp_in) / 4 # in °C + +# Secondary nodes +Ts_in = 5.4611E+02 # in °C ORNL-TM-1647 p.2 +T0_s4 = 5.7939E+02 # in °C ORNL-TM-1647 p.2 +T0_s1 = Ts_in + (T0_s4 - Ts_in) / nn_s # in °C +T0_s2 = Ts_in + 2 * (T0_s4 - Ts_in) / nn_s # in °C +T0_s3 = Ts_in + 3 * (T0_s4 - Ts_in) / nn_s # in °C +# Tube nodes +T0_t1 = (T0_p1 * hA_pn + T0_s3 * hA_sn) / (hA_pn + hA_sn) # in °C +T0_t2 = (T0_p3 * hA_pn + T0_s1 * hA_sn) / (hA_pn + hA_sn) # in °C + +# Radiator Parameters - DONE + +# Initial conditions - DONE +# Primary nodes +Trp_in = T0_s4 # 5.933E+02; % in °C ORNL-TM-1647 p.2 +T0_rp = Ts_in # in °C ORNL-TM-1647 p.2 + +# Secondary nodes - DONE +Trs_in = 37.78 # (C) air inlet temperature ORNL-TM-1647 p.2 +T0_rs = 148.9 # (C) air exit temperature ORNL-TM-1647 p.2 + +# Radiator Geometry +od_rad = 0.01905 # (m) outer diameter of tubes in the radiator ORNL-TM-0728 p.296 +tube_wall_thick = 0.0018288 # (m) thickness of tubes in the radiator ORNL-TM-0728 p.296 +id_rad = od_rad - 2 * tube_wall_thick +n_rtubes = 120 # number of tubes in the radiator (rows times tubes per row) ORNL-TM-0728 p.296 +l_rtube = 9.144 # (m) length of tubes in the radiator ORNL-TM-0728 p.296 +v_rp = pi * (id_rad / 2) ** 2 * l_rtube * n_rtubes # volume available to salt in the radiator +# v_rtube = pi * (od_rad / 2) ** 2 * l_rtube * n_rtubes - v_rp # volume of metal in radiator tubes *TUBES NOT MODELED + +n_tpr = 12 # number of tubes per row in the radiator matrix +n_row = 10 # number rows in the radiator matrix +tube_space = 0.0381 # (m) spacing between tubes and rows of matrix +v_rs = (n_row * od_rad + (n_row - 1) * tube_space) * (n_tpr * od_rad + (n_tpr - 1) * tube_space) * l_rtube # volume of air inside radiator + +# PRIMARY FLOW PARAMETERS - DONE +W_rp = W_s # coolant salt flow rate (kg/s) +m_rp = v_rp * rho_s # coolant salt mass in rad (kg) +nn_rp = 1 # number of coolant salt nodes in the radiator +mn_rp = m_rp / nn_rp # coolant mass per node (kg) +cp_rp = scp_s # coolant specific heat capacity (MJ/(kg-C)) + +# SECONDARY FLOW PARAMETERS - DONE +vdot_rs = 94.389 # ORNL-TM-0728 p. 296; 78.82; % air volume flow rate (m^3/s) ORNL-TM-1647 p.2 +rho_rs = 1.1237 # air density (kg/m^3) REFPROP (310K and 0.1MPa) +W_rs = vdot_rs * rho_rs # air flow rate (kg/s) + +m_rs = v_rs * rho_rs # coolant air mass in rad (kg) +nn_rs = 1 # number of coolant nodes in rad +mn_rs = m_rs / nn_rs # coolant mass per node (kg) +scp_rs = 1.0085E-3 # (MJ/kg-C) specific heat capacity of air at (air_out+air_in)/2 REFPROP + +A_rad = 6.503E1 # (m^2) surface area of the radiator ORNL-TM-0728 p.14 +h_roverall = P / A_rad / ((T0_rp + Trp_in) / 2 - (T0_rs + Trs_in) / 2) # cald as: P/A_rad/((T0_rp+Trp_in)/2-(T0_rs+Trs_in)/2) 3.168E-4; % (MW/m^2-C) polimi thesis + +# Primary Side +mcp_rpn = mn_rp * cp_rp # (mass of material x heat capacity of material) of fuel salt per lump in MW-s/°C +hA_rpn = h_roverall * A_rad / nn_rs # 3.030; % (primary to secondary heat transfer coeff x heat transfer area) in MW/°C + +# Secondary Side - DONE +mcp_rsn = mn_rs * scp_rs # (mass of material x heat capacity of material) of coolant salt per lump in MW-s/°C +hA_rsn = h_roverall * A_rad / nn_rs # (tube to secondary heat transfer coeff x heat transfer area) in MW/°C + +# Pure time delays between components - DONE +tau_hx_c = 8.67 # (sec) delay from hx to core TDAMSRE p.6 +tau_c_hx = 3.77 # (sec) subtracted 1 sec for external loop power generation node resident time; delay from core to fuel hx TDAMSRE p.6 +tau_hx_r = 4.71 # (sec) fertile hx to core TDAMSRE p.6 +tau_r_hx = 8.24 # (sec) core to fertile hx TDAMSRE p.6 + +first_val = (rho_0 - beta_t) * n_frac0 / Lam + lam[0] * C0[0] + lam[1] * C0[1] + lam[2] * C0[2] + lam[3] * C0[3] + lam[4] * C0[4] + lam[5] * C0[5] \ No newline at end of file diff --git a/dynamic_model/pump_transient_benchmark/parameters_U235_pump_transient.py b/dynamic_model/pump_transient_benchmark/parameters_U235_pump_transient.py new file mode 100644 index 0000000..0dc743f --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/parameters_U235_pump_transient.py @@ -0,0 +1,217 @@ +import numpy as np +import math +pi = math.pi + +# domain +t0 = 0.0 +tf = 10000.00 +T = np.arange(t0,tf,0.01) + +# NEUTRONICS DATA +tau_l = 16.73 # ORNL-TM-0728 %16.44; % (s) +tau_c = 8.46 # ORNL-TM-0728 %8.460; % (s) +# P = 8.0 # Thermal Power in MW ORNL-TM-1070, p.2 +P = 1.0e-5 # 10 W +n_frac0 = 1.0 # initial fractional neutron density n/n0 (n/cm^3/s) +Lam = 2.400E-04 # mean generation time ORNL-TM-1070 p.15 U235 +# Lam = 4.0E-04; # mean generation time ORNL-TM-1070 p.15 U233 +lam = np.array([1.240E-02, 3.05E-02, 1.11E-01, 3.01E-01, 1.140E+00, 3.014E+00]) +beta = np.array([0.000223, 0.001457, 0.001307, 0.002628, 0.000766, 0.00023]) # U235 +# beta = np.array([0.00023, 0.00079, 0.00067, 0.00073, 0.00013, 0.00009]) # U233 +beta_t = np.sum(beta) # total delayed neutron fraction MSRE +rho_0 = beta_t-sum(np.divide(beta,1+np.divide(1-np.exp(-lam*tau_l),lam*tau_c))) # reactivity change in going from stationary to circulating fuel +C0 = beta / Lam * (1.0 / (lam - (np.exp(-lam * tau_l) - 1.0) / tau_c)) + +# Feedback co-efficients +# a_f = -8.71E-05 # U235 (drho/°C) fuel salt temperature-reactivity feedback coefficient ORNL-TM-1647 p.3 % -5.904E-05; % ORNL-TM-0728 p. 101 % +# a_g = -6.66E-05 # U235 (drho/°C) graphite temperature-reactivity feedback coefficient ORNL-TM-1647 p.3 % -6.624E-05; % ORNL-TM-0728 p.101 + +# low power coefficients +a_f = (-4.1e-5)*5/9 +a_g = (-4.0e-5)*5/9 + +# CORE HEAT TRANSFER PARAMETERS +# FUEL PARAMETERS - DONE +vdot_f = 7.5708E-02 # ORNL-TM-0728 % 7.571e-2; % vol. flow rate (m^3/s) ORNL-TM-1647 p.3, ORNL-TM-0728 p.12 +rho_f = 2.14647E+03 # (partially enriched U-235)ORNL-TM-0728 p.8 2.243E+03; % (Th-U) density of fuel salt (kg/m^3) ORNL-TM-0728 p.8 + +# W_f = 1.623879934566580e+02 # 1.83085e+02;%vdot_f*rho_f; % 182.78; % calcd from m_dot*cp*delT=P; vdot_f*rho_f; % fuel flow rate (kg/s) + +W_f = 1200*(1/264.172)*(1/60)*(rho_f) # gpm -> kg/s + +# tau_f_c = tau_c; % ORNL-TM-0728 % 8.45; % transit time of fuel in core (s) ORNL-TM-1070 p.15, TDAMSRE p.5 +m_f = W_f * tau_c # fuel mass in core (kg) +nn_f = 2 # number of fuel nodes in core model +mn_f = m_f / nn_f # fuel mass per node (kg) +# cp_f = 4.2*9/5; % (MJ/deg-C) total fuel heat capacity TDAMSRE p.5 +scp_f = 1.9665E-3 # specific heat capacity of fuel salt (MJ/kg-C) ORNL-TM-0728 p.8 + +# Core Upflow - DONE +v_g = 1.95386 # graphite volume(m^3) ORNL-TM-0728 p. 101 +rho_g = 1.860E3 # graphite density (kg/m^3) ORNL-3812 p.77, ORNL-TM-0728 p.87 +m_g = v_g * rho_g # graphite mass (kg) +cp_g = 3.6 * 9 / 5 # TDAMSRE p.5 graphite total heat capacity (MW-s/C) ORNL-TM-1647 p.3 +scp_g = 1.773E-3 # cp_g/m_g; % graphite specific heat capacity (MW-s/kg-C) ORNL-TM-1647 p.3 +mcp_g1 = m_g * scp_g # (mass of material x heat capacity of material) of graphite per lump (MW-s/°C) +mcp_f1 = mn_f * scp_f # (mass of material x heat capacity of material) of fuel salt per lump (MW-s/°C) +mcp_f2 = mn_f * scp_f # (mass of material x heat capacity of material) of fuel salt per lump (MW-s/°C) +hA_fg = 0.02 * 9 / 5 # (fuel to graphite heat transfer coeff x heat transfer area) (MW/°C) ORNL-TM-1647 p.3, TDAMSRE p.5 +k_g = 0.07 # fraction of total power generated in the graphite ORNL-TM-0728 p.9 +k_1 = 0.5 # fraction of heat transferred from graphite which goes to the first fuel lump +k_2 = 0.5 # fraction of heat transferred from graphite which goes to the second fuel lump +k_f = 0.93 # fraction of heat generated in fuel - that generated in the external loop ORNL-TM-0728 p.9 +k_f1 = k_f / nn_f # fraction of total power generated in lump f1 +k_f2 = k_f / nn_f # fraction of total power generated in lump f2 + +# New node for power deposited in fuel outside the core +k_out = 1 - (k_g + k_f) # fraction of power generated in fuel in external loop ORNL-TM-0728 p.9 +m_out = W_f # (kg) Mass of node such that resident time is 1 sec (W_f needs to be defined) + +# Initial conditions - DONE +Tf_in = 648.85 # in °C ORNL-TM-1647 p.2 +T0_f2 = 648.85 # 6.5444E+02; % in °C 6.461904761904777e+02; ORNL-TM-1647 p.2 +T0_f1 = Tf_in + (T0_f2 - Tf_in) / 2 # 6.405952380952389e+02; in °C +T0_g1 = T0_f1 + (k_g * P / hA_fg) # 6.589285714285924e+02; in °C +# T0_out = k_out * P / m_out / scp_f + T0_f2 # in °C (scp_f needs to be defined) + + +# Heat Exchanger - DONE +# Geometry +d_he = 16 # (in) he diameter ORNL-TM-0728 p. 164 +h_he = 72 # (in) active height % 96; %(in) he height ORNL-TM-0728 p. 164 +od_tube = 0.5 # (in) coolant tube OD ORNL-TM-0728 p. 164 +id_tube = od_tube - 2 * 0.042 # (in) coolant tube ID ORNL-TM-0728 p. 164 +n_tube = 159 # number of coolant tubes ORNL-TM-0728 p. 164 +a_tube = 254 * 144 # (in^2) total area of tubes ORNL-TM-0728 p. 164 +l_tube = a_tube / n_tube / (np.pi * od_tube) # (in) tube length +v_tube = n_tube * np.pi * (od_tube / 2) ** 2 * l_tube # (in^3) hx shell volume occupied by tubes +v_cool = n_tube * np.pi * (id_tube / 2) ** 2 * l_tube # (in^3) hx volume occupied by coolant +v_he = (d_he / 2) ** 2 * np.pi * h_he # (in^3) volume of heat exchanger shell +v_he_fuel = v_he - v_tube # (in^3) volume available to fuel in shell + +# Unit conversions +in_m = 1.63871e-5 # 1 cubic inch = 1.63871e-5 cubic meters + +# PRIMARY FLOW PARAMETERS - DONE +W_p = W_f # fuel flow rate (kg/s) + +m_p = v_he_fuel * in_m * rho_f # fuel mass in PHE (kg) +nn_p = 4 # number of fuel nodes in PHE +mn_p = m_p / nn_p # fuel mass per node (kg) +cp_p = scp_f # fuel heat capacity (MJ/(kg-C)) + +# SECONDARY FLOW PARAMETERS - DONE +vdot_s = 5.36265E-02 # ORNL-TM-0728 p. 164 % 5.236E-02; % coolant volume flow rate (m^3/s) ORNL-TM-1647 p.3 +rho_s = 1.922e3 # coolant salt density (kg/m^3) ORNL-TM-0728 p.8 +W_s = 1.005793369810108e+02 # vdot_s*rho_s; % calcd from mdot*cp*delT; vdot_s*rho_s; % coolant flow rate (kg/s) ORNL-TM-1647 p.3 + +m_s = v_cool * in_m * rho_s # coolant mass in PHE (kg) +nn_s = 4 # number of coolant nodes in PHE +mn_s = m_s / nn_s # coolant mass per node (kg) +scp_s = 2.39E-3 # cp_s/m_s; % specific heat capacity of coolant (MJ/(kg-C) ORNL-TM-0728 p.8 + +A_phe = 2.359E+01 # effective area for heat transfer (primary and secondary, m^2) ORNL-TM-0728 p.164 + +ha_p = 6.480E-01 # heat transfer*area coefficient from primary to tubes (MW/C) ORNL-TM-1647 p.3 +ha_s = 3.060E-01 # heat transfer*area coefficient from tubes to secondary (MW/C) ORNL-TM-1647 p.3 + +# Primary Side +mcp_pn = mn_p * cp_p # (mass of material x heat capacity of material) of fuel salt per lump in MW-s/°C +hA_pn = ha_p / nn_s # 3.030; % (primary to tube heat transfer coeff x heat transfer area) in MW/°C + +# Tubes - DONE +nn_t = 2 # number of nodes of tubes in the model +rho_tube = 8.7745E+03 # (kg/m^3) density of INOR-8 ORNL-TM-0728 p.20 +m_tn = (v_tube - v_cool) * in_m * rho_tube / nn_t # mass of tubes (kg) +scp_t = 5.778E-04 # specific heat capacity of tubes (MJ/(kg-C)) ORNL-TM-0728 p.20 +mcp_tn = m_tn * scp_t # mass*(heat capacity) of tubes per lump in MW-s/°C + +# Secondary Side - DONE +mcp_sn = mn_s * scp_s # (mass of material x heat capacity of material) of coolant salt per lump in MW-s/°C +hA_sn = ha_s / nn_s # (tube to secondary heat transfer coeff x heat transfer area) in MW/°C + +# Initial conditions - DONE +# Primary nodes +Tp_in = T0_f2 # in °C ORNL-TM-1647 p.2 +T0_p4 = Tf_in # 6.5444E+02; % in °C 6.461904761904777e+02; ORNL-TM-1647 p.2 +T0_p1 = Tp_in + (T0_p4 - Tp_in) / 4 # in °C +T0_p2 = Tp_in + 2 * (T0_p4 - Tp_in) / 4 # in °C +T0_p3 = Tp_in + 3 * (T0_p4 - Tp_in) / 4 # in °C + +# Secondary nodes +hx_f_temp = 648.85-(3e-4) +Ts_in = hx_f_temp # in °C ORNL-TM-1647 p.2 +T0_s4 = hx_f_temp # in °C ORNL-TM-1647 p.2 +T0_s1 = Ts_in + (T0_s4 - Ts_in) / nn_s # in °C +T0_s2 = Ts_in + 2 * (T0_s4 - Ts_in) / nn_s # in °C +T0_s3 = Ts_in + 3 * (T0_s4 - Ts_in) / nn_s # in °C +# Tube nodes +T0_t1 = (T0_p1 * hA_pn + T0_s3 * hA_sn) / (hA_pn + hA_sn) # in °C +T0_t2 = (T0_p3 * hA_pn + T0_s1 * hA_sn) / (hA_pn + hA_sn) # in °C + +# Radiator Parameters - DONE + +# Initial conditions - DONE +# Primary nodes +Trp_in = T0_s4 # 5.933E+02; % in °C ORNL-TM-1647 p.2 +T0_rp = Ts_in # in °C ORNL-TM-1647 p.2 + +# Secondary nodes - DONE +Trs_in = 37.78 # (C) air inlet temperature ORNL-TM-1647 p.2 +T0_rs = 148.9 # (C) air exit temperature ORNL-TM-1647 p.2 + +# Radiator Geometry +od_rad = 0.01905 # (m) outer diameter of tubes in the radiator ORNL-TM-0728 p.296 +tube_wall_thick = 0.0018288 # (m) thickness of tubes in the radiator ORNL-TM-0728 p.296 +id_rad = od_rad - 2 * tube_wall_thick +n_rtubes = 120 # number of tubes in the radiator (rows times tubes per row) ORNL-TM-0728 p.296 +l_rtube = 9.144 # (m) length of tubes in the radiator ORNL-TM-0728 p.296 +v_rp = pi * (id_rad / 2) ** 2 * l_rtube * n_rtubes # volume available to salt in the radiator +# v_rtube = pi * (od_rad / 2) ** 2 * l_rtube * n_rtubes - v_rp # volume of metal in radiator tubes *TUBES NOT MODELED + +n_tpr = 12 # number of tubes per row in the radiator matrix +n_row = 10 # number rows in the radiator matrix +tube_space = 0.0381 # (m) spacing between tubes and rows of matrix +v_rs = (n_row * od_rad + (n_row - 1) * tube_space) * (n_tpr * od_rad + (n_tpr - 1) * tube_space) * l_rtube # volume of air inside radiator + +# PRIMARY FLOW PARAMETERS - DONE +W_rp = W_s # coolant salt flow rate (kg/s) +m_rp = v_rp * rho_s # coolant salt mass in rad (kg) +nn_rp = 1 # number of coolant salt nodes in the radiator +mn_rp = m_rp / nn_rp # coolant mass per node (kg) +cp_rp = scp_s # coolant specific heat capacity (MJ/(kg-C)) + +# SECONDARY FLOW PARAMETERS - DONE +# assume only convection airflow +# vdot_rs = 94.389 # ORNL-TM-0728 p. 296; 78.82; % air volume flow rate (m^3/s) ORNL-TM-1647 p.2 +vdot_rs = 1.0 +rho_rs = 1.1237 # air density (kg/m^3) REFPROP (310K and 0.1MPa) +W_rs = vdot_rs * rho_rs # air flow rate (kg/s) + + + +m_rs = v_rs * rho_rs # coolant air mass in rad (kg) +nn_rs = 1 # number of coolant nodes in rad +mn_rs = m_rs / nn_rs # coolant mass per node (kg) +scp_rs = 1.0085E-3 # (MJ/kg-C) specific heat capacity of air at (air_out+air_in)/2 REFPROP + +A_rad = 6.503E1 # (m^2) surface area of the radiator ORNL-TM-0728 p.14 +h_roverall = P / A_rad / ((T0_rp + Trp_in) / 2 - (T0_rs + Trs_in) / 2) # cald as: P/A_rad/((T0_rp+Trp_in)/2-(T0_rs+Trs_in)/2) 3.168E-4; % (MW/m^2-C) polimi thesis +# h_roverall = 3.0 + +# Primary Side +mcp_rpn = mn_rp * cp_rp # (mass of material x heat capacity of material) of fuel salt per lump in MW-s/°C +hA_rpn = h_roverall * A_rad / nn_rs # 3.030; % (primary to secondary heat transfer coeff x heat transfer area) in MW/°C + +# Secondary Side - DONE +mcp_rsn = mn_rs * scp_rs # (mass of material x heat capacity of material) of coolant salt per lump in MW-s/°C +hA_rsn = h_roverall * A_rad / nn_rs # (tube to secondary heat transfer coeff x heat transfer area) in MW/°C + +# Pure time delays between components - DONE +tau_hx_c = 8.67 # (sec) delay from hx to core TDAMSRE p.6 +tau_c_hx = 3.77 # (sec) subtracted 1 sec for external loop power generation node resident time; delay from core to fuel hx TDAMSRE p.6 +tau_hx_r = 4.71 # (sec) fertile hx to core TDAMSRE p.6 +tau_r_hx = 8.24 # (sec) core to fertile hx TDAMSRE p.6 + +first_val = (rho_0 - beta_t) * n_frac0 / Lam + lam[0] * C0[0] + lam[1] * C0[1] + lam[2] * C0[2] + lam[3] * C0[3] + lam[4] * C0[4] + lam[5] * C0[5] + diff --git a/dynamic_model/pump_transient_benchmark/pump_transients.ipynb b/dynamic_model/pump_transient_benchmark/pump_transients.ipynb new file mode 100644 index 0000000..2eacef8 --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/pump_transients.ipynb @@ -0,0 +1,315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from parameters_U235_pump_transient import *\n", + "from jitcdde import t\n", + "from msrDynamics import Node, System\n", + "import pandas as pd\n", + "import os\n", + "from scipy.interpolate import interp1d\n", + "import sympy as sp" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook simulates pump transients for the MSRE at zero power (10W). The system is run at steady-state until $t = 2500$, where the fuel and coolant pumps are spun down at the rate defined by the ORNL data. The model includes a reactivity response, $\\texttt{rho_control}$, which models the response of the MSRE control rod to maintain constant power. It is modeled as a pure integrator of $\\frac{dn}{dt}$ from the point-kinetics equations with a coefficient of -1.0, i.e. it tries to exactly cancel reactivity changes introduced by flow changes. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# plotting style \n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams[\"font.family\"] = \"monospace\"\n", + "\n", + "colors = ['tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:brown']\n", + "\n", + "# function to update the style of each axis\n", + "def update_axis_style(ax, title = None, x_label='', y_label='', x_ticks=True,fsl = 12, fsb = 12, fst = 14):\n", + " if title:\n", + " ax.set_title(title,fontsize=fst)\n", + " ax.set_xlabel(x_label,fontsize=fsb)\n", + " ax.set_ylabel(y_label,fontsize=fsl)\n", + " ax.grid(True, which='both', linestyle='--', linewidth=0.5)\n", + " ax.tick_params(axis='x', which='both', bottom=x_ticks, top=False, labelbottom=x_ticks)\n", + " ax.tick_params(axis='y', which='both', left=True, right=False, labelleft=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set up system \n", + "\n", + "MSRE = System()\n", + "\n", + "# define flow events\n", + "df_spindown = pd.read_csv(os.getcwd() + '/data/spindown.csv', names = ['time', 'pct'], header = None)\n", + "df_spinup = pd.read_csv(os.getcwd() + '/data/spinup.csv', names = ['time', 'pct'], header = None)\n", + "spindown_fit = interp1d(df_spindown['time'], df_spindown['pct'])\n", + "spinup_fit = interp1d(df_spinup['time'], df_spinup['pct'])\n", + "t_spindown = 2500\n", + "t_spinup = 7500\n", + "\n", + "def flow_fac(t):\n", + " if (t <= t_spindown):\n", + " return 1.0\n", + " elif (t < (t_spindown + 20.0)):\n", + " return max(spindown_fit(t-t_spindown)/100.0, 0.02)\n", + " elif (t <= t_spinup):\n", + " return 0.02\n", + " elif (t < t_spinup + 8.20):\n", + " return max(spinup_fit(t-t_spinup)/100.0, 0.02)\n", + " else:\n", + " return 1.0\n", + "\n", + "flow_pct = MSRE.add_input(flow_fac, T, max_anchors = 5000, input_tol = 32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define nodes\n", + "\n", + "# radiator\n", + "T_out_rc = Node(m=mn_rp, scp=mcp_rpn/mn_rp, W=W_rp, y0=T0_rp, name='T_out_rc')\n", + "T_out_air = Node(m=mn_rs, scp=mcp_rsn/mn_rs, W=W_rs, y0=T0_rs, name='T_out_air')\n", + "\n", + "# heat exchanger\n", + "T_hf1 = Node(m=mn_p, scp=mcp_pn/mn_p, W=W_p*flow_pct, y0=T0_p1, name='T_hf1')\n", + "T_hf2 = Node(m=mn_p, scp=mcp_pn/mn_p, W=W_p*flow_pct, y0=T0_p2, name='T_hf2')\n", + "T_hf3 = Node(m=mn_p, scp=mcp_pn/mn_p, W=W_p*flow_pct, y0=T0_p3, name='T_hf3')\n", + "T_hf4 = Node(m=mn_p, scp=mcp_pn/mn_p, W=W_p*flow_pct, y0=T0_p4, name='T_hf4')\n", + "T_ht1 = Node(m=m_tn, scp=scp_t, y0=T0_t1, name='T_ht1')\n", + "T_ht2 = Node(m=m_tn, scp=scp_t, y0=T0_t2, name='T_ht2')\n", + "T_hc1 = Node(m=mn_s, scp=mcp_sn/mn_s, W=W_s*flow_pct, y0=T0_s1, name='T_hc1')\n", + "T_hc2 = Node(m=mn_s, scp=mcp_sn/mn_s, W=W_s*flow_pct, y0=T0_s2, name='T_hc2')\n", + "T_hc3 = Node(m=mn_s, scp=mcp_sn/mn_s, W=W_s*flow_pct, y0=T0_s3, name='T_hc3')\n", + "T_hc4 = Node(m=mn_s, scp=mcp_sn/mn_s, W=W_s*flow_pct, y0=T0_s4, name='T_hc4')\n", + "\n", + "# core \n", + "n = Node(y0=n_frac0, name='n')\n", + "C1 = Node(y0=C0[0], name='C1')\n", + "C2 = Node(y0=C0[1], name='C2')\n", + "C3 = Node(y0=C0[2], name='C3')\n", + "C4 = Node(y0=C0[3], name='C4')\n", + "C5 = Node(y0=C0[4], name='C5')\n", + "C6 = Node(y0=C0[5], name='C6')\n", + "rho = Node(y0=rho_0, name='rho')\n", + "\n", + "rho_control = Node(y0=0.0, name='rho_control')\n", + "\n", + "T_cg = Node(m=mcp_g1/scp_g, scp=scp_g, y0=T0_g1, name='T_cg')\n", + "T_cf1 = Node(m=mn_f, scp=scp_f, W=W_f*flow_pct, y0=T0_f1, name='T_cf1')\n", + "T_cf2 = Node(m=mn_f, scp=scp_f, W=W_f*flow_pct, y0=T0_f1, name='T_cf2')\n", + "\n", + "MSRE.add_nodes([T_out_rc,T_out_air,T_hf1,T_hf2,T_hf3,T_hf4,T_ht1,T_ht2,T_hc1,\n", + " T_hc2,T_hc3,T_hc4,n,C1,C2,C3,C4,C5,C6,T_cg,T_cf1,T_cf2,rho, rho_control])\n", + "\n", + "# dynamics\n", + "\n", + "# radiator\n", + "T_out_rc.set_dTdt_advective(source = T_hc4.y(t-tau_hx_r/flow_pct))\n", + "T_out_rc.set_dTdt_convective(source = [T_out_air.y()], hA = [hA_rpn*flow_pct])\n", + "\n", + "T_out_air.set_dTdt_advective(source = Trs_in)\n", + "T_out_air.set_dTdt_convective(source = [T_out_rc.y()], hA = [hA_rsn])\n", + "\n", + "# heat exchanger\n", + "T_hf1.set_dTdt_advective(source = T_cf2.y(t-tau_c_hx/flow_pct))\n", + "T_hf1.set_dTdt_convective(source = [T_ht1.y()], hA = [hA_pn*flow_pct])\n", + "\n", + "T_hf2.set_dTdt_advective(source = T_hf1.y())\n", + "T_hf2.dTdt_convective = T_hf1.dTdt_convective\n", + "\n", + "T_hf3.set_dTdt_advective(source = T_hf2.y())\n", + "T_hf3.set_dTdt_convective(source = [T_ht2.y()], hA = [hA_pn*flow_pct])\n", + "\n", + "T_hf4.set_dTdt_advective(source = T_hf3.y())\n", + "T_hf4.dTdt_convective = T_hf3.dTdt_convective\n", + "\n", + "T_ht1.set_dTdt_convective(source = [T_hf1.y(),T_hf1.y(),T_hc3.y(),T_hc3.y()], hA = [hA_pn*flow_pct,hA_pn*flow_pct,hA_sn*flow_pct,hA_sn*flow_pct])\n", + "T_ht2.set_dTdt_convective(source = [T_hf3.y(),T_hf3.y(),T_hc1.y(),T_hc1.y()], hA = [hA_pn*flow_pct,hA_pn*flow_pct,hA_sn*flow_pct,hA_sn*flow_pct])\n", + "\n", + "T_hc1.set_dTdt_advective(source = T_out_rc.y(t-tau_r_hx/flow_pct))\n", + "T_hc1.set_dTdt_convective(source = [T_ht2.y()], hA = [hA_sn*flow_pct])\n", + "\n", + "T_hc2.set_dTdt_advective(source = T_hc1.y())\n", + "T_hc2.dTdt_convective = T_hc1.dTdt_convective\n", + "\n", + "T_hc3.set_dTdt_advective(source = T_hc2.y())\n", + "T_hc3.set_dTdt_convective(source = [T_ht1.y()], hA = [hA_sn*flow_pct])\n", + "\n", + "T_hc4.set_dTdt_advective(source = T_hc3.y())\n", + "T_hc4.dTdt_convective = T_hc3.dTdt_convective\n", + "\n", + "# core\n", + "n.set_dndt(r = rho.y() + rho_control.y(), beta_eff = beta_t, Lambda = Lam, lam = lam, C = [C1.y(),C2.y(),C3.y(),C4.y(),C5.y(),C6.y()])\n", + "C1.set_dcdt(n.y(), beta = beta[0],Lambda = Lam, lam = lam[0], t_c = tau_c/flow_pct, t_l = tau_l/flow_pct, flow = True)\n", + "C2.set_dcdt(n.y(), beta = beta[1],Lambda = Lam, lam = lam[1], t_c = tau_c/flow_pct, t_l = tau_l/flow_pct, flow = True)\n", + "C3.set_dcdt(n.y(), beta = beta[2],Lambda = Lam, lam = lam[2], t_c = tau_c/flow_pct, t_l = tau_l/flow_pct, flow = True)\n", + "C4.set_dcdt(n.y(), beta = beta[3],Lambda = Lam, lam = lam[3], t_c = tau_c/flow_pct, t_l = tau_l/flow_pct, flow = True)\n", + "C5.set_dcdt(n.y(), beta = beta[4],Lambda = Lam, lam = lam[4], t_c = tau_c/flow_pct, t_l = tau_l/flow_pct, flow = True)\n", + "C6.set_dcdt(n.y(), beta = beta[5],Lambda = Lam, lam = lam[5], t_c = tau_c/flow_pct, t_l = tau_l/flow_pct, flow = True)\n", + "\n", + "rho_control.dydt = -sp.Min(29.0e-5, sp.Max(-29.0e-5, n.dydt))\n", + "\n", + "\n", + "T_cg.set_dTdt_convective(source = [T_cf1.y()], hA = [hA_fg*flow_pct])\n", + "T_cg.set_dTdt_internal(source = [n.y()], k = [k_g*P])\n", + "\n", + "T_cf1.set_dTdt_advective(source = T_hf4.y(t-tau_hx_c/flow_pct))\n", + "T_cf1.set_dTdt_convective(source = [T_cg.y()], hA = [k_1*hA_fg*flow_pct])\n", + "T_cf1.set_dTdt_internal(source = [n.y()], k = [k_f1*P])\n", + "\n", + "T_cf2.set_dTdt_advective(source = T_cf1.y())\n", + "T_cf2.dTdt_convective = T_cf1.dTdt_convective\n", + "T_cf2.set_dTdt_internal(source = [n.y()], k = [k_f2*P])\n", + "\n", + "rho.set_drdt(sources = [T_cf1.dydt, T_cg.dydt], coeffs = [a_f,a_g])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finalizing integrator...\n", + "integrating...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Integration progress: 0%| | 0/1000000 [00:00" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_ornl_spindown = pd.read_csv(os.getcwd() + '/data/ornl_spindown.csv', header = None, names = ['time', 'pcm'])\n", + "df_ornl_spinup = pd.read_csv(os.getcwd() + '/data/ornl_spinup.csv', header = None, names = ['time', 'pcm'])\n", + "\n", + "fig, axs = plt.subplots(1,2, figsize = (12,5))\n", + "\n", + "T_compare_spindown = T[(T >= 2500.0) & (T <= 2572.0)] -2500\n", + "rho_compare_spindown = 200+(rho_control.y_out[(T >= 2500.0) & (T <= 2572.0)])*1e5\n", + "\n", + "T_compare_spinup = T[(T >= 7500.0) & (T <= 7547.0)] -7500\n", + "rho_compare_spinup = 200+(rho_control.y_out[(T >= 7500.0) & (T <= 7547.0)])*1e5\n", + "\n", + "update_axis_style(axs[0], title = 'MSRE Pump Coastdown Test')\n", + "axs[0].plot(T_compare_spindown, rho_compare_spindown, label = 'simulated, msrDynamics')\n", + "axs[0].scatter(df_ornl_spindown['time'], df_ornl_spindown['pcm'], marker=\"2\",color=colors[2],label=\"measured, ORNL\")\n", + "axs[0].set_xlim([0,72])\n", + "axs[0].legend()\n", + "\n", + "update_axis_style(axs[1], title = 'MSRE Pump Startup Test')\n", + "axs[1].plot(T_compare_spinup, rho_compare_spinup-rho_compare_spinup[0], label = 'simulated, msrDynamics')\n", + "axs[1].scatter(df_ornl_spinup['time'], df_ornl_spinup['pcm'], marker=\"2\",color=colors[2],label=\"measured, ORNL\")\n", + "axs[1].set_xlim([0,47])\n", + "axs[1].legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "onion_dynamics_py312", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/dynamic_model/pump_transient_benchmark/steady_state.ipynb b/dynamic_model/pump_transient_benchmark/steady_state.ipynb new file mode 100644 index 0000000..7ad2046 --- /dev/null +++ b/dynamic_model/pump_transient_benchmark/steady_state.ipynb @@ -0,0 +1,22 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}