chromaquant 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

chromaquant/Quant/QuantSub/__init__.py

@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-ChromaQuant.Match.MatchSub package initialization
-
-Julia Hancock
-Created 10-19-2024
-
-"""
-
-from .parseTools import *
-from .liquidFID import *
-from .gasFID import *
-from .gasTCD import *

chromaquant/Quant/QuantSub/gasFID.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-COPYRIGHT STATEMENT:
-
-ChromaQuant – A quantification software for complex gas chromatographic data
-
-Copyright (c) 2024, by Julia Hancock
-              Affiliation: Dr. Julie Elaine Rorrer
-	      URL: https://www.rorrerlab.com/
-
-License: BSD 3-Clause License
-
----
-
-SUBPACKAGE FOR PERFORMING GAS FID QUANTIFICATION STEPS
-
-Julia Hancock
-Started 12-29-2024
-
-"""
-""" PACKAGES """
-import pandas as pd
-import numpy as np
-from chemformula import ChemFormula
-
-#Function for quantifying gas FID data w/ external standard
-def gasFID_ES(BreakdownDF,DBRF,Label_info,gasBag_cond,total_volume,cutoff=4):
-    """
-    Function quantifies gas FID data and returns a breakdown dataframe
-
-    Parameters
-    ----------
-    BreakdownDF : DataFrame
-        Dataframe containing columns associated with matched FID and MS peak data
-    DBRF : Dataframe
-        Dataframe containing nested dataframes with associated chemical lumps,
-        likely imported from an excel sheet where each sheet is specific to
-        a given chemical lump. The top-level keys must be associated with the
-        predefined chemical lumps given in 'LABELS' section above
-    gasBag_cond : List
-        List containing gas bag temperature [0] and gas bag pressure [1]
-    Label_info : List
-        List of dictionaries containing chemical lump and compound type abbreviations
-    total_volume : Float
-        Float describing the total amount of gas estimated by the external standard volume percent, mL
-    cutoff : Integer, optional
-        Integer representing the maximum cutoff carbon number that can be 
-        quantified using FID.The default is 4.
-
-    Returns
-    -------
-    BreakdownDF : DataFrame
-        Dataframe containing columns associated with matched FID and MS peak data
-
-    """
-    #Function for assigning response factors to compounds
-    def assignRF(BreakdownDF,DBRF):
-        
-        #Get a dictionary of average response factors by carbon number
-        avgRF = {}
-        #Loop through every carbon number up to the max in DBRF
-        for i in range(1,DBRF['Carbon Number'].max()+1):
-            #Get a slice of all rows in DBRF with a given carbon number
-            slicer = DBRF.loc[DBRF['Carbon Number']==i]
-            #Average the response factor entries in this slice, appending the result to the average RF dictionary
-            avgRF['{0}'.format(i)] = slicer['RF'].mean()
-            
-        #Loop through every row in the FIDpMS dataframe
-        for i, row in BreakdownDF.iterrows():
-            #Check that the formula is not nan
-            if not pd.isna(row['Formula']):
-                #Obtain a dictionary containing key:value pairs as element:count using the formula string for the ith row
-                chemFormDict = ChemFormula(row['Formula']).element
-                #Use the carbon entry from the above dictionary to assign a carbon number to the ith row
-                BreakdownDF.at[i,'Carbon Number'] = chemFormDict['C']
-            
-                #If the row's compound name exists in the RF list explicitly, assign the row to the appropriate RF
-                if row['Compound Name'] in DBRF['Compound Name'].values:
-                    BreakdownDF.at[i,'RF (Area/vol.%)'] = DBRF.loc[DBRF['Compound Name']==row['Compound Name'],'RF'].iloc[0]
-                    #Assign response factor source
-                    BreakdownDF.at[i,'RF Source'] = 'Direct RF assignment based on compound name'
-                #Otherwise, assign response factor based on average carbon number RF
-                else:
-                    BreakdownDF.at[i,'RF (Area/vol.%)'] = avgRF['{0}'.format(int(BreakdownDF.at[i,'Carbon Number']))]
-                    #Assign response factor source
-                    BreakdownDF.at[i,'RF Source'] = 'RF assignment based on average response factor for DBRF carbon number entries'
-            #Otherwise if the row's formula is nan, pass
-            else:
-                pass
-            
-            
-        return BreakdownDF
-    
-    #Function for quantifying compounds using ideal gas law
-    def gasQuant(BreakdownDF,DBRF,total_volume,cutoff):
-        
-        #Remove rows in BreakdownDF with a carbon number at or below cutoff
-        BreakdownDF = BreakdownDF.loc[BreakdownDF['Carbon Number'] > cutoff].copy()
-        
-        #Get gas bag conditions
-        temp = gasBag_cond[0]       #temperature of gas bag, C
-        pressure = gasBag_cond[1]   #sample pressure in gas bag, psi
-        
-        #Convert gas bag conditions to new units
-        temp = temp + 273.15                    #gas bag temperature, K
-        pressure = pressure / 14.504*100000     #gas bag pressure, Pa
-        total_volume /= 10**6                   #gas bag volume, m^3
-        #Define ideal gas constant, m^3*Pa/K*mol
-        R = 8.314
-        
-        #Loop through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #Add molecular weight using ChemFormula
-            BreakdownDF.at[i,'MW (g/mol)'] = ChemFormula(row['Formula']).formula_weight
-            
-            #Get volume percent using response factor
-            BreakdownDF.at[i,'Vol.%'] = row['FID Area']/row['RF (Area/vol.%)']
-            
-            #Get moles using ideal gas law (PV=nRT)
-            BreakdownDF.at[i,'Moles'] = BreakdownDF.at[i,'Vol.%']/100*total_volume*pressure/(temp*R)
-            
-            #Get mass (mg) using moles and molar mass
-            BreakdownDF.at[i,'Mass (mg)'] = BreakdownDF.at[i,'Moles'] * BreakdownDF.at[i,'MW (g/mol)'] * 1000
-            
-        return BreakdownDF
-    
-    #Function for further breaking down product distribution
-    def moreBreakdown(BreakdownDF,CT_dict):
-        """
-        This function prepares further breakdown dictionaries for use in exporting to Excel
-    
-        Parameters
-        ----------
-        BreakdownDF : DataFrame
-            Dataframe containing columns associated with matched FID and MS peak data.
-        CT_dict : Dict
-            Dictionary of all compound type abbreviations in use and their associated expansions
-            
-        Returns
-        -------
-        BreakdownDF : DataFrame
-            Dataframe containing columns associated with matched FID and MS peak data.
-    
-        """
-        
-        #Get the total mass of product from the breakdown dataframe
-        m_total = np.nansum(BreakdownDF['Mass (mg)'])
-        
-        #Iterate through every species in the breakdown dataframe and add entries in two new columns: Compound Type and Carbon Number
-        for i, row in BreakdownDF.iterrows():
-            #If there exists a formula..
-            try:
-                #Set breakdown compound type according to the abbreviation already in the breakdown dataframe
-                BreakdownDF.at[i,'Compound Type'] = CT_dict[BreakdownDF.at[i,'Compound Type Abbreviation']]
-                #Obtain a dictionary containing key:value pairs as element:count using the formula string for the ith row
-                chemFormDict = ChemFormula(row['Formula']).element
-                #Use the carbon entry from the above dictionary to assign a carbon number to the ith row
-                BreakdownDF.at[i,'Carbon Number'] = chemFormDict['C']
-            #Otherwise, pass
-            except:
-                pass
-        
-        #Get maximum carbon number in breakdown dataframe
-        CN_max = int(BreakdownDF['Carbon Number'].max())
-    
-        #Create a dataframe for saving quantitative results organized by compound type
-        CT_DF = pd.DataFrame({'Compound Type':['Aromatics','Linear Alkanes','Branched Alkanes',
-                                                    'Cycloalkanes','Alkenes/Alkynes','Other'],
-                                    'Mass (mg)':np.empty(6),
-                                    'Mass fraction':np.empty(6)})
-        
-        #Create a dataframe for saving quantitative results organized by carbon number
-        CN_DF = pd.DataFrame({'Carbon Number':range(1,CN_max+1,1),
-                                    'Mass (mg)':np.empty(CN_max)})
-        
-        #Create a dataframe for saving quantitative results organized by both compound type and carbon number
-        CTCN_DF = pd.DataFrame({'Aromatics': pd.Series(np.empty(CN_max),index=range(CN_max)),
-                                'Linear Alkanes': pd.Series(np.empty(CN_max),index=range(CN_max)),
-                                'Branched Alkanes':pd.Series(np.empty(CN_max),index=range(CN_max)),
-                                'Cycloalkanes':pd.Series(np.empty(CN_max),index=range(CN_max)),
-                                'Alkenes/Alkynes':pd.Series(np.empty(CN_max),index=range(CN_max)),
-                                'Other':pd.Series(np.empty(CN_max),index=range(CN_max))})
-        
-        #Iterate through every compound type in the compound type dataframe, summing the total respective masses from the breakdown dataframe
-        for i, row in CT_DF.iterrows():
-            
-            #Define a temporary dataframe which contains all rows matching the ith compound type
-            tempDF = BreakdownDF.loc[BreakdownDF['Compound Type'] == row['Compound Type']]
-            #Assign the ith compound type's mass as the sum of the temporary dataframe's m_i column, treating nan as zero
-            CT_DF.at[i,'Mass (mg)'] = np.nansum(tempDF['Mass (mg)'])
-            #Calculate and assign the ith compound type's mass fraction usingthe total mass from earlier
-            CT_DF.at[i,'Mass fraction'] = CT_DF.at[i,'Mass (mg)']/m_total
-        
-        #Iterate through every carbon number in the carbon number dataframe, summing the total respective masses from the breakdown dataframe
-        for i, row in CN_DF.iterrows():
-            
-            #Define a temporary dataframe which contains all rows matching the ith carbon number
-            tempDF = BreakdownDF.loc[BreakdownDF['Carbon Number'] == row['Carbon Number']]
-            #Assign the ith carbon number's mass as the sum of the temporary dataframe's m_i column, treating nan as zero
-            CN_DF.at[i,'Mass (mg)'] = np.nansum(tempDF['Mass (mg)'])
-        
-        #Iterate through the entire dataframe, getting masses for every compound type - carbon number pair
-        for i, row in CTCN_DF.iterrows():
-            
-            #For every entry in row
-            for j in row.index:
-                
-                #Define a temporary dataframe which contains all rows matching the ith carbon number and compound type
-                tempDF = BreakdownDF.loc[(BreakdownDF['Carbon Number'] == i+1) & (BreakdownDF['Compound Type'] == j)]
-                #Assign the ith carbon number/jth compound type's mass as the sum of the temporary dataframe's m_i column, treating nan as zero
-                CTCN_DF.loc[i,j] = np.nansum(tempDF['Mass (mg)'])
-                
-                
-        #Get total masses from CT, CN, and CTCN dataframes
-        CT_mass = np.nansum(CT_DF['Mass (mg)'])
-        CN_mass = np.nansum(CN_DF['Mass (mg)'])
-        CTCN_mass = np.nansum(CTCN_DF)
-        
-        #Create total mass dataframe
-        mass_DF = pd.DataFrame({'Total mass source':['Overall breakdown','Compound Type Breakdown','Carbon Number Breakdown','Compound Type + Carbon Number Breakdown'],'Mass (mg)':[m_total,CT_mass,CN_mass,CTCN_mass]})
-        
-        return BreakdownDF, CT_DF, CN_DF, CTCN_DF, mass_DF
-    
-    #Unpack compound type and carbon number dictionaries from list
-    CL_Dict, CT_Dict = Label_info
-    
-    #Filter dataframe to remove compounds that do not contain carbon
-    BreakdownDF = BreakdownDF.drop(BreakdownDF[[not i for i in BreakdownDF['Formula'].str.contains('C')]].index)
-    #Reset the dataframe index
-    BreakdownDF.reset_index()
-    
-    #Run response factor assignment function
-    BreakdownDF = assignRF(BreakdownDF, DBRF)
-    #Run gas quantification function
-    BreakdownDF = gasQuant(BreakdownDF,DBRF,total_volume,cutoff)
-    #Run further breakdown function
-    BreakdownDF, CT_DF, CN_DF, CTCN_DF, mass_DF = moreBreakdown(BreakdownDF, CT_Dict)
-    
-    return BreakdownDF, CT_DF, CN_DF, CTCN_DF, mass_DF

