Floc_Redesign_Workbook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Floc_Redesign_Workbook.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AguaClara/Prefabricated-Pilot-Plant/blob/master/Floc_Redesign_Workbook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XUxHZRaQVbpj",
        "colab_type": "text"
      },
      "source": [
        "# **Flocculator Redesign Workbook** "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FYjxDM0idXYT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install aguaclara\n",
        "import aguaclara.core.head_loss as minorloss\n",
        "import aguaclara.design.human_access as ha\n",
        "import aguaclara.core.physchem as pc\n",
        "import aguaclara.core.pipes as pipes\n",
        "from aguaclara.core.units import unit_registry as u\n",
        "import numpy as np\n",
        "import pandas as pd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S65SV3M7VjkE",
        "colab_type": "text"
      },
      "source": [
        "Current Flocculator Redesign"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x_MV6_WndVR7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "387cdce8-f52b-4485-e6fa-319c95dcd02c"
      },
      "source": [
        "# Governing Equation: h_l = v^2 / 2g (n_c*k_c + n_b* (Apipe/Aopen*pi_vc - 1)^2)\n",
        "\n",
        "tot_hl = 50 * u.cm # Desired headloss for flocculator system\n",
        "num_elbows = 12 # Total number of elbows in piping\n",
        "K_elbow = 0.3 # headloss coefficient for 3 inch pipe 90 degree bend\n",
        "vel = 1 * u.m/u.s # Average velocity through flocculator\n",
        "num_baf = 48 # number of baffles in system\n",
        "A_pipe = np.pi * ((pipes.ID_sch40(3*u.inch)/2) ** 2) # area of 3 inch pipe\n",
        "pi_vc = 0.62 #vena contracta coefficient for 90 degree bend\n",
        "\n",
        "A_open =  A_pipe/pi_vc * 1/((np.sqrt((2*pc.gravity*tot_hl)/(vel**2) - num_elbows*K_elbow\n",
        "                         / num_baf) + 1))\n",
        "percen = (A_open/A_pipe) * 100\n",
        "print(A_pipe)\n",
        "print(A_open)\n",
        "print(percen)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7.393 inch ** 2\n",
            "2.894 inch ** 2\n",
            "39.15 dimensionless\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sH-VYt3dwgEx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "8a690abe-5e41-442e-c32d-2c7ede3b0ed1"
      },
      "source": [
        "# Round Twoski\n",
        "\n",
        "Q_in = 1 * u.L / u.s\n",
        "A_pipe = np.pi * (pipes.ID_sch40(1.5*u.inch) ** 2) # area of 3 inch pipe\n",
        "pipe_vel = Q_in / A_pipe # average velocity flowing through the pipe with no baffle\n",
        "print(pipe_vel.to(u.m/u.s))\n",
        "\n",
        "tot_hl = 50 * u.cm # Desired headloss for flocculator system\n",
        "num_elbows = 12 # Total number of elbows in piping\n",
        "K_elbow = 0.3 # headloss coefficient for 3 inch pipe 90 degree bend\n",
        "rem_hl =  (tot_hl - (num_elbows*K_elbow * (pipe_vel ** 2)/(2* pc.gravity))) #remaining headloss without elbows\n",
        "print(rem_hl)\n",
        "\n",
        "num_baf = 48 # number of baffles in system\n",
        "baf_hl = rem_hl / num_baf # headloss per baffle\n",
        "print(baf_hl)\n",
        "\n",
        "targ_vc = (np.sqrt(2*pc.gravity*baf_hl/(pipe_vel ** 2)) ) #solve for vc from K equation\n",
        "print(targ_vc)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.1903 meter / second\n",
            "49.34 centimeter\n",
            "1.028 centimeter\n",
            "-1.359 dimensionless\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ETBpl3KbW67H",
        "colab_type": "text"
      },
      "source": [
        "New Flocculator Design"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xUHgYFbwXjhq",
        "colab_type": "code",
        "outputId": "27029934-b96d-48da-f8ca-3c82a86d0b30",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 679
        }
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting aguaclara\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/96/e5/8e08f91aa57147375f2bcda4eecb9df97209975eacf119fafdc69a26860c/aguaclara-0.1.1.tar.gz (81kB)\n",
            "\u001b[K     |████████████████████████████████| 81kB 3.1MB/s \n",
            "\u001b[?25hCollecting pint==0.8.1 (from aguaclara)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/1e/40/6938f7d544eef208a8183c2c80624289e8a4f4e0aea43f4658b9527077de/Pint-0.8.1.tar.gz (162kB)\n",
            "\u001b[K     |████████████████████████████████| 163kB 8.5MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from aguaclara) (1.16.4)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from aguaclara) (0.24.2)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from aguaclara) (3.0.3)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from aguaclara) (1.3.0)\n",
            "Collecting onshapepy (from aguaclara)\n",
            "  Downloading https://files.pythonhosted.org/packages/eb/02/3db2d83488c979c0e8cb83ee4dc2d0fa859e13f35e31487911ba07f824a2/onshapepy-0.0.18.tar.gz\n",
            "Requirement already satisfied: python-dateutil>=2.5.0 in /usr/local/lib/python3.6/dist-packages (from pandas->aguaclara) (2.5.3)\n",
            "Requirement already satisfied: pytz>=2011k in /usr/local/lib/python3.6/dist-packages (from pandas->aguaclara) (2018.9)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->aguaclara) (0.10.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->aguaclara) (1.1.0)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->aguaclara) (2.4.0)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.6/dist-packages (from onshapepy->aguaclara) (2.21.0)\n",
            "Collecting ruamel.yaml (from onshapepy->aguaclara)\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/44/5f/57033d598ba3c2685eaac2f7e4860e511a8b5d1d408f3b299e63596bc53d/ruamel.yaml-0.15.97-cp36-cp36m-manylinux1_x86_64.whl (655kB)\n",
            "\u001b[K     |████████████████████████████████| 665kB 39.2MB/s \n",
            "\u001b[?25hRequirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.5.0->pandas->aguaclara) (1.12.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from kiwisolver>=1.0.1->matplotlib->aguaclara) (41.0.1)\n",
            "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->onshapepy->aguaclara) (3.0.4)\n",
            "Requirement already satisfied: urllib3<1.25,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests->onshapepy->aguaclara) (1.24.3)\n",
            "Requirement already satisfied: idna<2.9,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests->onshapepy->aguaclara) (2.8)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests->onshapepy->aguaclara) (2019.3.9)\n",
            "Building wheels for collected packages: aguaclara, pint, onshapepy\n",
            "  Building wheel for aguaclara (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Stored in directory: /root/.cache/pip/wheels/67/cb/2a/97692914470ff85150e4769f1e143ef68c722eeacd8dccade4\n",
            "  Building wheel for pint (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Stored in directory: /root/.cache/pip/wheels/b4/56/36/7c4d6a4e3660e233b95e3b0482551915cb184abca0f93ee1dd\n",
            "  Building wheel for onshapepy (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Stored in directory: /root/.cache/pip/wheels/ea/bd/5d/bcad50021b4d6e49e006edc8c271d68b4493a83e5a85551e57\n",
            "Successfully built aguaclara pint onshapepy\n",
            "Installing collected packages: pint, ruamel.yaml, onshapepy, aguaclara\n",
            "Successfully installed aguaclara-0.1.1 onshapepy-0.0.18 pint-0.8.1 ruamel.yaml-0.15.97\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yk0FQfNkW-MT",
        "colab_type": "code",
        "outputId": "1c5b124b-7614-45a3-9942-654719e30437",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        }
      },
      "source": [
        "##Flocculatorita Code\n",
        "\n",
        "\n",
        "\n",
        "BAFFLE_THICKNESS = 2 * u.mm\n",
        "PVC_CHANNEL_THICKNESS = 1 * u.inch\n",
        "\n",
        "class Flocculatorita:\n",
        "    \"\"\"Calculates physical dimensions of a flocculatorita\n",
        "    ----------------------------\n",
        "    - BAFFLE_K (K or K_{baffle}): float\n",
        "        - The minor loss coefficient of the flocculator baffles.\n",
        "    - CHANNEL_N_MIN (N_{channel}: int\n",
        "        - The minimum number of flocculator channels.\n",
        "    - HS_RATIO_MIN (\\Pi_{HS}): float\n",
        "        - The minimum ratio between expansion height and baffle spacing\n",
        "    - RATIO_MAX_HS (\\Pi_{HS}): float\n",
        "        - The maximum ratio between expansion height and baffle spacing\n",
        "    - SDR (sdr): float\n",
        "        - The standard dimension ratio.\n",
        "    \"\"\"\n",
        "\n",
        "    # Increased both to provide a safety margin on flocculator head loss and\n",
        "    # to simultaneously scale back on the actual collision potential we are\n",
        "    # trying to achieve.\n",
        "    # Originally calculated to be 2.3 from the equations:\n",
        "\n",
        "\n",
        "    BAFFLE_K = 2.5\n",
        "    CHANNEL_N_MIN = 1\n",
        "    RATIO_MAX_HS = 6.0\n",
        "    SDR = 41.0\n",
        "    pi_VC_180bend=.384 #source: (Floc Design PP )\n",
        "\n",
        "    def __init__(\n",
        "            self,\n",
        "            Q=1 * u.L/u.s,\n",
        "            temp=25 * u.degC,\n",
        "            Gt=37000,\n",
        "            HL = 40 * u.cm,\n",
        "            downstream_H = 2 * u.m,\n",
        "            ent_tank_L=0*u.m,\n",
        "            max_W=42 * u.inch,\n",
        "            available_tank_diameters = [12.2, 15.1, 18.2,24.1, 30.2,36.0,42.0,47.9,59.9,72.0],\n",
        "            available_obstacle_diameters = [1/2,3/4,1,5/4,3/2,2,5/2,3,7/2,4,5,6,8,10,12,14,16],\n",
        "            n_channels=5,\n",
        "            pi_VC_180bend=pi_VC_180bend,\n",
        "            tank_diameters_prices = [[12.2, 4.07], [15.1, 5.70], [18.2, 8.00],[24.1, 12.64], [30.2, 18.60],[36.0, 24.33], [42.0, 28.40],[47.9 , 39.42] , [59.9, 63.51]],\n",
        "            baffle_price = (20.5/1872) * u.USD/(u.inch**2),\n",
        "            PVC_channel_price = (431/4608) * u.USD/(u.inch**2),\n",
        "            obstacle_diameters_prices = [[1/2, 1.95/5],[3/4, 2.35/5],[1, 3.91/5],[5/4, 4.55/5],[3/2, 4.99/5],[2, 6.90/5],[5/2, 10.26/5],[3, 13.90/5],[7/2, 39.95/5],[4, 18.90/5],[5, 57.50/5],[6, 37.94/5],[8, 55.00/5],[10, 76.81/5],[12, 109.86/5],[14, 180.75/5],[16, 228.52/5]]\n",
        "            ):\n",
        "\n",
        "        self.Q = Q\n",
        "        self.temp = temp\n",
        "        self.Gt = Gt\n",
        "        self.HL = HL\n",
        "        self.downstream_H = downstream_H\n",
        "        self.ent_tank_L = ent_tank_L\n",
        "        self.max_W = max_W\n",
        "        self.n_channels=n_channels\n",
        "        self.pi_VC_180bend=pi_VC_180bend\n",
        "        self.available_tank_diameters=available_tank_diameters\n",
        "        self.tank_diameters_prices = tank_diameters_prices\n",
        "        self.baffle_price = baffle_price\n",
        "        self.PVC_channel_price = PVC_channel_price\n",
        "        self.obstacle_diameters_prices = obstacle_diameters_prices\n",
        "        self.available_obstacle_diameters = available_obstacle_diameters\n",
        "\n",
        "\n",
        "    @property\n",
        "    def vel_grad_avg(self):\n",
        "        #NOTE: this is borrowed from AguaClara source code\n",
        "        \"\"\"Calculate the average velocity gradient (G-bar) of water flowing\n",
        "        through the flocculator.\n",
        "        :returns: Average velocity gradient (G-bar)\n",
        "        :rtype: float * 1 / second\n",
        "        \"\"\"\n",
        "        return ((u.standard_gravity * self.HL) /\n",
        "               (pc.viscosity_kinematic(self.temp) * self.Gt)).to(u.s ** -1)\n",
        "\n",
        "    @property\n",
        "    def retention_time(self):\n",
        "        #NOTE: this is borrowed from AguaClara source code\n",
        "        \"\"\"Calculates the hydraulic retention time neglecting the volume created by head loss in the flocculator.\n",
        "        :returns: Hydraulic retention time (:math:`\\theta`)\n",
        "        :rtype: float * second\n",
        "        \"\"\"\n",
        "        return (self.Gt / self.vel_grad_avg).to(u.s)\n",
        "\n",
        "    @property\n",
        "    def vol(self):\n",
        "        #NOTE: this is borrowed from AguaClara source code\n",
        "        \"\"\"Calculate the target volume (not counting the volume added by head loss) of the flocculator.\n",
        "        :returns: Target volume\n",
        "        :rtype: float * meter ** 3\n",
        "        \"\"\"\n",
        "        return (self.Q * self.retention_time).to(u.m ** 3)\n",
        "\n",
        "    @property\n",
        "    def cross_sectional_area(self):\n",
        "        \"\"\"This function calculates the necessary active cross sectional area of the flocculator\"\"\"\n",
        "        return (self.vol/self.downstream_H).to(u.m**2)\n",
        "\n",
        "\n",
        "    @property\n",
        "    def min_diameter_tank(self):\n",
        "        \"\"\"\"this function calculates the necessary diameter to accommodate the required cross sectional area, assuming that the only \"active space\" in the cross section is the largest square that will fit into the larger PVC pipe\"\"\"\n",
        "        return ((2*self.cross_sectional_area)**.5).to(u.inch)\n",
        "\n",
        "    @property\n",
        "    def design_diameter_tank(self):\n",
        "        \"\"\"This function selects the closest available PVC tank to the calculated minimum pipe diameter\"\"\"\n",
        "        for i in range(len(self.available_tank_diameters)):\n",
        "            if self.available_tank_diameters[i]*u.inch <= self.min_diameter_tank:\n",
        "                i +=1\n",
        "            else:\n",
        "                return self.available_tank_diameters[i]*u.inch\n",
        "\n",
        "    @property\n",
        "    def channel_L(self):\n",
        "        \"\"\"This function determines channel length based the largest square that fits inside of the selected tank. So, channel length is the the length of the square\"\"\"\n",
        "        return ((self.design_diameter_tank)**2/2)**.5\n",
        "\n",
        "    @property\n",
        "    def channel_W(self):\n",
        "       \"\"\"This function calculates the channel width by dividing the total width of the active cross sectional area by number of channels\"\"\"\n",
        "       return (self.channel_L/self.n_channels).to(u.cm)\n",
        "       ###NOTE: incorporate baffle width\n",
        "\n",
        "    @property\n",
        "    def expansion_max_H(self):\n",
        "        #NOTE: This is borrowed from AguaClara source code\n",
        "        \"\"\"\"Return the maximum distance between expansions for the largest\n",
        "        allowable H/S ratio.\n",
        "        :returns: Maximum expansion distance\n",
        "        :rtype: float * meter\n",
        "        Examples\n",
        "        --------\n",
        "        exp_dist_max(20*u.L/u.s, 40*u.cm, 37000, 25*u.degC, 2*u.m)\n",
        "        0.375 meter\n",
        "        \"\"\"\n",
        "        return (((self.BAFFLE_K / (2 * pc.viscosity_kinematic(self.temp) * (self.vel_grad_avg ** 2))) *\n",
        "                (self.Q * self.RATIO_MAX_HS / self.channel_W) ** 3) ** (1/4)).to(u.m)\n",
        "\n",
        "    @property\n",
        "    def expansion_n(self):\n",
        "        #NOTE: This is borrowed from AguaClara source code\n",
        "        \"\"\"Return the minimum number of expansions per baffle space.\n",
        "        :returns: Minimum number of expansions/baffle space\n",
        "        :rtype: int\n",
        "        \"\"\"\n",
        "        return np.ceil(self.downstream_H / self.expansion_max_H)\n",
        "\n",
        "    @property\n",
        "    def expansion_H(self):\n",
        "      #NOTE: This is borrowed from AguaClara source code#NOTE: This is borrowed from AguaClara source code\n",
        "        \"\"\"Returns the height between flow expansions.\n",
        "        :returns: Height between flow expansions\n",
        "        :rtype: float * centimeter\n",
        "        \"\"\"\n",
        "        return (self.downstream_H / self.expansion_n).to(u.cm)\n",
        "\n",
        "    @property\n",
        "    def baffle_S(self):\n",
        "      #NOTE: This is borrowed from AguaClara source code\n",
        "        \"\"\"Return the spacing between baffles.\n",
        "        :returns: Spacing between baffles\n",
        "        :rtype: int\n",
        "        \"\"\"\n",
        "        return ((self.BAFFLE_K /\n",
        "                ((2 * self.expansion_H * (self.vel_grad_avg ** 2) *\n",
        "                 pc.viscosity_kinematic(self.temp))).to_base_units()) ** (1/3) *\n",
        "               self.Q / self.channel_W).to(u.cm)\n",
        "\n",
        "    @property\n",
        "    def obstacle_n(self):\n",
        "      #NOTE: This is borrowed from AguaClara source code\n",
        "        \"\"\"Return the number of obstacles per baffle.\n",
        "        :returns: Number of obstacles per baffle\n",
        "        :rtype: int\n",
        "        \"\"\"\n",
        "        return self.expansion_n - 1\n",
        "\n",
        "    @property\n",
        "    def obstacle_size(self):\n",
        "        \"\"\"This function calculates the size of obstacles, so that the obstacles cause the same flow expansion as a 180 degree bend in the flocculatorita\"\"\"\n",
        "\n",
        "        for i in range(len(self.available_obstacle_diameters)):\n",
        "            if (self.baffle_S*(1-self.pi_VC_180bend)).to(u.inch) >= self.available_obstacle_diameters[i]/2*u.inch :\n",
        "                i +=1\n",
        "            else:\n",
        "                return self.available_obstacle_diameters[i]*u.inch\n",
        "\n",
        "    @property\n",
        "    def baffle_n(self):\n",
        "        \"\"\"This function calclulates the number of the baffles in the flocculator.\"\"\"\n",
        "        return (np.ceil((self.channel_L/self.baffle_S*self.n_channels))).to(u.dimensionless)\n",
        "\n",
        "    @property\n",
        "    def design(self):\n",
        "        \"\"\"Returns the designed values.\n",
        "        :returns: list of designed values (G, t, channel_W, obstacle_n)\n",
        "        :rtype: int\n",
        "        \"\"\"\n",
        "        floc_dict = {'n_channels': self.n_channels,\n",
        "                     'channel_L': self.channel_L,\n",
        "                     'channel_W': self.channel_W,\n",
        "                     'baffle_S': self.baffle_S,\n",
        "                     'obstacle_n': self.obstacle_n,\n",
        "                     'G': self.vel_grad_avg,\n",
        "                     't': self.retention_time,\n",
        "                     'expansion_max_H': self.expansion_max_H,\n",
        "                     'min_diameter_tank': self.min_diameter_tank,\n",
        "                     'design_diameter_tank': self.design_diameter_tank}\n",
        "        return floc_dict\n",
        "\n",
        "    @property\n",
        "    def cost_of_tank(self):\n",
        "        \"\"\"Returns the cost of the tank.\n",
        "        \"\"\"\n",
        "        for i in range(len(self.available_tank_diameters)):\n",
        "            if self.available_tank_diameters[i]*u.inch < self.design_diameter_tank:\n",
        "                i +=1\n",
        "            else:\n",
        "                return (self.tank_diameters_prices[i][1]*(u.USD/u.ft) * (self.downstream_H + self.HL + 10*u.cm)).to(u.USD)\n",
        "\n",
        "    @property\n",
        "    def cost_of_baffles(self):\n",
        "        \"\"\"Returns the cost of the baffels.\n",
        "        \"\"\"\n",
        "\n",
        "        return (self.channel_W * (self.downstream_H + self.HL + (10 * u.cm)) * self.baffle_n * self.n_channels * self.baffle_price).to(u.USD)\n",
        "\n",
        "    @property\n",
        "    def cost_of_PVC_channels(self):\n",
        "        \"\"\"Returns the cost of the PVC Channels.\n",
        "        \"\"\"\n",
        "        return ((self.n_channels+1) * (self.downstream_H + self.HL + 10 * u.cm) * self.channel_L * self.PVC_channel_price).to(u.USD)\n",
        "\n",
        "\n",
        "    @property\n",
        "    def cost_of_obstacles(self):\n",
        "        \"\"\"Returns the cost of the obstacles.\n",
        "        \"\"\"\n",
        "        for i in range(len(self.available_obstacle_diameters)):\n",
        "          if self.available_obstacle_diameters[i]*u.inch < self.obstacle_size:\n",
        "            i +=1\n",
        "          else:\n",
        "            return (self.obstacle_diameters_prices[i][1]*(u.USD/u.ft) * self.obstacle_n*self.baffle_n*self.n_channels*self.channel_W/2).to(u.USD)\n",
        "\n",
        "    @property\n",
        "    def total_cost(self):\n",
        "        \"\"\"Returns the cost total cost.\n",
        "        \"\"\"\n",
        "        return self.cost_of_tank + self.cost_of_baffles + self.cost_of_PVC_channels + self.cost_of_obstacles\n",
        "\n",
        "    @property\n",
        "    def cost(self):\n",
        "        \"\"\"Returns costs of of everything\n",
        "        \"\"\"\n",
        "        cost_dict = {'cost of tank':self.cost_of_tank,\n",
        "                     'cost of baffles':self.cost_of_baffles,\n",
        "                     'cost of PVC channels':self.cost_of_PVC_channels,\n",
        "                     'cost of halfpipes':self.cost_of_obstacles,\n",
        "                     'total cost':self.total_cost}\n",
        "        return cost_dict\n",
        "\n",
        "\n",
        "    @property\n",
        "    def pi_sedtank_floc(self):\n",
        "        \"\"\"This function calculates the ratio of the sed tank diameter to the flocculator diameter if the sed tank's up flow velocity is 1 mm/s and height is 2 m\"\"\"\n",
        "        up_V=1*u.mm/u.s\n",
        "        depth=2*u.m\n",
        "        A_sedtank=self.Q/up_V\n",
        "        d_sedtank=(2*A_sedtank**.5).to(u.inch)\n",
        "        return (d_sedtank/self.min_diameter_tank)\n",
        "\n",
        "\n",
        "##make a data frame to show results\n",
        "q  = 1 * u.L/u.s #change this flow rate in order to display design specs for the flocculatorita handling that flow rate\n",
        "tester=Flocculatorita(Q=q)\n",
        "\n",
        "data ={'':['Tank Pipe Diameter', 'Width of Channels', 'Baffle Spacing', 'Cost'],\n",
        "       '1 Channel': [Flocculatorita(n_channels=1, Q=q).design_diameter_tank, Flocculatorita(n_channels=1, Q=q).channel_W, Flocculatorita(n_channels=1, Q=q).baffle_S,Flocculatorita(n_channels=1, Q=q).total_cost],\n",
        "       '2 Channels': [Flocculatorita(n_channels=2, Q=q).design_diameter_tank, Flocculatorita(n_channels=2, Q=q).channel_W, Flocculatorita(n_channels=2, Q=q).baffle_S, Flocculatorita(n_channels=2, Q=q).total_cost],\n",
        "       '3 Channels': [Flocculatorita(n_channels=3, Q=q).design_diameter_tank, Flocculatorita(n_channels=3, Q=q).channel_W, Flocculatorita(n_channels=3, Q=q).baffle_S,Flocculatorita(n_channels=3, Q=q).total_cost],\n",
        "       '4 Channels':[Flocculatorita(n_channels=4, Q=q).design_diameter_tank, Flocculatorita(n_channels=4, Q=q).channel_W, Flocculatorita(n_channels=4, Q=q).baffle_S, Flocculatorita(n_channels=4, Q=q).total_cost],\n",
        "       '5 Channels':[Flocculatorita(n_channels=5, Q=q).design_diameter_tank, Flocculatorita(n_channels=5, Q=q).channel_W, Flocculatorita(n_channels=5, Q=q).baffle_S, Flocculatorita(n_channels=5, Q=q).total_cost],\n",
        "       '6 Channels':[Flocculatorita(n_channels=6, Q=q).design_diameter_tank, Flocculatorita(n_channels=6, Q=q).channel_W, Flocculatorita(n_channels=6, Q=q).baffle_S,Flocculatorita(n_channels=6, Q=q).total_cost]\n",
        "       }\n",
        "Flocculatorita(n_channels=2, Q=q).total_cost\n",
        "\n",
        "df=pd.DataFrame(data)\n",
        "print(df)\n",
        "\n",
        "\n",
        "##Cost Comparison Code\n",
        "\n",
        "class Floc_1_min_res(Flocculatorita):\n",
        "  \"\"\"This class models a flocculatorita with 1 minute residence time\"\"\"\n",
        "  @property\n",
        "  def retention_time(self):\n",
        "    return 1*u.min\n",
        "  @property\n",
        "  def vol(self):\n",
        "    return ((self.Q*self.retention_time).to(u.L))\n",
        "\n",
        "\"\"\"Now, Floc_1_min_res is used to estimate the cost of the floculatorita, which would handle similar flow and have the same collision potential as the current PF300 flocculator.  \"\"\"\n",
        "cc=Floc_1_min_res(Q=1*u.L/u.s)\n",
        "print(cc.retention_time)\n",
        "print(cc.total_cost)\n",
        "\n",
        "\"\"\"Below are the calculations for the estimate of the cost of the current PF3000 flocculator\"\"\"\n",
        "\n",
        "three_in_pvc=(32.73*u.USD)/(10*u.ft) #this is the cost of a 10' long 3\" pvc pipe from [McMaster]https://www.mcmaster.com/pvc\n",
        "quantity_three_in_pvc=9*2*u.m\n",
        "price_three_in_pvc=quantity_three_in_pvc*three_in_pvc ##total cost of the 3\" PVC pipes that will used for the floculatorita\n",
        "\n",
        "T_three_in_pvc=\t7.66*u.USD #this is the cost from [McMaster]https://www.mcmaster.com/pvc\n",
        "quantity_T_three_in_pvc=10\n",
        "price_T_three_in_pvc=T_three_in_pvc*quantity_T_three_in_pvc\n",
        "\n",
        "\n",
        "three_in_elbow=5.22*u.USD #this is the cost from [McMaster]https://www.mcmaster.com/pvc\n",
        "quantity_three_in_elbow=12\n",
        "price_three_in_elbow=three_in_elbow*quantity_three_in_elbow\n",
        "\n",
        "pvc_sheet= 56.52*u.USD#used to make light deflectors, this is the cost from [McMaster]https://www.mcmaster.com/pvc\n",
        "quantity_pvc_sheet=1\n",
        "price_pvc_sheet=pvc_sheet*quantity_pvc_sheet\n",
        "\n",
        "\n",
        "nuts = 9.18*u.USD #the price of one pack of 25 1/4\" stainless steel nuts\n",
        "quantity_nuts = 1\n",
        "price_nuts = nuts * quantity_nuts\n",
        "\n",
        "reducer_3to2 = 10.28 *u.USD #price of a 3\" to 2\" pvc pipe reducer from McMaster\n",
        "quantity_reducer_3to2= 1\n",
        "price_reducer_3to2 = reducer_3to2 * quantity_reducer_3to2\n",
        "\n",
        "reducer_2to1 = 2.43 *u.USD #price of a 3\" to 2\" pvc pipe reducer from McMaster\n",
        "quantity_reducer_2to1= 1\n",
        "price_reducer_2to1 = reducer_2to1 * quantity_reducer_3to2\n",
        "\n",
        "PF300cost=(price_three_in_pvc+price_T_three_in_pvc+price_three_in_elbow+price_pvc_sheet+price_nuts+price_reducer_3to2 +price_reducer_2to1).to(u.USD)\n",
        "\n",
        "\n",
        "\n",
        "comparison=cc.total_cost/PF300cost\n",
        "print('The floculatorita is', comparison, 'times the cost of the current floculatorita')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "                              1 Channel  ...        5 Channels        6 Channels\n",
            "0  Tank Pipe Diameter         24.1 inch  ...         24.1 inch         24.1 inch\n",
            "1   Width of Channels  43.28 centimeter  ...  8.657 centimeter  7.214 centimeter\n",
            "2      Baffle Spacing   2.14 centimeter  ...   7.26 centimeter  8.712 centimeter\n",
            "3                Cost      987.6 dollar  ...       1932 dollar       2757 dollar\n",
            "\n",
            "[4 rows x 7 columns]\n",
            "1 minute\n",
            "659.8 dollar\n",
            "The floculatorita is 1.606 dimensionless times the cost of the current floculatorita\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PxLgiVq4XWAK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}