mbmore_enrich_compare.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "# Render our plots inline\n",
    "%matplotlib inline\n",
    "%pylab inline  \n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.mlab as mlab\n",
    "\n",
    "# General Plotting Parameters\n",
    "mpl.rcParams['figure.figsize'] = (8,5)\n",
    "mpl.rcParams['lines.linewidth'] = 2.5\n",
    "mpl.rcParams['font.weight'] = 'bold'\n",
    "mpl.rcParams['axes.linewidth'] = 1.5\n",
    "mpl.rcParams['font.size'] = 14.\n",
    "mpl.rcParams['legend.fontsize'] = 12.\n",
    "mpl.rcParams['axes.labelsize'] = 12.\n",
    "mpl.rcParams['xtick.labelsize'] = 10.\n",
    "mpl.rcParams['ytick.labelsize'] = 10.\n",
    "mpl.rcParams['xtick.minor.pad'] = 4\n",
    "mpl.rcParams['xtick.direction'] = 'out'\n",
    "mpl.rcParams['ytick.direction'] = 'out'\n",
    "\n",
    "#Git says this is patched, but it doesn't work from Pip --upgrade 26-mar-2015\n",
    "#mpl.rcParams['xtick.minor.visible'] = True  \n",
    "\n",
    "# These are the \"Tableau 20\" colors as RGB.  \n",
    "tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14),\n",
    "             (255, 187, 120), (44, 160, 44), (152, 223, 138),\n",
    "              (148, 103, 189),\n",
    "             (197, 176, 213), (140, 86, 75), (196, 156, 148),  \n",
    "             (227, 119, 194), (247, 182, 210), (127, 127, 127),\n",
    "             (199, 199, 199), (188, 189, 34), (219, 219, 141),\n",
    "             (23, 190, 207), (158, 218, 229),(214, 39, 40), (255, 152, 150)]  \n",
    "    \n",
    "# Scale the RGB values to the [0, 1] range,\n",
    "# which is the format matplotlib accepts.  \n",
    "for i in range(len(tableau20)): \n",
    "    r, g, b = tableau20[i]  \n",
    "    tableau20[i] = (r / 255., g / 255., b / 255.)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import calc_enrich\n",
    "reload(calc_enrich)\n",
    "from calc_enrich import calc_del_U\n",
    "from calc_enrich import machines_per_cascade\n",
    "from calc_enrich import N_product_by_alpha\n",
    "from calc_enrich import machines_per_enr_stage\n",
    "from calc_enrich import product_per_enr_stage\n",
    "from calc_enrich import machines_per_strip_stage\n",
    "from calc_enrich import N_waste_by_alpha\n",
    "\n",
    "\n",
    "\n",
    "from calc_enrich import Npc_from_Nstages\n",
    "from calc_enrich import Nwc_from_Nstages\n",
    "from calc_enrich import calc_feed_flows\n",
    "from calc_enrich import find_N_stages\n",
    "from calc_enrich import design_cascade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# centrifuge params \n",
    "eff = 1.0 # centrifuge efficiency\n",
    "\n",
    "d = 0.15  # m \n",
    "Z = 0.5   # m\n",
    "F_m = 15/1e6\n",
    "T = 320.0# K\n",
    "cut = 0.5\n",
    "omega = 485/(d/2)\n",
    "\n",
    "# cascade params\n",
    "Nfc = 0.0071\n",
    "Npc = 0.035\n",
    "Nwc = 0.001\n",
    "Fc_month = 739 #kg/month\n",
    "\n",
    "# The feed enrichment to be used when using a cascade designed for LEU to produce HEU.\n",
    "Nfc_mod = 0.20\n",
    "Fc_month_mod = Fc_month #kg/month\n",
    "\n",
    "#unit conversions\n",
    "kg_sec2kg_month = 30.4*24*60*60\n",
    "v_a = omega * (d/2.0)\n",
    "Fc = Fc_month/kg_sec2kg_month\n",
    "Fc_mod = Fc_month_mod/kg_sec2kg_month\n",
    "\n",
    "# Comparison numbers (not needed for calculations)\n",
    "del_U_th_yr = 1.1 #swu/yr\n",
    "del_U_obs_yr = 0.71 #Swu/yr\n",
    "del_U_th = del_U_th_yr/(365.25*24*60*60) #kgSWU/sec\n",
    "del_U_obs = del_U_obs_yr/(365.25*24*60*60)\n",
    "\n",
    "Pc_month = 77 #kg/month\n",
    "Pc = Pc_month/kg_sec2kg_month\n",
    "\n",
    "qty_len = 8\n",
    "assay_len = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha 1.16321031431\n",
      "del_U 7.03232816847e-08\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.5e-05"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha, del_U, del_U_yr, dirac = calc_del_U(v_a, Z, d, F_m, T, cut, eff)\n",
    "print \"alpha\", alpha\n",
    "print \"del_U\", del_U\n",
    "F_m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "machines per cascade 25990.3926986\n"
     ]
    }
   ],
   "source": [
    "n_mach = machines_per_cascade(del_U, Npc, Nwc, Fc, Pc)\n",
    "print \"machines per cascade\", n_mach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N enrich stage 11\n",
      "N strip stage 13\n",
      "mod product assay 0.600852653247\n",
      "mod waste assay 0.029084658345\n"
     ]
    }
   ],
   "source": [
    "nenr, nstr = find_N_stages(alpha, Nfc, Npc, Nwc)\n",
    "print \"N enrich stage\", nenr\n",
    "print \"N strip stage\", nstr\n",
    "\n",
    "mod_p_assay = Npc_from_Nstages(alpha, Nfc_mod, nenr)\n",
    "mod_w_assay = Nwc_from_Nstages(alpha, Nfc_mod, nstr)\n",
    "print \"mod product assay\", mod_p_assay\n",
    "print \"mod waste assay\", mod_w_assay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "product assay stage 0.00824923407502\n",
      "n enrich mach per stage 53.2872354761\n",
      "stage product 0.000140841318721\n",
      "n strip mach 26.6127432942\n",
      "waste assay 0.00511779135645\n"
     ]
    }
   ],
   "source": [
    "product_assay = N_product_by_alpha(alpha, Nfc)\n",
    "n_enr_mach= machines_per_enr_stage(alpha, del_U, Fc)\n",
    "stage_product= product_per_enr_stage(alpha, Nfc, product_assay, Fc)\n",
    "\n",
    "print \"product assay stage\", product_assay\n",
    "print \"n enrich mach per stage\", n_enr_mach\n",
    "print \"stage product\", stage_product\n",
    "\n",
    "enrich_waste = Fc - stage_product\n",
    "enr_waste_assay = (Fc*Nfc - stage_product*product_assay)/enrich_waste\n",
    "\n",
    "n_strip_mach = machines_per_strip_stage(alpha, del_U, enrich_waste)\n",
    "waste_assay = N_waste_by_alpha(alpha, enr_waste_assay)\n",
    "print \"n strip mach\", n_strip_mach\n",
    "print \"waste assay\", waste_assay\n",
    "\n",
    "#waste_assay = waste_per_strip_stage(alpha, enr_waste_assay, enrich_waste)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feed flows \n",
      "[ 0.00030693  0.00061387  0.0009208   0.00122774  0.00153467  0.00127889\n",
      "  0.00102311  0.00076734  0.00051156  0.00025578] \n",
      "\n",
      "\n",
      "Stage   #Mach\t Feed    Product  Waste\t F_assay \tP_assay W_assay\n",
      "0 \t291 \t4030.91    2015.45    2015.45    0.1 \t0.1145 \t0.0872\n",
      "1 \t243 \t3359.09    1679.55    1679.55    0.1145 \t0.1307 \t0.1\n",
      "2 \t194 \t2687.27    1343.64    1343.64    0.1307 \t0.1488 \t0.1145\n",
      "3 \t146 \t2015.45    1007.73    1007.73    0.1488 \t0.169 \t0.1307\n",
      "4 \t97 \t1343.64    671.82    671.82    0.169 \t0.1913 \t0.1488\n",
      "5 \t49 \t671.82    335.91    335.91    0.1913 \t0.2158 \t0.169\n",
      "-1 \t233 \t3224.73    1612.36    1612.36    0.0872 \t0.1 \t0.0759\n",
      "-2 \t175 \t2418.55    1209.27    1209.27    0.0759 \t0.0872 \t0.0659\n",
      "-3 \t117 \t1612.36    806.18    806.18    0.0659 \t0.0759 \t0.0572\n",
      "-4 \t59 \t806.18    403.09    403.09    0.0572 \t0.0659 \t0.0496\n"
     ]
    }
   ],
   "source": [
    "fa = 0.10\n",
    "pa = 0.20\n",
    "wa = 0.05\n",
    "\n",
    "n_enr_st, n_str_st = find_N_stages(alpha, fa, pa, wa)\n",
    "feed_flows = calc_feed_flows(n_enr_st, n_str_st, Fc, cut)\n",
    "print \"feed flows \\n\", feed_flows, \"\\n\\n\"\n",
    "\n",
    "tot_stage_info, tot_machiens = design_cascade(cut, alpha, del_U,fa, feed_flows,\n",
    "                   n_enr_st, n_str_st,\n",
    "                   assay_len=4, qty_len=6, verbose=True, pretty=True)\n",
    "\n",
    "tot_stages = n_enr_st+n_str_st\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step size is 0.952380952381\n",
      "curr try 1 Tot mach 1528 # in last stage:  47\n",
      "curr try 2 Tot mach 1453 # in last stage:  44\n",
      "curr try 3 Tot mach 1386 # in last stage:  42\n",
      "curr try 4 Tot mach 1320 # in last stage:  40\n",
      "curr try 5 Tot mach 1256 # in last stage:  38\n",
      "curr try 6 Tot mach 1198 # in last stage:  37\n",
      "curr try 7 Tot mach 1141 # in last stage:  35\n",
      "curr try 8 Tot mach 1087 # in last stage:  33\n",
      "curr try 9 Tot mach 1035 # in last stage:  32\n",
      "curr try 10 Tot mach 986 # in last stage:  30\n",
      "reduced flow to correct # 986\n",
      "Stage   #Mach\t Feed    Product  Waste\t F_assay \tP_assay W_assay\n",
      "0 \t179 \t2474.63    1237.31    1237.31    0.0071 \t0.0082 \t0.0061\n",
      "1 \t149 \t2062.19    1031.1    1031.1    0.0082 \t0.0096 \t0.0071\n",
      "2 \t119 \t1649.75    824.88    824.88    0.0096 \t0.0111 \t0.0082\n",
      "3 \t90 \t1237.31    618.66    618.66    0.0111 \t0.0129 \t0.0096\n",
      "4 \t60 \t824.88    412.44    412.44    0.0129 \t0.015 \t0.0111\n",
      "5 \t30 \t412.44    206.22    206.22    0.015 \t0.0174 \t0.0129\n",
      "-1 \t143 \t1979.7    989.85    989.85    0.0061 \t0.0071 \t0.0053\n",
      "-2 \t108 \t1484.78    742.39    742.39    0.0053 \t0.0061 \t0.0045\n",
      "-3 \t72 \t989.85    494.93    494.93    0.0045 \t0.0053 \t0.0039\n",
      "-4 \t36 \t494.93    247.46    247.46    0.0039 \t0.0045 \t0.0033\n",
      "Cascade can process  453.681894367  kg/month\n",
      "Final total machines 986\n"
     ]
    }
   ],
   "source": [
    "## Design Cascade based on available number of centrifuges, determine max Fc\n",
    "max_centrifuges = 1000\n",
    "curr_feed = Fc\n",
    "optimal_feed = Fc\n",
    "step_size = 1.05  # MUST be a number Greater than 1. \n",
    "step = 1\n",
    "#ideal_enrich_stage, ideal_strip_stage = find_N_stages(alpha, fa, pa, wa)\n",
    "#print \"n stages\", ideal_enrich_stage, ideal_strip_stage\n",
    "#feed_flows = calc_feed_flows(ideal_enrich_stage, ideal_strip_stage, curr_feed, cut)\n",
    "all_stages, n_centrifuges = design_cascade(cut, alpha, del_U, fa, feed_flows, n_enr_st, n_str_st)\n",
    "\n",
    "optimum_number = False\n",
    "neg_inc = False\n",
    "pos_inc = False\n",
    "\n",
    "if (n_centrifuges < max_centrifuges):\n",
    "    pos_inc = True\n",
    "    step = step_size\n",
    "elif (n_centrifuges > max_centrifuges):\n",
    "    neg_inc = True\n",
    "    step = 1.0/step_size\n",
    "else:\n",
    "    optimum_number = True\n",
    "ntries=0\n",
    "print \"step size is\", step\n",
    "while (optimum_number == False) and (ntries < 100):\n",
    "    ntries+=1\n",
    "    last_feed = curr_feed\n",
    "    curr_feed *= step\n",
    "    feed_flows = calc_feed_flows(n_enr_st, n_str_st, curr_feed, cut)\n",
    "    all_stages, n_centrifuges = design_cascade(cut, alpha, del_U, Nfc, feed_flows, n_enr_st, \n",
    "                                               n_str_st)\n",
    "    print \"curr try\", ntries, \"Tot mach\", n_centrifuges, \"# in last stage: \", all_stages[-1][1]\n",
    "    if (all_stages[-1][1] < 1):\n",
    "        print \"not enough centrifuges to fill all stages\"\n",
    "        optimum_number = True\n",
    "        optimal_feed = last_feed\n",
    "    elif (neg_inc == True) and (n_centrifuges < max_centrifuges):\n",
    "        optimum_number = True\n",
    "        optimal_feed = curr_feed\n",
    "        print \"reduced flow to correct #\", n_centrifuges\n",
    "    elif (pos_inc == True) and (n_centrifuges > max_centrifuges):\n",
    "        optimum_number = True\n",
    "        optimal_feed = last_feed\n",
    "        print \"increased flow to correct #\", n_centrifuges\n",
    "\n",
    "final_feed_flows = calc_feed_flows(n_enr_st, n_str_st, optimal_feed, cut)\n",
    "final_stages, final_n_mach = design_cascade(cut, alpha, del_U, Nfc, final_feed_flows, \n",
    "                                            n_enr_st, n_str_st, verbose=True, pretty=True)\n",
    "print \"Cascade can process \", optimal_feed*kg_sec2kg_month, \" kg/month\"\n",
    "print \"Final total machines\", final_n_mach\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal feed  0.000172728547746\n"
     ]
    }
   ],
   "source": [
    "print \"optimal feed \",optimal_feed\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}