chromaquant/Quant/QuantSub/gasTCD.py

@@ -1,425 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-COPYRIGHT STATEMENT:
-
-ChromaQuant – A quantification software for complex gas chromatographic data
-
-Copyright (c) 2024, by Julia Hancock
-              Affiliation: Dr. Julie Elaine Rorrer
-	      URL: https://www.rorrerlab.com/
-
-License: BSD 3-Clause License
-
----
-
-SUBPACKAGE FOR PERFORMING GAS TCD QUANTIFICATION STEPS
-
-Julia Hancock
-Started 12-29-2024
-
-"""
-""" PACKAGES """
-from chemformula import ChemFormula
-
-#Function for quantifying gas TCD data w/ volume estimation method, no pressure adjustment
-def gasTCD_VE(BreakdownDF,DBRF,gasBag_cond,peak_error):
-    
-    #Unpack gas bag conditions
-    temp = gasBag_cond[0]       #temperature of gas bag, C
-    pressure = gasBag_cond[1]   #sample pressure in gas bag, psi
-    co2 = gasBag_cond[2]        #CO2 volume, mL
-
-    #Initialize compound name column in BreakdownDF
-    BreakdownDF['Compound Name'] = 'None'
-    
-    #Function to find if CO2 peak exists
-    def getCO2(BreakdownDF,DBRF,TCD_cond,peak_error):
-        
-        #Unpack TCD conditions
-        co2 = TCD_cond[0]
-        pressure = TCD_cond[1]
-        temp = TCD_cond[2]
-        R = TCD_cond[3]
-        
-        #Find the CO2 peak row in DBRF
-        CO2_row = DBRF.loc[DBRF['Compound Name'] == "Carbon Dioxide"].iloc[0]
-        
-        #Get the retention time
-        CO2_RT = CO2_row['RT (min)']
-        
-        #Get the minimum and maximum of the RT range using the peak error
-        CO2_RTmin = CO2_RT - peak_error
-        CO2_RTmax = CO2_RT + peak_error
-        
-        #Define boolean describing whether or not CO2 match has been found
-        CO2_bool = False
-        #Define volume estimate
-        volume = 0
-        
-        #Iterate through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #If the TCD retention time is within range of the CO2 entry...
-            if CO2_RTmin <= row['RT'] <= CO2_RTmax:
-                
-                #Add the compound name to the breakdown dataframe
-                BreakdownDF.at[i,'Compound Name'] = 'Carbon Dioxide'
-                
-                #Add the other relevant information to the breakdown dataframe
-                BreakdownDF.at[i,'Formula'] = 'CO2'
-                BreakdownDF.at[i,'RF (Area/vol.%)'] = CO2_row['RF']
-                BreakdownDF.at[i,'MW (g/mol)'] = ChemFormula('CO2').formula_weight
-                
-                #Get volume percent using response factor
-                volpercent = row['Area']/CO2_row['RF']
-                BreakdownDF.at[i,'Vol.%'] = volpercent
-                
-                #Calculate total volume using volume percent
-                volume = co2 * 100 / volpercent   #total volume, m^3
-                
-                #Assign CO2 volume
-                BreakdownDF.at[i,'Volume (m^3)'] = co2
-                
-                #Get moles using ideal gas law (PV=nRT)
-                BreakdownDF.at[i,'Moles (mol)'] = co2*pressure/(temp*R)
-                
-                #Get mass (mg) using moles and molar mass
-                BreakdownDF.at[i,'Mass (mg)'] = BreakdownDF.at[i,'Moles (mol)'] * BreakdownDF.at[i,'MW (g/mol)'] * 1000
-                
-                #Set CO2_bool to True
-                CO2_bool = True
-                
-                break
-            
-            #Otherwise, pass
-            else:
-                pass
-        
-        return CO2_bool, volume, BreakdownDF
-    
-    #Add min and max peak assignment values to DBRF
-    for i, row in DBRF.iterrows():
-        DBRF.at[i,'RT Max'] = DBRF.at[i,'RT (min)'] + peak_error
-        DBRF.at[i,'RT Min'] = DBRF.at[i,'RT (min)'] - peak_error
-    
-    #Convert sinfo variables to new units
-    co2 = co2 / 10**6                     #volume injected CO2, m^3
-    temp = temp + 273.15                  #reactor temperature, K
-    pressure = pressure / 14.504*100000   #reactor pressure, Pa
-    
-    #Define ideal gas constant, m^3*Pa/K*mol
-    R = 8.314
-    
-    #Define variable to total volume (m^3)
-    V_TC = 0
-    
-    #Define list of conditions
-    TCD_cond = [co2,pressure,temp,R]
-    
-    #Check if there is a peak in the BreakdownDF that can be assigned to CO2
-    CO2_bool, V_TC, BreakdownDF = getCO2(BreakdownDF,DBRF,TCD_cond,peak_error)
-    
-    if CO2_bool:
-        #Iterate through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #Iterate through every row in DBRF
-            for i2, row2 in DBRF.iterrows():
-                
-                #If the TCD retention time is within the range for a given DBRF entry...
-                if row2['RT Min'] <= row['RT'] <= row2['RT Max']:
-                    
-                    #Add the compound name to the breakdown dataframe
-                    BreakdownDF.at[i,'Compound Name'] = row2['Compound Name']
-                    
-                    #Add the other relevant information to the breakdown dataframe
-                    BreakdownDF.at[i,'Formula'] = row2['Formula']
-                    BreakdownDF.at[i,'RF (Area/vol.%)'] = row2['RF']
-                    BreakdownDF.at[i,'MW (g/mol)'] = ChemFormula(row2['Formula']).formula_weight
-                    
-                    #Get volume percent using response factor
-                    volpercent = row['Area']/row2['RF']
-                    BreakdownDF.at[i,'Vol.%'] = volpercent
-                    
-                    #Get volume using volume percent
-                    vol = V_TC*volpercent/100
-                    BreakdownDF.at[i,'Volume (m^3)'] = vol
-                    
-                    #Get moles using ideal gas law (PV=nRT)
-                    BreakdownDF.at[i,'Moles (mol)'] = vol*pressure/(temp*R)
-                    
-                    #Get mass (mg) using moles and molar mass
-                    BreakdownDF.at[i,'Mass (mg)'] = BreakdownDF.at[i,'Moles (mol)'] * BreakdownDF.at[i,'MW (g/mol)'] * 1000
-                
-                #Otherwise, pass    
-                else:
-                    pass
-    #Otherwise, pass
-    else:
-        pass
-    
-    #Convert total volume to mL
-    V_TC *= 10**6
-
-    return BreakdownDF, V_TC
-
-#Function for quantifying gas TCD data w/ scale factor method
-def gasTCD_SF(BreakdownDF,DBRF,gasBag_cond,reactor_cond,peak_error):
-    
-    #Initialize compound name column in BreakdownDF
-    BreakdownDF['Compound Name'] = 'None'
-    
-    #Function to determine total volume using ideal gas law
-    def volumeIGL(V_C,reactor_cond):
-
-        #Unpack reactor conditions
-        P_f = reactor_cond[0]       #reactor quench pressure, psig
-        V_R = reactor_cond[1]       #reactor internal volume, mL
-        P_0 = reactor_cond[2]       #atmospheric pressure, psi
-
-        #Estimate total volume of gas bag, mL
-        V_T = V_R * (P_f + P_0) / P_0
-
-        #Estimate total volume of gas bag plus volume CO2, mL
-        V_TC = V_T + V_C
-
-        return V_T, V_TC
-
-    # Function to estimate scale factor from CO2
-    def getScaleFactor(BreakdownDF,DBRF,V_C,V_TC):
-
-        #Find the CO2 peak row in DBRF
-        CO2_row = DBRF.loc[DBRF['Compound Name'] == "Carbon Dioxide"].iloc[0]
-        
-        #Get the retention time
-        CO2_RT = CO2_row['RT (min)']
-        
-        #Get the minimum and maximum of the RT range using the peak error
-        CO2_RTmin = CO2_RT - peak_error
-        CO2_RTmax = CO2_RT + peak_error
-        
-        #Define boolean describing whether or not CO2 match has been found
-        CO2_bool = False
-
-        #Iterate through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #If the TCD retention time is within range of the CO2 entry...
-            if CO2_RTmin <= row['RT'] <= CO2_RTmax:
-                
-                #Get estimated volume fraction of CO2
-                psiCO2_e = row['Area'] / (100 * CO2_row['RF'])
-
-                #Get actual volume fraction of CO2
-                psiCO2_a = V_C / V_TC
-
-                #Define scale factor as ratio of actual volume fraction to estimated volume fraction
-                SF = psiCO2_a / psiCO2_e
-
-                #Set CO2_bool to True
-                CO2_bool = True
-                
-                break
-            
-            #Otherwise, pass
-            else:
-                pass
-
-        #Raise error if no CO2 peak found
-        if CO2_bool == False:
-            raise Exception("[gasTCD][ERROR] No CO2 peak found in TCD")
-
-        else:
-            pass
-
-        return SF
-
-    #Function to calculate amounts of each species using the scale factor
-    def quantTCD(BreakdownDF,DBRF,gasBag_cond,reactor_cond):
-
-        # Unpack gas bag conditions
-        GB_temp = gasBag_cond[0]       # Temperature of gas bag, C
-        GB_pressure = gasBag_cond[1]   # Sample pressure in gas bag, psig
-        V_C = gasBag_cond[2]           # CO2 volume, mL
-
-        # Get total and total+CO2 gas bag volumes
-        V_T, V_TC = volumeIGL(V_C,reactor_cond)
-
-        # Define ideal gas constant, m^3*Pa/K*mol
-        R = 8.314
-
-        #Define conversion factor, Pa * m^3 * psi^-1 * mL^-1
-        C = 0.00689476
-
-        #Get scale factor
-        SF = getScaleFactor(BreakdownDF,DBRF,V_C,V_TC)
-
-        #Add min and max peak assignment values to DBRF
-        for i, row in DBRF.iterrows():
-            DBRF.at[i,'RT Max'] = DBRF.at[i,'RT (min)'] + peak_error
-            DBRF.at[i,'RT Min'] = DBRF.at[i,'RT (min)'] - peak_error
-
-        #Iterate through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #Iterate through every row in DBRF
-            for i2, row2 in DBRF.iterrows():
-                
-                #If the TCD retention time is within the range for a given DBRF entry...
-                if row2['RT Min'] <= row['RT'] <= row2['RT Max']:
-                    
-                    #Add the compound name to the breakdown dataframe
-                    BreakdownDF.at[i,'Compound Name'] = row2['Compound Name']
-                    
-                    #Add the other relevant information to the breakdown dataframe
-                    BreakdownDF.at[i,'Formula'] = row2['Formula']
-                    BreakdownDF.at[i,'RF (Area/vol.%)'] = row2['RF']
-                    BreakdownDF.at[i,'MW (g/mol)'] = ChemFormula(row2['Formula']).formula_weight
-                    
-                    #Get estimated volume percent using response factor
-                    volpercent_e = row['Area']/row2['RF']
-                    BreakdownDF.at[i,'Est. Vol.%'] = volpercent_e
-
-                    #Get adjusted volume percent using scale factor
-                    volpercent_a = volpercent_e * SF
-                    BreakdownDF.at[i,'Adj. Vol.%'] = volpercent_a
-                    
-                    #Get moles using ideal gas law (PV=nRT)
-                    BreakdownDF.at[i,'Moles (mol)'] = C * (GB_pressure * volpercent_a / 100 * V_TC)/(R * (GB_temp + 273.15))
-                    
-                    #Get mass (mg) using moles and molar mass
-                    BreakdownDF.at[i,'Mass (mg)'] = BreakdownDF.at[i,'Moles (mol)'] * BreakdownDF.at[i,'MW (g/mol)'] * 1000
-                
-                #Otherwise, pass    
-                else:
-                    pass
-        
-        return BreakdownDF, V_TC, SF
-    
-    BreakdownDF, V_TC, SF = quantTCD(BreakdownDF,DBRF,gasBag_cond,reactor_cond)
-    
-    return BreakdownDF, V_TC, SF
-
-#Function for quantifying gas TCD data w/ internal standard method
-def gasTCD_IS(BreakdownDF,DBRF,gasBag_cond,reactor_cond,peak_error):
-    
-    #Initialize compound name column in BreakdownDF
-    BreakdownDF['Compound Name'] = 'None'
-
-    #Define molar mass of CO2, g/mol
-    Mc = 44.009
-
-    # Function to estimate mass of CO2 from provided conditions and get area of CO2
-    def massCO2(BreakdownDF,DBRF,R,C,V_C,P_0,GB_temp):
-
-        #Find the CO2 peak row in DBRF
-        CO2_row = DBRF.loc[DBRF['Compound Name'] == "Carbon Dioxide"].iloc[0]
-        
-        #Get the retention time
-        CO2_RT = CO2_row['RT (min)']
-        
-        #Get the minimum and maximum of the RT range using the peak error
-        CO2_RTmin = CO2_RT - peak_error
-        CO2_RTmax = CO2_RT + peak_error
-        
-        #Define boolean describing whether or not CO2 match has been found
-        CO2_bool = False
-
-        #Iterate through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #If the TCD retention time is within range of the CO2 entry...
-            if CO2_RTmin <= row['RT'] <= CO2_RTmax:
-                
-                #Get mass of CO2, mg
-                mc = C * Mc * (P_0 * V_C) / (R * (GB_temp + 273.15)) * 1000
-
-                #Get area of CO2
-                Ac = row['Area']
-
-                #Set CO2_bool to True
-                CO2_bool = True
-                
-                break
-            
-            #Otherwise, pass
-            else:
-                pass
-
-        #Raise error if no CO2 peak found
-        if CO2_bool == False:
-            raise Exception("[gasTCD][ERROR] No CO2 peak found in TCD")
-
-        else:
-            pass
-
-        return mc, Ac
-
-    #Function to calculate amounts of each species using the scale factor
-    def quantTCD(BreakdownDF,DBRF,gasBag_cond,reactor_cond):
-
-        # Unpack gas bag conditions
-        GB_temp = gasBag_cond[0]       # Temperature of gas bag, C
-        GB_pressure = gasBag_cond[1]   # Sample pressure in gas bag, psig
-        V_C = gasBag_cond[2]           # CO2 volume, mL
-
-        #Unpack reactor conditions
-        P_f = reactor_cond[0]       #reactor quench pressure, psig
-        V_R = reactor_cond[1]       #reactor internal volume, mL
-        P_0 = reactor_cond[2]       #atmospheric pressure, psi
-
-        # Define ideal gas constant, m^3*Pa/K*mol
-        R = 8.314
-
-        #Define conversion factor, Pa * m^3 * psi^-1 * mL^-1
-        C = 0.00689476
-
-        #Get mass of CO2
-        mc, Ac = massCO2(BreakdownDF,DBRF,R,C,V_C,P_0,GB_temp)
-
-        #Get total volume plus CO2
-        V_T = V_R * (P_f + P_0) / P_0
-        V_TC = V_T + V_C
-        print(V_TC)
-        #Add min and max peak assignment values to DBRF
-        for i, row in DBRF.iterrows():
-            DBRF.at[i,'RT Max'] = DBRF.at[i,'RT (min)'] + peak_error
-            DBRF.at[i,'RT Min'] = DBRF.at[i,'RT (min)'] - peak_error
-
-        #Iterate through every row in BreakdownDF
-        for i, row in BreakdownDF.iterrows():
-            
-            #Iterate through every row in DBRF
-            for i2, row2 in DBRF.iterrows():
-                
-                #If the TCD retention time is within the range for a given DBRF entry...
-                if row2['RT Min'] <= row['RT'] <= row2['RT Max']:
-                    
-                    #Add the compound name to the breakdown dataframe
-                    BreakdownDF.at[i,'Compound Name'] = row2['Compound Name']
-                    
-                    #Add the other relevant information to the breakdown dataframe
-                    BreakdownDF.at[i,'Formula'] = row2['Formula']
-                    BreakdownDF.at[i,'RF'] = row2['RF']
-                    BreakdownDF.at[i,'MW (g/mol)'] = ChemFormula(row2['Formula']).formula_weight
-                    
-                    #If the peak is CO2...
-                    if row['Compound Name'] == "Carbon Dioxide":
-                        #Set mass to mc
-                        BreakdownDF.at[i,'Mass(mg)'] = mc
-                    
-                    #Otherwise...
-                    else:
-                        #Get mass (mg) using mass of carbon dioxide and response factor
-                        BreakdownDF.at[i,'Mass (mg)'] = (mc * (BreakdownDF.at[i,'Area'] / Ac)) / BreakdownDF.at[i,'RF']
-                
-                #Otherwise, pass    
-                else:
-                    pass
-        
-        return BreakdownDF, V_TC
-    
-    BreakdownDF, V_TC = quantTCD(BreakdownDF,DBRF,gasBag_cond,reactor_cond)
-    
-    return BreakdownDF, V_TC