thermofluids 2.0.0__py3-none-any.whl

thermofluids/ProcessEquipment/Column.py

@@ -0,0 +1,1004 @@
+import re
+import sys
+import warnings
+
+#import matplotlib.pyplot as #plt
+from thermofluids import Statepoint, Quantity
+from CoolProp.CoolProp import PropsSI
+from thermofluids.Properties.BrineProps import get_C_vap_sat, get_C_liq_sat
+from thermofluids.Properties.VLE_data import VLE
+from numpy import linspace, zeros
+
+from thermofluids.HeatTransfer.lmtd import lmtd
+
+
+class Column():
+    """
+    This class models distillation processes. There are three performance models:
+
+    1. ME_balance - This model just does mass and energy balances to determine the inputs and outputs. Use this model when you need high speed calculations and you don't need any info about column design
+    2. mccabe - This model does tray-wise mass and (approx.) energy balances using the McCabe Thiele model Use it to get more detailed information about the internal performance of the column with minimal computation time.
+    3. mccabe_diabatic - This model does tray-wise mass and (approx.) energy balances using the McCabe Thiele model. The operational line for this model is parallel to the VLE line to model a diabatic process.  It solves the model from the top tray downward such that inlet feed and outlet vapor are defined.  Use this model as a detailed, functional analysis of a diabatic column.
+    4. mccabe_diabatic_bottomup - This model is the same as mccabe_diabatic except that it attempts to solve it from the bottom up such that inlet feed and outlet liquid are defined. DON'T use this model... this function is currently buggy (go with mccabe_diabatic instead)
+    5. FullDetail - This model does a complete mass energy balance on every tray. Use it when you need the most internal performance detail, require a column design, and have some time to let it run. This function is currently buggy (go with mccabe_diabatic instead)
+
+    """
+    #currently only setup for 0 reflux columns
+    def __init__(self, P_col=None, inlet=None, outlet_vap=None, outlet_liq_c=None, fluid=None):
+        self.P_col = P_col
+        self.inlet = inlet
+        self.outlet_vap = outlet_vap
+        self.c_outlet_vap = outlet_vap
+        self.outlet_liq_c = outlet_liq_c
+        self.fluid = fluid
+
+    def set_P_col(self, P_col):
+        self.P_col = P_col
+
+    def set_inlet(self, inlet):
+        self.inlet = inlet
+
+    def set_outlet_vap(self, outlet_vap):
+        self.outlet_vap = outlet_vap
+
+    def set_outlet_liq_c(self, outlet_liq_c):
+        self.outlet_liq_c = outlet_liq_c
+
+    def set_fluid(self, fluid):
+        self.fluid = fluid
+
+    def set_Q_sens(self, Q_sens):
+        self.Q_sens = Q_sens
+
+    def set_diabatic(self, dia_targ):
+        self.dia_targ = dia_targ
+
+    def ME_balance(self):
+        """
+        This is the simplest column model. It just does mass and energy balances to determine how much heat is
+        required to get the desired top and bottom products from the inlet stream.
+
+        You can use the following results from this model:
+        Column.bottoms
+        Column.Q_input
+        """
+        assert isinstance(self.inlet, Statepoint), '\'inlet\' must be set to a Statepoint'
+        assert isinstance(self.outlet_vap, Statepoint), '\'outlet_vap\' must be set to a Statepoint'
+
+        self.outlet_vap.set_m((self.inlet.m * self.outlet_liq_c - self.inlet.m * self.inlet.c ) / (self.outlet_liq_c - self.outlet_vap.c))
+
+        self.bottoms = Statepoint(name='bottoms', fluid=self.fluid)
+        self.bottoms.set_p(self.P_col)
+        self.bottoms.set_x(0.)
+        self.bottoms.set_c(self.outlet_liq_c)
+        self.bottoms.set_m(self.inlet.m-self.outlet_vap.m)
+
+        self.Q_input = self.outlet_vap.m*self.outlet_vap.h + self.bottoms.m*self.bottoms.h - self.inlet.m*self.inlet.h
+
+
+    def mccabe(self, plotfile=None):
+        """
+        This is a graphical way to do an approximate mass and energy balance on each tray
+        For more info: https://en.wikipedia.org/wiki/McCabe%E2%80%93Thiele_method
+
+        You can use the following results from this model:
+        Column.n_trays
+        Produces a png picture file with the McCabe Theile diagram
+        """
+
+        # do a mass energy balance to get the bottoms
+        self.bottoms = Statepoint(name='bottoms', fluid=self.fluid)
+        self.bottoms.set_p(self.P_col)
+        self.bottoms.set_x(0.)
+        self.bottoms.set_c(self.outlet_liq_c)
+        self.bottoms.set_m(self.inlet.m-self.outlet_vap.m)
+
+        # Convert the flow rates to molar
+        fluid2, fluid1 = re.sub(r'^REFPROP-MIX:', '', self.fluid).split('&')
+        MW1 = PropsSI('M', 'T', 298., 'P', 1.e5, fluid1)
+        MW2 = PropsSI('M', 'T', 298., 'P', 1.e5, fluid2)
+
+        con_mol_inject = self.inlet.c/MW2 / (self.inlet.c/MW2 + (1.-self.inlet.c)/MW1)
+        con_mol_dist = self.outlet_vap.c/MW2 / (self.outlet_vap.c/MW2 + (1.-self.outlet_vap.c)/MW1)
+        con_mol_bottoms = self.bottoms.c/MW2 / (self.bottoms.c/MW2 + (1.-self.bottoms.c)/MW1)
+
+        # Solve for trays
+        rect_slope = 0.
+        operating_inject_y = con_mol_dist
+        strip_slope = (con_mol_dist - con_mol_bottoms) / (con_mol_inject - con_mol_bottoms)
+        operating_x = [con_mol_bottoms, con_mol_inject, con_mol_dist]                   #save operating line data for plotting
+        operating_y = [con_mol_bottoms, con_mol_dist, con_mol_dist]
+        feed_x = [con_mol_inject]*2                                                     #save injection line data for plotting
+        feed_y = [0., con_mol_dist]
+
+        trays_x = [con_mol_bottoms]*2
+        trays_y = [con_mol_bottoms]
+        under_target = True
+        while under_target:
+            trays_y.append(VLE(fluid1,fluid2,trays_x[-1]))
+            if trays_y[-1]>con_mol_dist:
+                    under_target=False          #this is enough trays to hit target
+                    trays_x.append(con_mol_dist)
+                    trays_y.append(trays_y[-1])
+            else:
+                if trays_y[-1]<operating_inject_y:
+                    trays_x.append(trays_x[-1]+(trays_y[-1]-trays_y[-2])/strip_slope)
+                else:
+                    trays_x.append(con_mol_inject+(trays_y[-1]-operating_inject_y)/rect_slope)
+                trays_x.append(trays_x[-1])
+                trays_y.append(trays_y[-1])
+            if len(trays_x)>100:
+                raise Exception('Too many trays!')
+
+        vle_range = [i/100. for i in range(100)]
+        vle = [VLE(fluid1, fluid2, con) for con in vle_range]
+
+        self.n_trays = (len(trays_x)-1)/2
+
+        #convert to mass
+        trays_x_mass = trays_x
+        trays_y_mass = trays_y
+        for i in range(len(trays_x)):
+            trays_x_mass[i] = trays_x[i]*MW2/(trays_x[i]*MW2+(1.-trays_x[i])*MW1)
+            trays_y_mass[i] = trays_y[i]*MW2/(trays_y[i]*MW2+(1.-trays_y[i])*MW1)
+        vle_range_mass = vle_range
+        vle_mass=vle
+        for i in range(len(vle)):
+            vle_range_mass[i] = vle_range[i]*MW2/(vle_range[i]*MW2+(1.-vle_range[i])*MW1)
+            vle_mass[i] = vle[i]*MW2/(vle[i]*MW2+(1.-vle[i])*MW1)
+        operating_x_mass=operating_x
+        operating_y_mass=operating_y
+        for i in range(len(operating_x)):
+            operating_x_mass[i] = operating_x_mass[i]*MW2/(operating_x_mass[i]*MW2+(1.-operating_x_mass[i])*MW1)
+            operating_y_mass[i] = operating_y_mass[i]*MW2/(operating_y_mass[i]*MW2+(1.-operating_y_mass[i])*MW1)
+        feed_x_mass=feed_x
+        feed_y_mass=feed_y
+        for i in range(len(feed_x)):
+            feed_x_mass[i] = feed_x[i]*MW2/(feed_x[i]*MW2+(1.-feed_x[i])*MW1)
+            feed_y_mass[i] = feed_y[i]*MW2/(feed_y[i]*MW2+(1.-feed_y[i])*MW1)
+
+        # plot
+        if plotfile != None:
+            print('')
+            #plt.figure()                        #make mccabe-thiele diagram
+            #plt.subplot(1,1,1)
+            #plt.plot(list(range(2)),list(range(2)))         #y=x line
+            ##plt.plot(vle_range,vle)             #vapor liquid equilibrium line
+            ##plt.plot(trays_x,trays_y)           #trays line
+            ##plt.plot(operating_x,operating_y)   #flowpath lines
+            ##plt.plot(feed_x,feed_y)
+            #plt.plot(vle_range_mass,vle_mass)             #vapor liquid equilibrium line
+            #plt.plot(trays_x_mass,trays_y_mass)           #trays line
+            #plt.plot(operating_x_mass,operating_y_mass)   #flowpath lines
+            #plt.plot(feed_x_mass,feed_y_mass)
+            #plt.xlim(0,1)
+            ##plt.xlabel('Liquid conc [mol/mol]')
+            #plt.xlabel('Liquid conc [kg/kg]')
+            #plt.ylim(0,1)
+            ##plt.ylabel('Vapor conc [mol/mol]')
+            #plt.ylabel('Vapor conc [kg/kg]')
+            #plt.savefig(plotfile)
+
+
+    def get_diabatic_curves(self, shift, plotfile=None, printmode=True):
+        """
+        This calculates the coordinates for the vapor-liquid equilibrium line and operating line for a given column.
+        The operating line is that which minimized exergy destruction. In order to find this operating line, this
+        function finds the shift value that will move the VLE line at a 45deg angle southeast such that it satisfies
+        the inlet liquid and outlet vapor concentrations.  That shift value is used in diabatic_mccabe during the
+        McCabe-Thiele calculations.
+        (See "Diabatic Column Optimization Compared to Isoforce Columns" by Sauar et al)
+
+        You can use the following results from this function:
+            column.x_sat             <-- saturated liquid concentrations for temperature range
+            column.y_sat             <-- saturated vapor concentrations for temperature range
+            column.x_oper            <-- operating liquid concentrations for temperature range
+            column.y_oper            <-- operating vapor concentrations for temperature range
+            column.oper_shift        <-- value used to make oper. line from VLE line (x_VLE + oper_shift, y_VLE - oper_shift)
+
+        Written by Fiona Majeau for Rebound Technology July 1 2016
+        """
+
+        # Set up bounds for bisect to find operating line shift
+        if shift == None:
+            y = self.outlet_vap.c  # vapor conc for outlet vap and inlet
+            x_min = get_C_liq_sat(self.fluid, y, self.P_col)  # sat liq conc for outlet vap (lower bound)
+            x_max = self.inlet.c  # sat liq conc for inlet (upper bound)
+            if x_min > x_max:
+                raise Exception('Liquid concentration of outlet vapor (%f) is higher than that of inlet feed (%f). '
+                                'Decrease outlet vapor conc or increase inlet liquid feed conc.' % (x_min, x_max))
+
+            # Set up bisect variables
+            x_lower = x_min
+            x_upper = x_max
+            tol = 0.01
+            i = 0
+            # print 'Bisecting...'
+            while True:
+                # print 'bisect ', i
+                x_guess = (x_lower + x_upper) / 2  # bisect
+                shift = x_max - x_guess  # find x shift
+                y_guess = y + shift  # make guess along y = 1-x line from inlet
+                y_sat_guess = get_C_vap_sat(self.fluid, x_guess, self.P_col)  # find y_sat for given x_guess
+
+                # Compare y's from y=1-x and VLE calc, check if they are close enough to be done
+                if abs(y_guess - y_sat_guess) < tol:
+                    break  # shift is correct
+
+                # Reassign upper/lower bound depending on which side of root you are on
+                if y_guess < y_sat_guess:
+                    x_upper = x_guess  # move upper bound in
+                else:
+                    x_lower = x_guess  # move lower bound in
+
+                    # i = i+1
+
+        if plotfile != None:
+            if printmode==True:
+                print('\nGETTING VLE AND OPERATING LINES...')
+            # Get saturation line for FPS mixture (for plotting)
+            x_sat = linspace(0, 1, 101)
+            y_sat = zeros(len(x_sat))
+            for i in range(len(x_sat)):
+                # print 'i =', i
+                y_sat[i] = get_C_vap_sat(self.fluid, x_sat[i], self.P_col)
+
+            # Create min. exergy dest. operational line (for plotting)
+            # NOTE: This is the operational line that gives minimum exergy destruction.  It is parallel to the saturation
+            #   line and is calculated by shifting the saturation line diagonally southeast by the outlet liquid composition.
+            x_oper = [z + shift for z in x_sat]
+            y_oper = [z - shift for z in y_sat]
+
+            self.x_sat = x_sat
+            self.y_sat = y_sat
+            self.x_oper = x_oper
+            self.y_oper = y_oper
+
+            # Plot
+            #plt.figure()  # make McCabe-Thiele diagram
+            #plt.subplot(1, 1, 1)
+            #plt.plot(list(range(2)), list(range(2)))  # y = x line
+            #plt.plot(self.x_sat, self.y_sat)  # VLE line
+            #plt.plot(self.x_oper, self.y_oper)  # operational line
+            ##plt.plot(trays_x, trays_y)  # McCabe Thiele points
+            #plt.xlim(0, 1)
+            #plt.xlabel('Liquid conc [kg/kg]')
+            #plt.ylim(0, 1)
+            #plt.ylabel('Vapor conc [kg/kg]')
+            #plt.savefig(plotfile)
+
+        self.oper_shift = shift
+        # print 'shift =', shift
+
+
+    def mccabe_diabatic(self, shift=None, plotfile=None, printmode=True):
+        """
+        This is a graphical way to do an approximate mass and energy balance on each tray for a diabatic column.
+        Creates McCabe-Thiele diagram using an minimum exergy destruction operational line that sets the liquid outlet
+        state (bottoms) given Statepoints for the inlet liquid and outlet vapor.  Using COE, the necessary Q_sens is
+        calculated for each tray.
+        (See "Diabatic Column Optimization Compared to Isoforce Columns" by Sauar et al)
+
+        You can use the following results from this model:
+            Column.num_trays         <-- number of trays
+            Column.Q_feed_to_satliq  <-- Q to heat inlet feed to saturated liquid (if subcooled)
+            Column.Q_sens            <-- array of Q_sens to each tray (1st val is top tray)
+            Column.Q_trays_total     <-- total Q going to trays (sum of Q_sens)
+            Column.Q_total           <-- total Q going to column (Q_trays_total + Q_feed_to_satliq)
+            Column.tray_temps        <-- array of temperature for each tray (1st val is top tray)
+            Column.tray_concs        <-- array of concentration arrays for each tray (1st val is top tray)
+            Column.tray_masses       <-- array of mass flow arrays for each tray (1st val is top tray)
+            Column.bottoms           <-- Statepoint of liquid outlet
+        As well as the outputs from get_diabatic_curves (called within)
+            column.x_sat             <-- saturated liquid concentrations for temperature range
+            column.y_sat             <-- saturated vapor concentrations for temperature range
+            column.x_oper            <-- operating liquid concentrations for temperature range
+            column.y_oper            <-- operating vapor concentrations for temperature range
+            column.oper_shift        <-- value used to make oper. line from VLE line (x_VLE + oper_shift, y_VLE - oper_shift)
+
+        Produces a png picture file with the McCabe-Theile diagram (includes VLE line and operating line)
+
+        Written by Fiona Majeau for Rebound Technology June 30 2016
+        Rectifying section added by Luke Erickson for Rebound Technology Nov 30 2016
+        """
+
+        if printmode==True:
+            print('\nMcCabe-Thiele method for diabatic column (minimum exergy destruction)')
+            print('---------------------------------------------------------------------')
+            print('*** TOP DOWN VERSION -- GOOD ***')
+
+        # Create Statepoint for liquid outlet "bottoms"
+        self.bottoms = Statepoint(name='bottoms', fluid=self.fluid, p=self.P_col, x=0.)
+        outlet_liq_c_max = self.outlet_liq_c  # maximum outlet liquid concentration (used as bound during tray calculations)
+
+        # Get operating line shift (plus VLE and operating lines for plotting)
+        self.get_diabatic_curves(shift=shift, plotfile=plotfile, printmode=printmode)
+        # if shift == None:
+
+        # Create arrays in which to store x and y values for each McCabe point, starting from the top
+        trays_x = [self.inlet.c]  # top inlet x
+        if shift==None:
+            shift = self.oper_shift
+            trays_y = [self.outlet_vap.c]  # top inlet y
+        else:
+            y_sat_xshift = float(get_C_vap_sat(self.fluid, trays_x[0] - shift, self.P_col))
+            trays_y = [y_sat_xshift - shift]
+        trays_x.append(float(get_C_liq_sat(self.fluid, trays_y[-1], self.P_col)))  # top outlet x
+        trays_y.append(trays_y[-1])  # top outlet y
+
+        # Cleanly store inflows/outflows for each tray for later use in COE
+        # NOTE: tray_concs is an array (with num_trays elements) where each element is an array [Vin Lout Vout Lin]
+        Vin = 0  # for indexing
+        Lout = 1
+        Vout = 2
+        Lin = 3
+        tray_concs = [[0., 0., 0., 0.], [0., 0., 0., 0.]]  # store concentrations (tray at 0 index will stay empty)
+        num_trays = 1  # start by populating the top tray (tray_conc[1])
+        tray_concs[num_trays][Lin] = trays_x[0]  # Lin to the top tray
+        tray_concs[num_trays][Vout] = trays_y[-1]  # Vout of the top tray
+
+        # Solve for trays, start from the top
+        if printmode==True:
+            print('\nSOLVING FOR CONCENTRATION IN EACH TRAY... ')
+        over_target = True
+        while over_target:
+
+            # Move vertically downward based on operating line shift
+            y_sat_xshift = float(get_C_vap_sat(self.fluid, trays_x[-1] - shift, self.P_col))
+
+            # Check whether movement downward will go into negative y values
+            if y_sat_xshift <= shift:           # can't have McCabe point there, done with trays
+                # Remove last McCabe point (VLE point from horiz. calc)
+                trays_x.remove(trays_x[-1])
+                trays_y.remove(trays_y[-1])
+                num_trays = num_trays - 1
+                tray_concs[num_trays][Vin] = 0.  # no vapor into bottom tray
+                print(tray_concs[num_trays-1])
+                print(tray_concs[num_trays])
+                print(tray_concs[num_trays+1])
+
+                #tray_concs[num_trays][Lout] = trays_x[-1]  # same as previous point
+                break
+
+            # Add point array
+            trays_y.append(y_sat_xshift - shift)
+            trays_x.append(trays_x[-1])
+
+            # Move horizontally with VLE calc
+            x_sat_horiz = float(get_C_liq_sat(self.fluid, trays_y[-1], self.P_col))
+            trays_x.append(x_sat_horiz)
+            trays_y.append(trays_y[-1])
+
+            # Update tray concentrations
+            tray_concs[num_trays][Lout] = trays_x[-2]  # second to last value appended
+            tray_concs[num_trays][Vin] = trays_y[-1]  # last value appended
+
+
+            # Check whether there is an operating line directly below in anticipation of next vertical calc
+            if trays_x[-1] <= shift:     # if so, can't have McCabe point there, done with trays
+                # Remove last McCabe point (VLE point from horiz. calc)
+                trays_x.remove(trays_x[-1])
+                trays_y.remove(trays_y[-1])
+                tray_concs[num_trays][Vin] = 0.  # no vapor into bottom tray
+                break
+
+            # Check whether this tray overshot the target outlet liquid
+            elif trays_x[-1] < outlet_liq_c_max: # below target outlet liquid conc, target reached
+                # Move vertically downward based on operating line shift to finish off final tray
+                num_trays = num_trays + 1
+                y_sat_xshift = float(get_C_vap_sat(self.fluid, trays_x[-1] - shift, self.P_col))
+                trays_y.append(y_sat_xshift - shift)
+                trays_x.append(trays_x[-1])
+                tray_concs.append([0., 0., 0., 0.])                           # populating last tray
+                tray_concs[num_trays][Lin] = tray_concs[num_trays - 1][Lout]  # Lin of next tray = Lout of current tray
+                tray_concs[num_trays][Vout] = tray_concs[num_trays - 1][Vin]  # Vout of next tray = Vin of current tray
+                tray_concs[num_trays][Lout] = trays_x[-1]  # same as previous point
+                tray_concs[num_trays][Vin] = 0.  # no vapor into bottom tray
+                break
+
+            # Print current tray
+            # print '--------------Tray %.2G --------------' % num_trays
+            # print 'Vap_in C = %.3f' % tray_concs[num_trays][Vin], ' Liq_out C = %.3f' % tray_concs[num_trays][Lout]
+            # print 'Vap_out C = %.3f' % tray_concs[num_trays][Vout], 'Liq_in C = %.3f' % tray_concs[num_trays][Lin]
+
+            # More trays to go...
+            num_trays = num_trays + 1
+            tray_concs.append([0., 0., 0., 0.])  # start populating next tray
+            tray_concs[num_trays][Lin] = tray_concs[num_trays - 1][Lout]  # Lin of next tray = Lout of current tray
+            tray_concs[num_trays][Vout] = tray_concs[num_trays - 1][Vin]  # Vout of next tray = Vin of current tray
+
+            # Check if number of trays has become impractical
+            if num_trays > 100:
+                raise Exception('Too many trays!')
+
+        # Solve for rectifier trays from inlet upwards
+        if tray_concs[1][Vout] < self.outlet_vap.c - 0.001:
+            num_trays = num_trays + 1
+            tray_concs[0][Lout] = tray_concs[1][Lin]  # Lin of next tray = Lout of current tray
+            tray_concs[0][Vin] = tray_concs[1][Vout]  # Vout of next tray = Vin of current tray
+        while tray_concs[1][Vout] < self.outlet_vap.c - 0.001:
+            # Move vertically upward based on operating line shift
+            y_sat_xshift = float(get_C_vap_sat(self.fluid, trays_x[0], self.P_col))
+            trays_y.insert(0, y_sat_xshift)
+            trays_x.insert(0, trays_x[0])
+
+            # Move horizontally with VLE calc
+            x_sat_horiz = float(get_C_liq_sat(self.fluid, trays_y[0] + shift, self.P_col))
+            trays_x.insert(0, x_sat_horiz + shift)
+            trays_y.insert(0, trays_y[0])
+
+            # Update tray concentrations
+            tray_concs[0][Lin] = trays_x[0]    # second value appended
+            tray_concs[0][Vout] = trays_y[0]   # first value appended
+
+            # Check whether there is an operating line directly below in anticipation of next vertical calc
+            if 1. - trays_x[0] <= shift or trays_y[0] > self.outlet_vap.c - 0.001:     # if so, can't have McCabe point there, done with trays
+                trays_x.remove(trays_x[0])   # Remove last McCabe point (VLE point from horiz. calc)
+                trays_y.remove(trays_y[0])
+                tray_concs[0][Lin] = 1.  # no liquid into top tray
+                tray_concs.insert(0, [0., 0., 0., 0.])  # I'm not sure why but Fiona had a blank tray at the beginning
+                break
+
+            # Check whether this tray overshot the target outlet liquid
+            elif trays_y[0] > self.outlet_vap.c - 0.001:   # below target outlet liquid conc, target reached
+                # Move vertically upward based on operating line shift to finish off final tray
+                num_trays = num_trays + 1
+                y_sat_xshift = float(get_C_vap_sat(self.fluid, trays_x[0], self.P_col))
+                trays_y.insert(0, y_sat_xshift)
+                trays_x.insert(0, trays_x[0])
+                tray_concs.insert(0, [0., 0., 0., 0.])    # populating last tray
+                tray_concs[0][Lin] = 1.                   # No liquid into top tray
+                tray_concs[0][Vout] = trays_y[1]          # Outlet vapor from this round of calcs
+                tray_concs[0][Lout] = tray_concs[1][Lin]  # Outputs liquid demanded by lower tray
+                tray_concs[0][Vin] = tray_concs[1][Vout]  # Input vapor from lower tray
+                break
+
+            # More trays to go...
+            num_trays = num_trays + 1
+            tray_concs.insert(0, [0., 0., 0., 0.])   # start populating next tray
+            tray_concs[0][Lout] = tray_concs[1][Lin]  # Lin of next tray = Lout of current tray
+            tray_concs[0][Vin] = tray_concs[1][Vout]  # Vout of next tray = Vin of current tray
+
+            # Check if number of trays has become impractical
+            if num_trays > 100:
+                raise Exception('Too many trays!')
+
+        # for tray_conc in tray_concs:
+        #     print tray_conc
+
+        # Find Q into each tray, starting from top tray
+        if printmode==True:
+            print('\nSOLVING FOR Q_SENS INTO EACH TRAY... \n')
+            print('(NOTE: Tray 1 is top-most tray)')
+        Q_sens = []
+        tray_temps = []
+
+        # Get starting masses
+        m_liq_in_i = Quantity(0., 'kg*s^-1')
+        self.bottoms.set_c(tray_concs[-1][Lout])
+        if not hasattr(self.outlet_vap, 'm'):
+            self.outlet_vap.set_m(self.inlet.m * (self.inlet.c - self.bottoms.c) / (self.outlet_vap.c - self.bottoms.c))  # mass balance
+        self.outlet_vap.set_p(self.P_col)
+        self.outlet_vap.set_x(1.)
+        m_vap_out_i = self.outlet_vap.m
+        self.bottoms.set_m(self.inlet.m - self.outlet_vap.m)
+        feed_tray = [tray_concs.index(t) for t in tray_concs if t[Lin]==self.inlet.c][0]
+
+        # Check whether inlet feed was subcooled, if so account for Q to bring it up to saturation
+        sat_inlet = Statepoint(fluid=self.fluid)
+        sat_inlet.set_c(self.inlet.c)
+        sat_inlet.set_p(self.P_col)
+        sat_inlet.set_x(0.)
+        # if sat_inlet.t != self.inlet.t:
+        # Account for Q to bring it up to saturation (small delta T at roomish temp, assume same cp)
+        Q_feed_to_satliq = self.inlet.m * self.inlet.cp * (sat_inlet.t - self.inlet.t)
+
+        if printmode==True:
+            print('sat_inlet.t =', sat_inlet.t)
+
+        # Keep track of mass flows in and out of trays
+        tray_masses = [[0., 0., 0., 0.], [0., 0., 0., 0.]]  # store concentrations (tray at 0 index will stay empty)
+        #num_trays = 1                                       # start by populating the top tray (tray_conc[1])
+
+        # COE and COM calculations to solve for Q
+        self.V = []
+        self.L = []
+        for i in range(1, num_trays + 1):
+            # Find enthalpies using Statepoint calcs
+            vap_in_i = Statepoint(fluid=self.fluid, p=self.P_col, x=1., c=float(tray_concs[i][Vin]))
+            vap_out_i = Statepoint(fluid=self.fluid, p=self.P_col, x=1., c=float(tray_concs[i][Vout]))
+            liq_in_i = Statepoint(fluid=self.fluid, p=self.P_col, x=0., c=float(tray_concs[i][Lin]))
+            liq_out_i = Statepoint(fluid=self.fluid, p=self.P_col, x=0., c=float(tray_concs[i][Lout]))
+
+            tray_temps.append(liq_out_i.t)  # liq_out and vap_out will both give tray temp
+
+            # Mass balance (methanol and total)
+            if i == feed_tray:
+                m_liq_in_i = m_liq_in_i + self.inlet.m
+            ##TODO: Figure out what the problem with the mass calc in the last step is
+            if i == num_trays:
+                m_liq_out_i = self.bottoms.m    # small errors become highly magnified at low concentrations
+            else:
+                m_liq_out_i = (m_liq_in_i * (vap_in_i.c - liq_in_i.c) + m_vap_out_i * (vap_out_i.c - vap_in_i.c)) / \
+                              (vap_in_i.c - liq_out_i.c)
+            m_vap_in_i = m_vap_out_i + m_liq_out_i - m_liq_in_i
+
+            liq_out_i.set_m(m_liq_out_i)
+            liq_in_i.set_m(m_liq_in_i)
+            vap_in_i.set_m(m_vap_in_i)
+            vap_out_i.set_m(m_vap_out_i)
+            self.V.append(vap_out_i)
+            self.L.append(liq_in_i)
+
+            # COE to get heat transfer required
+            Q_sens_i = m_vap_out_i * vap_out_i.h + m_liq_out_i * liq_out_i.h - m_vap_in_i * vap_in_i.h - m_liq_in_i * liq_in_i.h
+            Q_sens.append(Q_sens_i)
+            if printmode==True:
+                print('------------------Tray %.2G ------------------' % i)
+                print('Q_sens: %.2G kW' % Q_sens_i)
+                print('Vap C: %.3f' % vap_out_i.c, 'Vap M: %.4f kg/s' % m_vap_out_i, 'Vap T: %.2f C' % vap_out_i.t)
+                print('Liq C: %.3f' % liq_out_i.c, 'Liq M: %.4f kg/s' % m_liq_out_i, 'Liq T: %.2f C' % liq_out_i.t)
+
+            # Record mass flow rates for tray
+            tray_masses.append([0., 0., 0., 0.])  # start populating next tray
+            tray_masses[i][Lin] = m_liq_in_i   # Lin to the top tray
+            tray_masses[i][Vout] = m_vap_out_i  # Vout of the top tray
+            tray_masses[i][Lout] = m_liq_out_i  # Lout to the top tray
+            tray_masses[i][Vin] = m_vap_in_i    # Vin of the top tray
+
+            # Move down one tray
+            m_vap_out_i = m_vap_in_i
+            m_liq_in_i = m_liq_out_i
+
+        self.L.append(liq_out_i)    # add the final two statepoints to the output arrays
+        self.V.append(vap_in_i)
+
+        # for tray in tray_masses:
+        #     print tray
+
+        # Plot
+        if plotfile != None:
+            print('')
+            #plt.figure()                        # make McCabe-Thiele diagram
+            #plt.subplot(1, 1, 1)
+            #plt.plot(list(range(2)), list(range(2)))        # y = x line
+            #plt.plot(self.x_sat, self.y_sat)    # VLE line
+            #plt.plot(self.x_oper, self.y_oper)  # operational line
+            #plt.plot(trays_x, trays_y)          # McCabe Thiele points
+            #plt.xlim(0, 1)
+            #plt.xlabel('Liquid conc [kg/kg]')
+            #plt.ylim(0, 1)
+            #plt.ylabel('Vapor conc [kg/kg]')
+            #plt.savefig(plotfile)
+
+        if printmode==True:
+            print('\nSUMMARY')
+        self.num_trays = num_trays                                 # number of trays discrete trays
+        self.feed_tray = feed_tray
+        self.Q_feed_to_satliq = Q_feed_to_satliq                   # Q to bring inlet to saturation
+        self.Q_sens = Q_sens                                       # array of Q's to each tray (1st value = top tray)
+        self.Q_trays_total = sum(Q_sens)                           # total Q to trays
+        self.Q_trays_heat = sum(Q_sens[(feed_tray-1):])            # total heating requirement
+        self.Q_trays_cool = sum(Q_sens[:feed_tray-1])                # total cooling requirement
+        self.Q_total = self.Q_trays_total + self.Q_feed_to_satliq  # total Q to column
+        self.Q_input = self.Q_total
+        self.tray_temps = tray_temps                               # array of temps for each tray (1st value = top tray)
+        self.tray_concs = tray_concs                               # array of concentration arrays for each tray
+        self.tray_masses = tray_masses                             # array of mass flow arrays for each tray
+        if printmode==True:
+            print('Number of Trays =', num_trays)
+            print('Feed at tray ', feed_tray)
+            if self.bottoms.c > outlet_liq_c_max:
+                print('   NOTE: because of the solving method / operating line constraints, ')
+                print('   the outlet liquid vapor concentration is higher than %0.3f' % outlet_liq_c_max)
+                print('   Consider adding one more tray to the above number to be safe (%0.0f trays)' % (num_trays + 1))
+            print('Vapor outlet conc. =', self.outlet_vap.c)
+            print('Liquid outlet conc = %0.3f' % self.bottoms.c)
+            print('Q_feed_to_satliq =', self.Q_feed_to_satliq)
+            print('Q_trays_heat =', self.Q_trays_heat)
+            print('q_trays_cool =', self.Q_trays_cool)
+            print('Q_total =', self.Q_total)
+        self.trays_x = trays_x
+        self.trays_y = trays_y
+
+        # COM/COE check
+        COM = self.outlet_vap.m + self.bottoms.m - self.inlet.m
+        COE = (self.outlet_vap.m * self.outlet_vap.h) + (self.bottoms.m * self.bottoms.h) - (self.inlet.m * self.inlet.h) - self.Q_total
+        # print 'COM =', COM
+        # print 'COE =', COE
+
+
+    def off_design(self, heating_stream, n_trays, h_tray, d_col, htc, plotfile=None):
+        """
+        This model calculates the performance given both an inlet stream and a heating stream.
+        Most of the other models are set up to do design, meaning they output column specifications or heat requirements
+        This one, in contrast, just outputs performance based on a specified design parameters and inputs.
+
+        To do:
+
+        -It currently is set up for only a square column heating from the perimeter. We should make other options available
+        -Improve the solver speed. I think the best ways to do this would be to make the conc/mass convergence criteria adaptive and the heat transfer step size adaptive. A bigger but maybe better change would be to do something more complex than damped direct substitution.
+        -LMTD for the top tray is currently not accounting for the fact that the Q/T curve is significantly non-linear because that section has both sensible and latent heating. This should be fixed.
+        -Set up plotting again.
+        -Make outputs more useful.
+
+        :param heating_stream: A statepoint instance representing the heating fluid coming into the bottom of the column
+        :param n_trays: The number of trays [-]
+        :param h_tray: The height of a tray [m]
+        :param d_col: Width of the column [m]
+        :param htc: Heat transfer coefficient [kW/m^2-C]. I typically assume this is equal the HTC of the heating fluid.
+        :param plotfile: [string] name of png file to output a mccabe thiele style diagram. Plotting is not fully enabled right now
+        :return: Currently just prints all the outputs
+        """
+        print("===== Evaluating Problem Boundaries =====")
+        sp_all_vap = Statepoint(fluid=self.inlet.fluid, p=self.P_col, c=self.inlet.c, x=1., m=self.inlet.m)
+        print('Inlet fluid can absorb: ', self.inlet.m * (sp_all_vap.h - self.inlet.h))
+
+        sp_max_chilled = Statepoint(fluid=heating_stream.fluid, p=heating_stream.p, t=self.inlet.t, m=heating_stream.m)
+        print('Heating stream can supply: ', heating_stream.m * (heating_stream.h - sp_max_chilled.h))
+
+        print("\n===== Getting VLE =====")
+        vle_x = [x/100. for x in range(0, 101, 5)]
+        vle_y = [get_C_vap_sat(re.sub(r"\[|\]|[0-9]|\.", "", self.inlet.fluid), x, self.P_col) for x in vle_x]
+
+        print("\n===== Intializing guesses =====")
+        # Initialize heating fluid nodes
+        heating_streams = [Statepoint() for n in range(n_trays+1)]
+        heating_streams[-1] = heating_stream
+        for tray in range(n_trays-1, -1, -1):    #step through trays from bottom to top
+            heating_streams[tray].set_source(heating_streams[tray+1], ('fluid', 'm', 'p'))
+            heating_streams[tray].set_t(self.inlet.t + (heating_stream.t - self.inlet.t)*tray/n_trays)  # guess linear temp rise from top to bottom
+
+        print("\tUsing McCabe Thiele Model to Guess Performance")
+        """
+        This section uses the minimum exergy destruction mccabe theile model to get a decent starting point for
+        how the column will perform before doing physics-based calculations. The target outlet concentration is varied
+        until the number of trays is equal to the number of trays specified for this model.
+        """
+        self.num_trays = 0
+        vc_guess = get_C_vap_sat(self.fluid, self.inlet.c, self.P_col) - 0.05
+        # print vc_guess, self.num_trays
+        c_step = 0.02
+        last_step = 'none'
+        while self.num_trays != n_trays:        # Vary the outlet concentration until the number of trays is correct
+            self.outlet_vap = Statepoint(fluid=self.fluid, p=self.P_col, x=1., c=vc_guess)
+            self.outlet_liq_c = 0.01
+            try:
+                self.mccabe_diabatic(printmode=False)
+            except:
+                self.outlet_vap = Statepoint(fluid=self.fluid, p=self.P_col, x=1., c=vc_guess+0.001)    # doesnt always converge when # trays is near changing
+            if self.num_trays > n_trays:
+                if last_step == 'up':           # reduce the step size when its crossed past the solution
+                    c_step = c_step/2.
+                vc_guess = vc_guess - c_step
+                last_step = 'down'
+            elif self.num_trays < n_trays:
+                if last_step == 'down':
+                    c_step = c_step/2.
+                vc_guess = vc_guess + c_step
+                last_step = 'up'
+            print(vc_guess, self.num_trays)
+
+        Q = list(self.Q_sens)
+        V = list(self.V)
+        L = list(self.L)
+        for i in range(len(V)):
+            V[i].name = i
+            L[i].name = i
+
+        qres = 1.
+        first_loop = True
+        while qres > 0.001:     # Outer loop: solve for the heat transfer from the heating stream to the distilled fluid
+            clres = 1.
+            cvres = 1.
+            mlres = 1.
+            mvres = 1.
+            step = 1.
+            print('\nSolving mass balance: ')
+            print('Q: ', ['%.2f' % float(q) for q in Q], sum(Q))
+            while abs(clres) + abs(cvres) + abs(mlres) + abs(mvres) > 0.001:     # Solve for mass flows and concentrations at Qs
+                c_bottoms_last = L[-1].c    # save values to calculate residual
+                c_tops_last = V[0].c
+                m_bottoms_last = L[-1].m
+                m_tops_last = V[0].m
+
+                for v in reversed(V[:-2]):      # solve COE and check props to get vapor equilibria from bottom to top
+                    iv = v.name
+                    new_c = get_C_vap_sat(self.fluid, L[iv+1].c, self.P_col)                            # property definition
+                    h_vap_i1 = Statepoint(fluid=self.fluid, x=1, p=self.P_col, c=V[iv+1].c).h - Statepoint(fluid=self.fluid, x=0, p=self.P_col, c=V[iv+1].c).h    #TODO: switch this out of sum(m.h)?
+                    h_vap_i = Statepoint(fluid=self.fluid, x=1, p=self.P_col, c=new_c).h - Statepoint(fluid=self.fluid, x=0, p=self.P_col, c=new_c).h
+                    new_m = (Q[iv] + V[iv+1].m * h_vap_i1) / h_vap_i                                    # conservation of energy
+                    V[iv] = Statepoint(name=v.name, fluid=self.fluid, p=v.p, x=v.x, c=new_c, m=new_m)
+
+                for l in L[1:]:                 # solve mass balances to get liquid flow and conc from top to bottom
+                    il = l.name
+                    new_m = max(L[il-1].m + V[il].m -V[il-1].m, 1e-6)                                          # conservation of total mass
+                    new_c = (V[il].m * V[il].c + L[il-1].m * L[il-1].c - V[il-1].m * V[il-1].c) / L[il].m      # conservation of FPS mass
+                    new_c = max(new_c, 0.0001)
+                    new_c = L[il].c * (1.-step) + new_c * step
+                    L[il] = Statepoint(name=l.name, fluid=self.fluid, p=l.p, x=l.x, c=new_c, m=new_m)
+
+                if L[-1].m != 0. and mlres != 0.:   # I'm not really sure why but this was crashing sometimes without this check
+                    if (L[-1].m - m_bottoms_last) / L[-1].m / mlres < 0:
+                        step = step * 0.8
+
+                clres = (L[-1].c - c_bottoms_last) / L[-1].c
+                cvres = (V[0].c - c_tops_last) / V[0].c
+                mlres = (L[-1].m - m_bottoms_last) / L[-1].m
+                mvres = (V[0].m - m_tops_last) / V[0].m
+                sys.stdout.write('\rConc/mass residual: %f' % (abs(clres) + abs(cvres) + abs(mlres) + abs(mvres)))
+            print('\nL conc: ', ['%.3f' % l.c for l in L])
+            print('V conc: ', ['%.3f' % v.c for v in V])
+
+            print('Solving heat transfer: ', end=' ')
+            Q_last = list(Q)
+            for i in reversed(list(range(n_trays))):    # resolve heat transfer from bottom up
+                q_tray_res = 1.
+                while q_tray_res > 0.001:
+                    heating_streams[i] = Statepoint(source=heating_streams[i], source_vars=('fluid', 'm', 'p'))
+                    heating_streams[i].set_h(heating_streams[i+1].h - Q[i] / heating_streams[i+1].m)
+
+                    Q_i_last = Q[i]
+                    try:
+                        lmtdx = lmtd(heating_streams[i+1].t, heating_streams[i].t, L[i].t, L[i+1].t)
+                    except AssertionError:  # occurs when some steps have a temperature cross.
+                        lmtdx = 1.e-3
+                    A = 4. * h_tray * d_col
+                    Q[i] = htc * A * lmtdx
+
+                    q_tray_res = abs(Q[i] - Q_i_last) / Q[i]
+                print('.', end=' ')
+            print()
+            for i in range(n_trays):    # Property calls crashed because the Q changes were causing extreme swings in the concentrations
+                q_damp_factor = 0.9
+                Q[i] = Q[i] * (1. - q_damp_factor) + Q_last[i] * q_damp_factor  # damp the solver so the conc can keep up
+
+            qres = abs(sum(Q) - sum(Q_last)) / sum(Q)
+            if first_loop:      # don't let it converge on the first step because its just duplicating the design calcs
+                qres = 1
+                first_loop = False
+            print('Q residual: ', qres)
+
+            
+
+        print("\n===== Plotting =====")
+        # Plot
+        if plotfile != None:
+            #plt.figure()                        # make McCabe-Thiele diagram
+            #plt.subplot(1, 1, 1)
+            #plt.plot(list(range(2)), list(range(2)), color='gray')        # y = x line
+            #plt.plot(vle_x, vle_y, color='blue')    # VLE line
+            print(vle_x)
+            print(vle_y)
+            print()
+            # #plt.plot([tray.c_l_out for tray in trays], [tray.c_v_in for tray in trays])  # operational line
+            #plt.plot([l.c for l in L[1:]], [v.c for v in V[1:]], color='green')    # operational line
+            print([l.c for l in L[1:]])
+            print([v.c for v in V[1:]])
+            print()
+            trays_x = [L[0].c]
+            trays_y = [V[0].c, V[0].c]
+            for tray in range(n_trays)[1:]:
+                trays_x.append(L[tray].c)
+                trays_x.append(L[tray].c)
+                trays_y.append(V[tray].c)
+                trays_y.append(V[tray].c)
+            trays_x.append(L[-1].c)
+            print(trays_x)
+            print(trays_y)
+            #plt.plot(trays_x, trays_y, color='red')          # McCabe Thiele points
+            #plt.xlim(0, 1)
+            #plt.xlabel('Liquid conc [kg/kg]')
+            #plt.ylim(0, 1)
+            #plt.ylabel('Vapor conc [kg/kg]')
+            #plt.savefig(plotfile)
+
+
+
+    def tray(self,m_vap_in_guess, arg):
+        self.tray_outs = [None]*4
+        inlet_liq = arg[0]
+        outlet_vap = arg[1]
+        c_tray = arg[2]
+        Fluid = arg[3]
+        Q_sens = arg[4]
+        assert isinstance(inlet_liq, Statepoint), '\'inlet\' must be set to a Statepoint'
+        assert isinstance(outlet_vap, Statepoint), '\'inlet\' must be set to a Statepoint'
+
+        #this is the vapor coming from the tray below the current tray
+        inlet_vap = Statepoint(name='inlet_vap', fluid=Fluid)
+        inlet_vap.set_x(1.)
+        inlet_vap.set_p(self.P_col)
+
+        #this is the liquid in the current tray
+        outlet_liq = Statepoint(name='outlet_liq', fluid=Fluid)
+        outlet_liq.set_c(c_tray)
+        outlet_liq.set_x(0.)
+        outlet_liq.set_p(self.P_col)
+
+        count=0
+        tol=.002
+        stop=0
+        while stop <= 1 :
+            #update the vapor guess based on the new iteration
+            inlet_vap.set_m(m_vap_in_guess)
+            outlet_liq.set_m(inlet_vap.m - outlet_vap.m + inlet_liq.m)
+            inlet_vap.set_c((outlet_liq.m*outlet_liq.c + outlet_vap.m*outlet_vap.c - inlet_liq.m*inlet_liq.c)/inlet_vap.m)
+
+            #COE should be 0, so iterate c_guess until it is
+            m_vap_in_guess = (outlet_liq.m*outlet_liq.h-inlet_liq.m*inlet_liq.h + outlet_vap.m*outlet_vap.h - Q_sens)/ inlet_vap.h
+            m_vap_in_guess_old = m_vap_in_guess
+
+            COE = abs(float(inlet_liq.m*inlet_liq.h - outlet_liq.m*outlet_liq.h - outlet_vap.m*outlet_vap.h + inlet_vap.m*inlet_vap.h + Q_sens)/(inlet_liq.m*inlet_liq.h+inlet_vap.m*inlet_vap.h))
+            COM = abs(float(inlet_liq.m*inlet_liq.c + inlet_vap.m*inlet_vap.c - outlet_liq.m*outlet_liq.c - outlet_vap.m*outlet_vap.c)/(inlet_liq.m*inlet_liq.c + inlet_vap.m*inlet_vap.c)) + abs(float(inlet_liq.m + inlet_vap.m - outlet_liq.m - outlet_vap.m))/(inlet_liq.m + inlet_vap.m)
+            res = abs(COE)
+
+            count=count+1
+
+            if abs(res)<tol:
+                stop=stop+1
+            if count > 100:
+                warnings.warn('tray did not converge after 100 iteration')
+                raise Exception()
+
+        self.tray_outs =  [inlet_vap, outlet_liq, COE, COM]
+
+        #print
+        #print outlet_liq.m, outlet_vap.m, inlet_liq.m, inlet_vap.m
+        #print outlet_liq.c, outlet_vap.c, inlet_liq.c, inlet_vap.c
+
+
+    def get_trays(self):
+        assert isinstance(self.inlet, Statepoint), '\'inlet\' must be set to a Statepoint'
+        assert isinstance(self.outlet_vap, Statepoint), '\'outlet_vap\' must be set to a Statepoint'
+
+        tray_liq = [None]*1
+        tray_vap = [None]*1
+        self.tray_outs = [None]*4
+
+        self.bottoms = Statepoint(name='bottoms', fluid=self.fluid)
+        self.bottoms.set_p(self.P_col)
+        self.bottoms.set_x(0.)
+        self.bottoms.set_c(self.outlet_liq_c)
+        self.bottoms.set_m(self.inlet.m-self.outlet_vap.m)
+
+
+        c_first_tray = self.inlet.c
+
+        if c_first_tray > self.inlet.c:
+            warnings.warn('desired outlet vapor concetration is higher than inlet equilibrium vapor')
+            raise Exception()
+
+        tray_liq[0] = self.inlet
+        tray_vap[0] = 0.
+        tray_vap.append(self.outlet_vap)
+
+        Q_input_guess = self.outlet_vap.m*self.outlet_vap.h - self.inlet.m*self.inlet.h + self.bottoms.m*self.bottoms.h
+        i=1
+        liq_c = tray_liq[0].c
+        stop = 0
+        while stop==0:
+            #for these iterations i = the current tray
+
+            arg=[None]*1
+            arg[0] = tray_liq[i-1]  #last tray (i-1) liquid statepoint
+            arg.append(tray_vap[i]) #outlet vapor statepoint, this is the inlet vapor calculated in the tray above
+            arg.append(get_C_liq_sat(self.fluid,tray_vap[i].c,self.P_col)) #current tray (i) concentration
+            arg.append(self.fluid) #column fluid
+            arg.append(self.Q_sens) # sensible heat addition
+            m_guess = float(tray_vap[i].m)
+            self.tray(m_vap_in_guess=m_guess, arg=arg)
+
+            tray_vap.append(self.tray_outs[0])
+            tray_liq.append(self.tray_outs[1]) #this creates the i-1 tray's outlet vapor statepoint, IE, the inlet in the i tray
+            print('---------Tray %.2G Converged---------'%i)
+            print('COM:%.2G'%self.tray_outs[3], 'COE:%.2G'%self.tray_outs[2])
+            print('Vap C: %.3G'%tray_vap[i].c, 'Vap M: %.2G'%tray_vap[i].m, 'Vap T: %.3G'%tray_vap[i].t)
+            print('Liq C: %.3G'%tray_liq[i].c, 'Liq M: %.2G'%tray_liq[i].m, 'Liq T: %.3G'%tray_liq[i].t)
+
+            if tray_liq[i].c<self.outlet_liq_c:
+                stop = 1
+                self.Q_bottoms = tray_vap[i+1].m*(tray_vap[i+1].h-tray_liq[i].h)
+                self.bottoms.set_m(tray_liq[i].m - tray_vap[i+1].m)
+                self.bottoms.set_c((tray_liq[i].m*tray_liq[i].c - tray_vap[i+1].m*tray_vap[i+1].c)/self.bottoms.m)
+
+            i=i+1
+            if i > 50:
+                warnings.warn('column did not produce outlet condition within 50 trays')
+                raise Exception()
+
+        n_trays = i-1
+        self.Q_input = self.Q_bottoms + self.Q_sens*n_trays
+        self.Per_dia = (self.Q_sens*n_trays)/self.Q_input
+        self.COE_total = abs(tray_liq[0].m*tray_liq[0].h - tray_vap[1].m*tray_vap[1].h - self.bottoms.m*self.bottoms.h + self.Q_input)/self.Q_input
+
+
+        # solve flooding equations to get diameter for column
+        # pack_f = 693.0 #Cannon packing 0.16" [?m^2/m^3?]
+        # HETP = 36.0 #Cannon packing 0.16" [?mm?]
+        # pack_f = 92. # Raschig super rings 0.3 (assume same as kempack)
+        # HETP = 400. # Raschig super rings 0.3 (http://www.raschig-usa.com/Portals/0/RASCHIG%20SUPER-RING%200_3%20-%20FRI%20Test%20Results.pdf fig 1)
+        pack_f = 92. # Kempac 1" Tripack [m^2/m^3]
+        HETP = 142. # Kempac 1" Tripack [mm]
+        self.d_col = 0.1 #guess diameter
+        self.L_col = n_trays*HETP/1000.
+        mid_tray = int(round(n_trays/2,1))
+
+        er=2.
+        i=1
+        flood_target = 0.3 #flooding target based on Kister p493
+        while abs(er)>.01:
+            A_cross = self.d_col**2./4.*3.1415
+            G_vap = tray_vap[mid_tray].m*3600./A_cross
+            G_liq = tray_liq[mid_tray].m*3600./A_cross
+            rho_vap = tray_vap[mid_tray].rho
+            rho_liq = tray_liq[mid_tray].rho
+            X = G_liq/G_vap*(rho_vap/rho_liq)**(0.5)
+            Y = ((G_vap*0.205)/3600.)**2.0*pack_f*0.881/(32.2*(rho_vap*0.0624)*((rho_liq*0.0624)-(rho_vap*0.0624)))
+            Y_flood = 1.4427*X**2-1.0271*X+0.2312
+            per_flood = Y/Y_flood
+            er = (flood_target - per_flood)/flood_target
+            self.d_col = self.d_col*(1.-er/5.)
+            i=i+1
+            if i > 50:
+                warnings.warn('diameter of column did not converge withing 50 iterations')
+                raise Exception()
+        self.d_col = Property(float(self.d_col),'m')
+
+
+        #print "Gvap", G_vap, "Gliq", G_liq
+
+        self.n_trays = n_trays
+
+
+
+
+
+
+
+
+if __name__=='__main__':
+    #FPS = 'REFPROP-MIX:AMMONIA&WATER'
+    #FPS = 'REFPROP-MIX:ACETONE&WATER'
+    FPS = 'REFPROP-MIX:METHANOL&WATER'
+
+    P_col = Property(0.2,'bar')
+    liq = Statepoint(name='liq', fluid=FPS)
+    vap = Statepoint(name='vap', fluid=FPS)
+    liq.set_x(0.)
+    liq.set_c(.31)
+    liq.set_p(P_col)
+    liq.set_m(Property(0.074,'kg*s^-1'))
+
+    vap.set_x(1.)
+    vap.set_c(.84)
+    vap.set_p(liq.p)
+    # vap.set_m(liq.m*liq.c/vap.c)  # mass is overdefined, calculated in the functions
+
+    col = Column()
+    col.set_P_col(P_col)
+    col.set_inlet(liq)
+    col.set_Q_sens(1.2) #1.2
+    col.set_outlet_vap(vap)
+    col.set_outlet_liq_c(.01)
+    col.set_fluid(FPS)
+
+    col.ME_balance()
+    print(col.Q_input)
+    print(col.bottoms)
+    # print "Solving adiabatic McCabe Thiele"
+    # col.mccabe(plotfile='McCabeThieleDiagram')
+
+    # print "\n\nSolving COE/COM diabatic model"
+    # col.set_diabatic(0.1)
+    # step = 0.9
+    # count = 10
+    # col.get_trays()
+    # COM = col.bottoms.m + vap.m - liq.m
+
+    print('\n\nSolving McCabe Thiele diabatic model')
+    # col.set_outlet_vap(Statepoint(fluid=FPS, p=P_col, x=1., c=0.95))
+    col.mccabe_diabatic(shift=0.03, plotfile='McCabeThieleDiabatic')
+
+    # print "Diameter", col.d_col, "total Q", col.Q_input, "Diabatic", col.Per_dia
+    # print "COM:",COM, "bottoms mass flow:",col.bottoms.m