diff --git a/.gitignore b/.gitignore
index 66bd3a4..3b42279 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,6 @@ target/
 *Theta45
 *checkpoint.ipynb
 *.png
+
+# ignores added by Lia
+*.hdf5
\ No newline at end of file
diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
new file mode 100644
index 0000000..642fef4
--- /dev/null
+++ b/gas_opac/opacity_demo.py
@@ -0,0 +1,458 @@
+# Demostrates how to open the opacity database and interpolate to a given P, T, and wavelength grid
+# Author: Ryan J. MacDonald - 8th November, 2018
+
+import numpy as np
+import h5py
+from scipy.ndimage import gaussian_filter1d as gauss_conv
+from numba.decorators import jit
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+
+#***** Begin function declarations *****# 
+
+@jit(nopython = True)
+def prior_index(vec, value, start):
+    
+    '''Finds the index of a grid closest to a specified value'''
+    
+    value_tmp = value
+    
+    if (value_tmp > vec[-1]):
+        return (len(vec) - 1)
+    
+    # Check if value out of bounds, if so set to edge value
+    if (value_tmp < vec[0]): value_tmp = vec[0]
+    if (value_tmp > vec[-2]): value_tmp = vec[-2]
+    
+    index = start
+    
+    for i in range(len(vec)-start):
+        if (vec[i+start] > value_tmp): 
+            index = (i+start) - 1
+            break
+            
+    return index
+
+@jit(nopython=True)
+def prior_index_V2(val, grid_start, grid_end, N_grid):
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        return int(i)
+
+@jit(nopython=True)
+def closest_index(val, grid_start, grid_end, N_grid):
+    
+    '''Finds the index of a UNIFORM grid closest to a specified value.
+    
+       Assuming a uniform grid dramatically speeds calculation'''
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        if ((i%1)<=0.5):
+            return int(i)
+        else:
+            return int(i)+1
+                        
+@jit(nopython = True)
+def P_interpolate_wl_initialise(N_T, N_P, N_wl, log_sigma,
+                                nu_l, nu_model, nu_r, nu_opac, N_nu,
+                                x, b1, b2, mode):
+    
+    '''Interpolates raw cross sections onto the model P and wl grid.
+       
+       Note: input sigma has format log10(cross_sec)[log(P)_grid, T_grid, nu_grid], 
+             whilst output has format cross_sec[T, wl_model]
+             
+       The input is in wavenumnber to take advantage of fast prior index location 
+       on a uniform grid, which wouldn't work for the (non-uniform) wavelength grid
+       Array reversal to output in increasing wavelength is handled by indexing
+       by a factor of (N_wl-1)-k throughout 
+    '''
+    
+    sigma_pre_inp = np.zeros(shape=(N_T, N_wl))
+    
+    N_nu_opac = len(nu_opac)   # Number of wavenumber points in sigma array
+    
+    for k in range(N_nu): # Note that the k here is looping over wavenumber
+        
+        # Indicies in pre-computed wavenumber array of LHS, centre, and RHS of desired wavenumber grid
+        z_l = closest_index(nu_l[k], nu_opac[0], nu_opac[-1], N_nu_opac)
+        z = closest_index(nu_model[k], nu_opac[0], nu_opac[-1], N_nu_opac)
+        z_r = closest_index(nu_r[k], nu_opac[0], nu_opac[-1], N_nu_opac)
+        
+        for j in range(N_T):
+            
+            # If nu (wl) point out of range of opacity grid, set opacity to zero
+            if ((z == 0) or (z == (N_nu_opac-1))):
+                sigma_pre_inp[j, ((N_wl-1)-k)] = 0.0
+                
+            else:
+                            
+                # Opacity sampling
+                if (mode == 1):
+                    
+                    # If pressure below minimum, set to value at min pressure
+                    if (x == -1):
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (log_sigma[0, j, z])
+                            
+                    # If pressure above maximum, set to value at max pressure
+                    elif (x == -2):
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (log_sigma[(N_P-1), j, z])
+            
+                    # Interpolate sigma in logsace, then power to get interp array
+                    else:
+                        reduced_sigma = log_sigma[x:x+2, j, z]
+                            
+                        sigma_pre_inp[j, ((N_wl-1)-k)] =  10 ** (b1*(reduced_sigma[0]) +
+                                                                 b2*(reduced_sigma[1]))
+                            
+                # Log averaging
+                elif (mode == 2):
+                    
+                    # If pressure below minimum, set to value at min pressure
+                    if (x == -1):
+                        sigma_in_bin = np.mean(log_sigma[0, j, z_l:z_r+1])
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+                            
+                    # If pressure above maximum, set to value at max pressure
+                    elif (x == -2):
+                        sigma_in_bin = np.mean(log_sigma[(N_P-1), j, z_l:z_r+1])
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+        
+                    # Interpolate sigma in logsace, then power to get interp array
+                    else:
+                        sigma_in_bin_P1 = np.mean(log_sigma[x, j, z_l:z_r+1])
+                        sigma_in_bin_P2 = np.mean(log_sigma[x+1, j, z_l:z_r+1])
+                        
+                        sigma_pre_inp[j, ((N_wl-1)-k)] =  10 ** (b1*(sigma_in_bin_P1) +
+                                                                 b2*(sigma_in_bin_P2))
+                                                
+    return sigma_pre_inp
+
+@jit(nopython = True)
+def T_interpolation_init(T_grid, T):
+    
+    y = 0  # Index in cross secion arrays prior to fine temperature value
+        
+    if (T < T_grid[0]):   # If temperature falls off LHS of temperaure grid
+        y = -1            # Special value (-1) stored, interpreted in interpolator
+        w_T = 0.0         # Weight not used in this case
+            
+    elif (T >= T_grid[-1]):   # If temperature falls off RHS of temperaure grid
+        y = -2                # Special value (-2) stored, interpreted in interpolator
+        w_T = 0.0             # Weight not used in this case
+        
+    else:
+            
+        # Have to use prior_index (V1) here as T_grid is not uniformly spaced
+        y = prior_index(T_grid, T, 0)      # Index in cross secion arrays prior to desired temperature value
+            
+        # Pre-computed temperature values to left and right of desired temperature value
+        T1 = T_grid[y]
+        T2 = T_grid[y+1]
+            
+        # Precompute temperature interpolation weight factor
+        w_T = (1.0/((1.0/T2) - (1.0/T1)))
+  
+    return y, w_T
+
+@jit(nopython = True)
+def T_interpolate(N_T, N_wl, sigma_pre_inp, T_grid, T, y, w_T):
+    
+    sigma_inp = np.zeros(shape=(N_wl))
+            
+    T1 = T_grid[y]
+    T2 = T_grid[y+1]
+            
+    for k in range(N_wl):   # Loop over wavelengths
+                
+        # If T_fine below min value (100 K), set sigma to value at min T
+        if (y == -1):
+            sigma_inp[k] = sigma_pre_inp[0, k]
+                    
+        # If T_fine above max value (3500 K), set sigma to value at max T
+        elif (y == -2):
+            sigma_inp[k] = sigma_pre_inp[(N_T-1), k]
+            
+        # Interpolate sigma to fine temperature grid value
+        else: 
+            sig_reduced = sigma_pre_inp[y:y+2, k]
+            sig_1, sig_2 = sig_reduced[0], sig_reduced[1]    # sigma(T1)[i,k], sigma(T2)[i,k]
+                    
+            sigma_inp[k] =  (np.power(sig_1, (w_T*((1.0/T2) - (1.0/T)))) *
+                             np.power(sig_2, (w_T*((1.0/T) - (1.0/T1)))))
+            
+    return sigma_inp
+
+
+## Written by Lia
+## To separate out reading step
+def load_db(filename='./Opacity_database_0.01cm-1.hdf5'):
+
+    print("Reading opacity database file")
+    opac_file = h5py.File(filename, 'r')
+
+    #***** Read in T and P grids used in opacity files*****#
+    T_grid = np.array(opac_file['H2O/T'])            # H2O here simply used as dummy (same grid for all molecules)
+    log_P_grid = np.array(opac_file['H2O/log(P)'])   # Units: log10(P/bar)!
+    
+    #***** Read in wavenumber arrays used in opacity files*****#
+    nu_opac = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
+
+    return T_grid, log_P_grid, nu_opac, opac_file
+
+
+# Algorithm for loading cross-sections from one pressure and temperature
+# from cross-section table of a single species (log_sigma)
+def _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac, 
+                new_P, new_T, wl_out, opacity_treatment):
+    
+    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
+    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
+
+    N_P = len(log_P_grid)              # No. of pressures in opacity files
+    N_T = len(T_grid)                  # No. of temperatures in opacity files
+
+    # Convert model wavelength grid to wavenumber grid
+    nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
+    nu_out = nu_out[::-1]    # Reverse direction, such that increases with wavenumber
+    
+    N_nu = len(nu_out)    # Number of wavenumbers on model grid
+    N_wl = len(wl_out)    # Number of wavelengths on model grid
+    
+    # Initialise arrays of wavenumber locations of left and right bin edges
+    #nu_l = np.zeros(N_nu)   # Left edge
+    #nu_r = np.zeros(N_nu)   # Right edge
+    # Look below for definitions of nu_l, nu_r
+            
+    # Find logarithm of desired pressure
+    log_P = np.log10(new_P)
+
+    # If pressure below minimum, do not interpolate
+    if (log_P < log_P_grid[0]):
+        x = -1      # Special value (1) used in opacity inialiser
+        w_P = 0.0
+    # If pressure above maximum, do not interpolate
+    elif (log_P >= log_P_grid[-1]):
+        x = -2      # Special value (2) used in opacity inialiser
+        w_P = 0.0
+    else:
+        # Closest P indicies in opacity grid corresponding to model pressure
+        x = prior_index_V2(log_P, log_P_grid[0], log_P_grid[-1], N_P)
+        # Weights - fractional distance along pressure axis of sigma array
+        w_P = (log_P-log_P_grid[x])/(log_P_grid[x+1]-log_P_grid[x])     
+            
+    # Precalculate interpolation pre-factors to reduce computation overhead
+    b1 = (1.0-w_P)
+    b2 = w_P  
+    
+    # Find wavenumber indicies in arrays of model grid
+    # Vectorized by Lia
+    nu_edges = np.append(nu_out[0] - (nu_out[1] - nu_out[0]), 
+                         nu_out)
+    nu_edges = np.append(nu_edges, nu_out[-1] + (nu_out[-1] - nu_out[-2]))
+    nu_l = 0.5 * (nu_edges[:-2] + nu_edges[1:-1])
+    nu_r = 0.5 * (nu_edges[1:-1] +  nu_edges[2:])
+    
+    '''for k in range(N_nu):
+        
+        if (k != 0) and (k != (N_nu-1)):    
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        
+        # Special case for boundary values
+        elif (k == 0): 
+            nu_l[k] = nu_out[k] - 0.5*(nu_out[k+1] - nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        elif (k == (N_nu-1)):
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])'''
+
+    # Evaluate temperature interpolation weighting factor
+    y, w_T = T_interpolation_init(T_grid, new_T)
+    
+    sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, 
+                                                  log_sigma, nu_l, nu_out, nu_r, 
+                                                  nu_opac, N_nu, x, b1, b2, calculation_mode)
+
+    sigma_result = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, new_T, y, w_T)
+
+    return sigma_result
+
+
+def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
+    
+    '''Convienient function to read in all opacities and pre-interpolate
+       them onto the desired pressure, temperature, and wavelength grid'''
+
+    T_grid, log_P_grid, nu_opac, opac_file = load_db()
+
+    # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
+    #sigma_stored = np.zeros(shape=(N_species, N_wl))
+    # Lia -- Making this a dictionary instead of a numpy array. It's easier to use for plotting.
+    # Later, a 2D numpy array will be faster for summing across a large number of species
+    # But for now, two dozen is not a lot.
+    sigma_stored = dict()
+    
+    #***** Process molecular and atomic opacities *****#
+    
+    # Load molecular and atomic absorption cross sections
+    for q in chemical_species:
+        
+        log_sigma = np.array(opac_file[q + '/log(sigma)']).astype(np.float64)
+
+        sigma_stored[q] = _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
+                                              P, T, wl_out, opacity_treatment)
+        
+        del log_sigma   # Clear raw cross section to free up memory
+        
+        print(q + " done")
+    
+    opac_file.close()
+    
+    return sigma_stored
+
+# Written by Lia for a set of (p,T) values
+def Extract_opacity_PTpairs(chemical_species, P, T, wl_out, opacity_treatment):
+    
+    '''Convienient function to read in all opacities and pre-interpolate
+       them onto the desired pressure, temperature, and wavelength grid'''
+
+    assert len(P) == len(T)
+
+    T_grid, log_P_grid, nu_opac, opac_file = load_db()
+
+    # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
+    #sigma_stored = np.zeros(shape=(N_species, N_wl))
+    # Lia -- Making this a dictionary instead of a numpy array. It's easier to use for plotting.
+    # Later, a 2D numpy array will be faster for summing across a large number of species
+    # But for now, two dozen is not a lot.
+    sigma_stored = dict()
+    
+    #***** Process molecular and atomic opacities *****#
+    
+    # Load molecular and atomic absorption cross sections
+    for q in chemical_species:
+        
+        log_sigma = np.array(opac_file[q + '/log(sigma)']).astype(np.float64)
+        
+        result = np.zeros(shape=(len(P), len(wl_out)))
+        for i in range(len(P)):
+             result[i,:] = _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
+                                       P[i], T[i], wl_out, opacity_treatment)
+        
+        sigma_stored[q] = result
+        
+        del log_sigma   # Clear raw cross section to free up memory
+        
+        print(q + " done")
+    
+    opac_file.close()
+    
+    return sigma_stored
+
+
+def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, **kwargs):
+    
+    # Max number of species this can plot is 9 (clustered beyond that!)
+    
+    # Optional smoothing of cross sections (can improve clarity)
+    smooth = False
+    smooth_factor = 5
+    
+    # Specify cross sections to plot, along with colours for each
+    #colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
+    
+    # Initialise plot
+    #ax = plt.gca()
+    #ax.set_xscale("log")
+    
+    ax = plt.subplot(111)
+    #xmajorLocator   = MultipleLocator(1.0)
+    #xmajorFormatter = FormatStrFormatter('%.1f')
+    #xminorLocator   = MultipleLocator(0.2)
+    
+    #ax.xaxis.set_major_locator(xmajorLocator)
+    #ax.xaxis.set_major_formatter(xmajorFormatter)
+    #ax.xaxis.set_minor_locator(xminorLocator)
+    
+    # Plot each cross section
+    for species in chemical_species:
+        #species_idx = np.where(chemical_species == species)[0][0]
+        sigma_plt = sigma_stored[species]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)
+        
+        if (smooth == True):
+            sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
+            
+        # Plot cross section
+        plt.semilogy(wl_grid, sigma_plt, label=species, **kwargs)
+    
+    plt.ylim([1.0e-28, 2.0e-18])
+    plt.xlim([min(wl_grid), max(wl_grid)])
+    plt.ylabel(r'$\mathrm{Cross \, \, Section \, \, (cm^{2})}$', fontsize = 15)
+    plt.xlabel(r'$\mathrm{Wavelength} \; \mathrm{(\mu m)}$', fontsize = 15)
+    
+    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\mathrm{T = }$' + str(T) + \
+                                         r'$\mathrm{K \, \, P = }$' + \
+                                         str(P*1000) + r'$\mathrm{mbar}$'), fontsize = 14)
+    
+    legend = plt.legend(loc='upper right', frameon=False, prop={'size':6}, ncol=2)
+    
+    '''for legline in legend.legendHandles:
+    legline.set_linewidth(1.0)'''
+
+    plt.show()
+
+    if savefig:
+        plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+
+    plt.close()
+    
+    return
+
+#***** Begin main program ***** 
+
+# This code will execute if you run the script from the terminal
+# Otherwise, no
+if __name__ == '__main__':
+    # Specify which molecules you want to extract from the database (full list available in the readme)
+    chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])
+    
+    # At what temperature and pressure do you desire the cross sections?
+    P = 1.0e-3    # Pressure (bar)
+    T = 1000.0    # Temperature (K)        
+
+    # Specify wavelength grid to extract cross section onto
+    wl_min = 0.4  # Minimum wavelength of grid (micron)
+    wl_max = 5.0  # Maximum wavelength of grid (micron)
+    N_wl = 1000   # Number of wavelength points
+
+    wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   
+    
+    # Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription 
+    opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg
+    #opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended
+    
+    # Extract desired cross sections from the database
+    cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)
+    
+    # Example: seperate H2O cross section, and print to terminal
+    H2O_cross_section = cross_sections['H2O']    # Format: np array(N_wl) / Units: (m^2 / molecule)
+    #print (H2O_cross_section)
+    
+    # Plot cross sections
+    plot_opacity(chemical_species, cross_sections, P, T, wl, savefig=True, alpha=0.8, lw=0.5)
+
diff --git a/gas_opac/opacity_demo_V2.py b/gas_opac/opacity_demo_V2.py
new file mode 100644
index 0000000..0435eb8
--- /dev/null
+++ b/gas_opac/opacity_demo_V2.py
@@ -0,0 +1,461 @@
+# Demostrates how to open the opacity database and interpolate to given (P,T) and wavelength grid
+# Author: Ryan J. MacDonald
+# V1.0: Evaluates cross sections at a single P,T point (8th November 2018)
+# V2.0: Evaluates cross sections on a grid of (P,T) points (6th december 2018)
+
+# 2018.12.06 - Modified slightly by liac@umich.edu
+
+import numpy as np
+import h5py
+from scipy.ndimage import gaussian_filter1d as gauss_conv
+from numba.decorators import jit
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+
+#***** Begin function declarations *****# 
+
+@jit(nopython = True)
+def prior_index(vec, value, start):
+    
+    '''Finds the previous index of a grid closest to a specified value
+    '''
+    
+    value_tmp = value
+    
+    if (value_tmp > vec[-1]):
+        return (len(vec) - 1)
+    
+    # Check if value out of bounds, if so set to edge value
+    if (value_tmp < vec[0]): value_tmp = vec[0]
+    if (value_tmp > vec[-2]): value_tmp = vec[-2]
+    
+    index = start
+    
+    for i in range(len(vec)-start):
+        if (vec[i+start] > value_tmp): 
+            index = (i+start) - 1
+            break
+            
+    return index
+
+@jit(nopython=True)
+def prior_index_V2(val, grid_start, grid_end, N_grid):
+    
+    '''Finds the previous index of a UNIFORM grid closest to a specified value.
+    
+       A uniform grid dramatically speeds calculation over a non-uniform grid.
+    '''
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        return int(i)
+
+@jit(nopython=True)
+def closest_index(val, grid_start, grid_end, N_grid):
+    
+    '''Finds the index of a UNIFORM grid closest to a specified value.
+    
+       A uniform grid dramatically speeds calculation over a non-uniform grid.
+    '''
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        if ((i%1)<=0.5):
+            return int(i)
+        else:
+            return int(i)+1
+                        
+@jit(nopython = True)
+def P_interpolate_wl_initialise(nu_grid, N_P_out, N_T, N_P, N_wl_out, N_nu_out, 
+                                log_sigma, x, z_l, z, z_r, b1, b2, mode):
+    
+    '''Interpolates raw cross sections onto the output P and wl grids.
+       
+       Note: input sigma has format log10(cross_sec)[log(P)_grid, T_grid, nu_grid], 
+             whilst output has format cross_sec[log(P)_out, T_grid, wl_out]
+             
+       The input is in wavenumnber to take advantage of fast prior index location 
+       on a uniform grid, which wouldn't work for the (non-uniform) wavelength grid
+       Array reversal to output in increasing wavelength is handled by indexing
+       by a factor of (N_wl-1)-k throughout. 
+    '''
+    
+    sigma_pre_inp = np.zeros(shape=(N_P_out, N_T, N_wl_out))
+    
+    N_nu = len(nu_grid)   # Number of wavenumber points in sigma array
+        
+    for i in xrange(N_P_out):        # For each pressure in output array
+        for j in xrange(N_T):        # For each temperature in input array
+            for k in xrange(N_nu_out):   # Note that the k here is looping over wavenumber
+                            
+                # If nu (wl) point out of range of opacity grid, set opacity to zero
+                if ((z[k] == 0) or (z[k] == (N_nu-1))):
+                    sigma_pre_inp[i, j, ((N_wl_out-1)-k)] = 0.0
+                
+                else:
+                    
+                    # Opacity sampling
+                    if (mode == 1):
+                    
+                        # If pressure below minimum, set to value at min pressure
+                        if (x[i] == -1):
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (log_sigma[0, j, z[k]])
+                            
+                        # If pressure above maximum, set to value at max pressure
+                        elif (x[i] == -2):
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (log_sigma[(N_P-1), j, z[k]])
+            
+                        # Interpolate sigma in logsace, then power to get interp array
+                        else:
+                            reduced_sigma = log_sigma[x[i]:x[i]+2, j, z[k]]
+                            
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] =  10 ** (b1[i]*(reduced_sigma[0]) +
+                                                                        b2[i]*(reduced_sigma[1]))
+                            
+                    # Log averaging
+                    elif (mode == 2):
+                    
+                        # If pressure below minimum, set to value at min pressure
+                        if (x[i] == -1):
+                            sigma_in_bin = np.mean(log_sigma[0, j, z_l[k]:z_r[k]+1])
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+                            
+                        # If pressure above maximum, set to value at max pressure
+                        elif (x[i] == -2):
+                            sigma_in_bin = np.mean(log_sigma[(N_P-1), j, z_l[k]:z_r[k]+1])
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+        
+                        # Interpolate sigma in logsace, then power to get interp array
+                        else:
+                            sigma_in_bin_P1 = np.mean(log_sigma[x[i], j, z_l[k]:z_r[k]+1])
+                            sigma_in_bin_P2 = np.mean(log_sigma[x[i]+1, j, z_l[k]:z_r[k]+1])
+                        
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] =  10 ** (b1[i]*(sigma_in_bin_P1) +
+                                                                        b2[i]*(sigma_in_bin_P2))
+                    
+    return sigma_pre_inp
+
+@jit(nopython = True)
+def T_interpolation_init(N_T_out, T_grid, T_out, y):
+    
+    ''' Precomputes the T interpolation weight factors, so this does not
+        need to be done multiple times across all species.
+    '''
+    
+    w_T = np.zeros(N_T_out)  # Temperature interpolation weight factors
+    
+    # Find T index in cross secion arrays prior to fine temperature value
+    for j in xrange(N_T_out):
+        
+        if (T_out[j] < T_grid[0]):    # If fine temperature point falls off LHS of temperaure grid
+            y[j] = -1                 # Special value (-1) stored, interpreted in interpolator
+            w_T[j] = 0.0              # Weight not used in this case
+            
+        elif (T_out[j] >= T_grid[-1]):    # If fine temperature point falls off RHS of temperaure grid
+            y[j] = -2                     # Special value (-2) stored, interpreted in interpolator
+            w_T[j] = 0.0                  # Weight not used in this case
+            
+        else:
+                
+            # Have to use prior_index (V1) here as T_grid is not uniformly spaced
+            y[j] = prior_index(T_grid, T_out[j], 0)     # Index in cross secion arrays prior to desired temperature value
+                
+            # Pre-computed temperature values to left and right of desired temperature value
+            T1 = T_grid[y[j]]
+            T2 = T_grid[y[j]+1]
+                
+            # Precompute temperature interpolation weight factor
+            w_T[j] = (1.0/((1.0/T2) - (1.0/T1)))
+  
+    return w_T
+
+@jit(nopython = True)
+def T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T):
+    
+    '''Interpolates pre-processed cross section onto the output T grid.
+       
+       Note: input sigma has format log10(cross_sec)[log(P)_out, T_grid, wl_out], 
+             whilst output has format cross_sec[log(P)_out, T_out, wl_out].
+             
+       Output is the final interpolated cross section as a 3D array on the
+       desired P_out, T_out, wl_out grids.
+    '''
+    
+    sigma_inp = np.zeros(shape=(N_P_out, N_T_out, N_wl_out))
+    
+    for i in xrange(N_P_out):       # Loop over output pressure array
+        for j in xrange(N_T_out):   # Loop over input temperature array
+            
+            T = T_out[j]            # Temperature we wish to interpolate to
+            T1 = T_grid[y[j]]
+            T2 = T_grid[y[j]+1]
+            
+            for k in xrange(N_wl_out):  # Loop over wavelengths
+                
+                # If T_out below min pre-computed value (100 K), set sigma to value at min T
+                if (y[j] == -1):
+                    sigma_inp[i, j, k] = sigma_pre_inp[i, 0, k]
+                    
+                # If T_out above max pre-computed value (3500 K), set sigma to value at max T
+                elif (y[j] == -2):
+                    sigma_inp[i, j, k] = sigma_pre_inp[i, (N_T-1), k]
+            
+                # Interpolate sigma to output temperature grid value
+                else: 
+                    sig_reduced = sigma_pre_inp[i, y[j]:y[j]+2, k]
+                    sig_1, sig_2 = sig_reduced[0], sig_reduced[1]    # sigma(T1)[i,k], sigma(T2)[i,k]
+                    
+                    sigma_inp[i, j, k] =  (np.power(sig_1, (w_T[j]*((1.0/T2) - (1.0/T)))) *
+                                           np.power(sig_2, (w_T[j]*((1.0/T) - (1.0/T1)))))
+            
+    return sigma_inp
+
+def Extract_opacity(chemical_species, P_out, T_out, wl_out, opacity_treatment):
+    
+    '''Main function to read in all opacities and interpolate them onto the 
+       desired pressure, temperature, and wavelength grids.
+    '''
+    
+    print("Now reading in cross sections")
+    
+    # First, check from config.py which opacity calculation mode is specified
+    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
+    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
+
+    #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
+    
+    # Open HDF5 files containing molecular + atomic opacities and CIA
+    opac_file = h5py.File('./Opacity_database_0.01cm-1.hdf5', 'r')
+    
+    #***** Read in T and P grids used in opacity files*****#
+    T_grid = np.array(opac_file['H2O/T'])            # H2O here simply used as dummy (same grid for all molecules)
+    log_P_grid = np.array(opac_file['H2O/log(P)'])   # Units: log10(P/bar)
+    log_P_out = np.log10(P_out)                      # Units: log10(P/bar)
+    
+    #***** Read in wavenumber arrays used in opacity files*****#
+    nu_grid = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
+
+    # Convert model wavelength grid to wavenumber grid
+    nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
+    nu_out = nu_out[::-1]    # Reverse direction, such that increases with wavenumber
+    
+    N_nu = len(nu_grid)                # No. of wavenumbers in each opacity file (2480001)
+    N_P = len(log_P_grid)              # No. of pressures in opacity files
+    N_T = len(T_grid)                  # No. of temperatures in opacity files
+    N_species = len(chemical_species)  # No. of chemical species user wishes to store
+    
+    N_P_out = len(P_out)      # No. of pressures on output pressure grid
+    N_T_out = len(T_out)      # No. of temperatures on output temperature grid
+    N_nu_out = len(nu_out)    # No. of wavenumbers on output grid
+    N_wl_out = len(wl_out)    # No. of wavelengths on output grid
+    
+    # Initialise arrays of wavenumber locations of left and right bin edges
+    nu_l = np.zeros(N_nu_out)   # Left edge
+    nu_r = np.zeros(N_nu_out)   # Right edge
+    
+    # Initialise arrays of indicies on wavenumber opacity grid corresponding to nu_l, nu_out, and nu_r
+    z_l = np.zeros(N_wl_out, dtype=np.int)   # Bin left edge
+    z = np.zeros(N_wl_out, dtype=np.int)     # Bin centre
+    z_r = np.zeros(N_wl_out, dtype=np.int)   # Bin right edge
+    
+    # Initialise array of indicies on pre-calculated pressure opacity grid prior to defined atmosphere layer pressures
+    x = np.zeros(N_P_out, dtype=np.int)
+    
+    # Weights
+    w_P = np.zeros(N_P_out)
+            
+    # Useful functions of weights for interpolation
+    b1 = np.zeros(shape=(N_P_out))
+    b2 = np.zeros(shape=(N_P_out))
+    
+    # Now find closest P indicies in opacity grid corresponding to output pressures
+    for i in xrange(N_P_out):
+        
+        # If pressure below minimum, do not interpolate
+        if (log_P_out[i] < log_P_grid[0]):
+            x[i] = -1      # Special value (1) used in opacity initialiser
+            w_P[i] = 0.0
+        
+        # If pressure above maximum, do not interpolate
+        elif (log_P_out[i] >= log_P_grid[-1]):
+            x[i] = -2      # Special value (2) used in opacity initialiser
+            w_P[i] = 0.0
+        
+        else:
+            x[i] = prior_index_V2(log_P_out[i], log_P_grid[0], log_P_grid[-1], N_P)
+        
+            # Weights - fractional distance along pressure axis of cross section array
+            w_P[i] = (log_P_out[i]-log_P_grid[x[i]])/(log_P_grid[x[i]+1]-log_P_grid[x[i]])     
+         
+        # Precalculate interpolation pre-factors to reduce computation overhead
+        b1[i] = (1.0-w_P[i])
+        b2[i] = w_P[i]  
+            
+    # Find wavenumber indicies on input grid closest to values on output grid
+    for k in xrange(N_nu_out):
+        
+        if (k != 0) and (k != (N_nu_out-1)):    
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        
+        # Boundary values of each output wavenumber point
+        elif (k == 0): 
+            nu_l[k] = nu_out[k] - 0.5*(nu_out[k+1] - nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        elif (k == (N_nu-1)):
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])
+        
+        # Calculate closest indicies to output wavenumber bin left, centre, and right edge
+        z_l[k] = closest_index(nu_l[k], nu_grid[0], nu_grid[-1], N_nu)
+        z[k] = closest_index(nu_out[k], nu_grid[0], nu_grid[-1], N_nu)
+        z_r[k] = closest_index(nu_r[k], nu_grid[0], nu_grid[-1], N_nu)
+        
+    # Initialise molecular and atomic opacity array, interpolated to output (P,T,wl) grid
+    # Lia - modified to use a dictionary instead (easier for reference in her codes)
+    #sigma_stored = np.zeros(shape=(N_species, N_P_out, N_T_out, N_wl_out))
+    sigma_stored = dict()
+    
+    # Evaluate temperature interpolation weighting factor
+    y = np.zeros(N_T_out, dtype=np.int)
+    w_T = T_interpolation_init(N_T_out, T_grid, T_out, y)
+        
+    #***** Process molecular and atomic opacities *****#
+    
+    # Load molecular and atomic absorption cross sections
+    for q in xrange(N_species):
+            
+        species_q = chemical_species[q]    # Species name specified by user
+        
+        # Read in log10(cross section) of specified species
+        log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)      
+            
+        # Pre-interpolate cross section to desired P and wl grid 
+        sigma_pre_inp = P_interpolate_wl_initialise(nu_grid, N_P_out, N_T, N_P, N_wl_out, N_nu_out, log_sigma, x, z_l, z, z_r, b1, b2, calculation_mode)
+                
+        # Interplate to desired temperature
+        #sigma_stored[q,:,:,:] = T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T)
+        sigma_stored[q] = T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T)
+        
+        del log_sigma, sigma_pre_inp   # Clear raw cross section to free up memory
+        
+        print(species_q + " done")
+    
+    # Clear up storage
+    del z, z_l, z_r, nu_grid, nu_l, nu_r, nu_out, y, w_T
+    
+    opac_file.close()
+    
+    return sigma_stored
+
+def plot_opacity(chemical_species, sigma_stored, P_desired, T_desired, wl_grid):
+    
+    # Max number of species this can plot is 9 (clustered beyond that!)
+    
+    # Optional smoothing of cross sections (can improve clarity)
+    smooth = False
+    smooth_factor = 5
+    
+    # Specify cross sections to plot, along with colours for each
+    colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
+    
+    # Initialise plot
+    ax = plt.gca()    
+    #ax.set_xscale("log")
+    
+    xmajorLocator   = MultipleLocator(1.0)
+    xmajorFormatter = FormatStrFormatter('%.1f')
+    xminorLocator   = MultipleLocator(0.2)
+    
+    ax.xaxis.set_major_locator(xmajorLocator)
+    ax.xaxis.set_major_formatter(xmajorFormatter)
+    ax.xaxis.set_minor_locator(xminorLocator)
+    
+    # Plot each cross section
+    for q in range(len(chemical_species)):
+        
+        species = chemical_species[q]  # Species to plot cross section of 
+        colour = colours_plot[q]   # Colour of cross section for plot
+        
+        #print(species)
+        
+        species_idx = np.where(chemical_species == species)[0][0]
+
+        sigma_plt = sigma_stored[species_idx,:]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)
+        
+        if (smooth == True):
+            sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
+        
+        # Plot cross section
+        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, color= colour, label = species)
+    
+    plt.ylim([1.0e-28, 2.0e-18])
+    plt.xlim([min(wl_grid), max(wl_grid)])
+    plt.ylabel(r'$\mathrm{Cross \, \, Section \, \, (cm^{2})}$', fontsize = 15)
+    plt.xlabel(r'$\mathrm{Wavelength} \; \mathrm{(\mu m)}$', fontsize = 15)
+    
+    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\mathrm{T = }$' + str(T_desired) + r'$\mathrm{K \, \, P = }$' + str(P_desired*1000) + r'$\mathrm{mbar}$'), fontsize = 14)
+    
+    legend = plt.legend(loc='upper right', shadow=False, frameon=False, prop={'size':6}, ncol=2)
+    
+    for legline in legend.legendHandles:
+        legline.set_linewidth(1.0)
+    
+    #plt.close()
+    #plt.show()
+
+    #plt.savefig('./cross_sections_' + str(T_desired) + 'K_' + str(P_desired*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+
+
+"""
+#***** Begin main program ***** 
+    
+# Specify which molecules you want to extract from the database (full list available in the readme)
+chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])
+
+# Specify temperature and pressure grids on which to evaluate cross sections. Example:
+P = np.logspace(-6, 2.0, 10)            # 20 pressures logarithmically spaced from 10^-6 -> 10^2 bar.
+T = np.linspace(1000.0, 3000.0, 100)    # 100 temperatures linearly spaced from 1000K -> 3000 K.
+
+# Specify wavelength grid to extract cross section onto
+wl_min = 0.4  # Minimum wavelength of grid (micron)
+wl_max = 5.0  # Maximum wavelength of grid (micron)
+N_wl = 1000   # Number of wavelength points
+
+wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   
+
+# Can use any P,T,wl grids, doesn't have to be uniform, but MUST be a numpy array.
+# Note: if you use a v. large number of (P,T,wl) points, the memory usage could be quite high!
+# This example has 10x100x1000 = 10^6 cross section values stored for each species.
+
+# Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription 
+opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg
+#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended
+  
+# Extract desired cross sections from the database
+cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_P, N_T, N_wl) / Units: (m^2 / species)
+
+# Example: seperate H2O cross section at 1 bar and 2000K, and print to terminal
+P_desired = 1.0
+T_desired = 2000.0
+P_idx = np.argmin(np.abs(P - P_desired))  # Closest index in the P array to desired value
+T_idx = np.argmin(np.abs(T - T_desired))  # Closest index in the T array to desired value
+
+H2O_cross_section = cross_sections[(np.where(chemical_species=='H2O')[0][0]),P_idx,T_idx,:]    # Format: np array(N_wl) / Units: (m^2 / molecule)
+#print (H2O_cross_section)
+
+# Plot cross sections at the desired P and T
+plot_opacity(chemical_species, cross_sections[:,P_idx,T_idx,:], P_desired, T_desired, wl)
+"""
diff --git a/notebooks/test_gas_opac.ipynb b/notebooks/test_gas_opac.ipynb
new file mode 100644
index 0000000..d688348
--- /dev/null
+++ b/notebooks/test_gas_opac.ipynb
@@ -0,0 +1,794 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import h5py\n",
+    "from scipy.ndimage import gaussian_filter1d as gauss_conv\n",
+    "from numba.decorators import jit\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.ticker import MultipleLocator, FormatStrFormatter\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/dev/cloudacademyMap/gas_opac\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd ~/dev/cloudacademyMap/gas_opac/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import astropy.units as u"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import opacity_demo as demo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading opacity database file\n",
+      "H2O done\n",
+      "CH4 done\n",
+      "NH3 done\n",
+      "HCN done\n",
+      "CO done\n",
+      "CO2 done\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Specify which molecules you want to extract from the database (full list available in the readme)\n",
+    "chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])\n",
+    "\n",
+    "# At what temperature and pressure do you desire the cross sections?\n",
+    "P = 1.0e-3    # Pressure (bar)\n",
+    "T = 1000.0    # Temperature (K)        \n",
+    "\n",
+    "# Specify wavelength grid to extract cross section onto\n",
+    "wl_min = 0.4  # Minimum wavelength of grid (micron)\n",
+    "wl_max = 5.0  # Maximum wavelength of grid (micron)\n",
+    "N_wl = 1000   # Number of wavelength points\n",
+    "\n",
+    "wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   \n",
+    "\n",
+    "# Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription \n",
+    "opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg\n",
+    "#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended\n",
+    "  \n",
+    "# Extract desired cross sections from the database\n",
+    "cross_sections = demo.Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example: seperate H2O cross section, and print to terminal\n",
+    "H2O_cross_section = cross_sections['H2O']    # Format: np array(N_wl) / Units: (m^2 / molecule)\n",
+    "#print (H2O_cross_section)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copy/paste plot function from opacity_demo.py because I'm getting some weird errors\n",
+    "\n",
+    "def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, **kwargs):\n",
+    "\n",
+    "    # Max number of species this can plot is 9 (clustered beyond that!)                                                                                                  \n",
+    "\n",
+    "    # Optional smoothing of cross sections (can improve clarity)                                                                                                         \n",
+    "    smooth = False\n",
+    "    smooth_factor = 5\n",
+    "\n",
+    "    # Specify cross sections to plot, along with colours for each                                                                                                        \n",
+    "    #colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])                                             \n",
+    "\n",
+    "    # Initialise plot                                                                                                                                                    \n",
+    "    #ax = plt.gca()\n",
+    "    #ax.set_xscale(\"log\")                                                                                                                                                \n",
+    "\n",
+    "    ax = plt.subplot(111)\n",
+    "    #xmajorLocator   = MultipleLocator(1.0)\n",
+    "    #xmajorFormatter = FormatStrFormatter('%.1f')\n",
+    "    #xminorLocator   = MultipleLocator(0.2)\n",
+    "\n",
+    "    #ax.xaxis.set_major_locator(xmajorLocator)\n",
+    "    #ax.xaxis.set_major_formatter(xmajorFormatter)\n",
+    "    #ax.xaxis.set_minor_locator(xminorLocator)\n",
+    "\n",
+    "    # Plot each cross section                                                                                                                                            \n",
+    "    for species in chemical_species:\n",
+    "        #species_idx = np.where(chemical_species == species)[0][0]\n",
+    "        sigma_plt = sigma_stored[species]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)                                                          \n",
+    "\n",
+    "        if (smooth == True):\n",
+    "            sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')\n",
+    "\n",
+    "        # Plot cross section                                                                                                                                             \n",
+    "        plt.semilogy(wl_grid, sigma_plt, label = species, **kwargs)\n",
+    "\n",
+    "    plt.ylim([1.0e-28, 2.0e-18])\n",
+    "    plt.xlim([min(wl_grid), max(wl_grid)])\n",
+    "    plt.ylabel(r'$\\mathrm{Cross \\, \\, Section \\, \\, (cm^{2})}$', fontsize = 15)\n",
+    "    plt.xlabel(r'$\\mathrm{Wavelength} \\; \\mathrm{(\\mu m)}$', fontsize = 15)\n",
+    "\n",
+    "    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\\mathrm{T = }$' + str(T) + r'$\\mathrm{K \\, \\, P = }$' + str(P*1000) + r'$\\mathrm{mbar}$'), fontsize = 14)\n",
+    "\n",
+    "    legend = plt.legend(loc='upper right', frameon=False, prop={'size':6}, ncol=2)\n",
+    "\n",
+    "    '''for legline in legend.legendHandles:\n",
+    "        legline.set_linewidth(1.0)'''\n",
+    "    return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot cross sections\n",
+    "plot_opacity(chemical_species, cross_sections, P, T, wl, lw=0.5, alpha=0.8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Grab all the opacities possible\n",
+    "\n",
+    "Based on gases present both in Ryan's library and in the static weather output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Grabbed from Readme.txt\n",
+    "RMcD_gas = np.array(['H3+', 'Na', 'K', 'Li', 'Rb', 'Cs', 'H2', 'H2O', 'CH4', 'NH3', 'HCN', 'CO', \\\n",
+    "                     'CO2', 'C2H2', 'H2S', 'N2', 'O2', 'O3', 'OH', 'NO', 'SO2', 'PH3', 'TiO', 'VO', \\\n",
+    "                     'ALO', 'SiO', 'CaO', 'TiH', 'CrH', 'FeH', 'ScH', 'AlH', 'SiH', 'BeH', 'CaH', \\\n",
+    "                     'MgH', 'LiH', 'SiH', 'CH', 'SH', 'NH'])\n",
+    "\n",
+    "RMcD_gas_upper = np.array([g.upper() for g in RMcD_gas])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False,  True, False, False, False, False,\n",
+       "       False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False, False])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.array(RMcD_gas_upper) == 'TIO'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/dev/cloudacademyMap\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd .."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from maplib import load_out3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd ~/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# An example file to work from. I hope all of the reported columns are the same\n",
+    "PHI, THETA = -180, 0\n",
+    "\n",
+    "# Get gas information\n",
+    "thermo = load_out3('thermo', PHI, THETA)\n",
+    "\n",
+    "# Get wavelengths for later\n",
+    "wavel = load_out3('wavel', PHI, THETA)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO', 'TIO2', 'TIS', 'SIO', 'SIS', 'SIH', 'H2O', 'H2', 'H2S', 'MGH', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FEH', 'FE(OH)2', 'ALOH', 'ALH', 'AL2O', 'ALO2H', 'CAO', 'CA(OH)2', 'CAS', 'CAOH', 'CAH', 'C2', 'C3', 'C2H', 'C2H2', 'CH4']\n"
+     ]
+    }
+   ],
+   "source": [
+    "thermo_gas = []\n",
+    "for k in thermo.keys():\n",
+    "    x = k.split('n_')\n",
+    "    if len(x) == 2:\n",
+    "        thermo_gas.append(x[1])\n",
+    "print(thermo_gas)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Gases in static_weather model that are also in Ryan's opacity library\n",
+    "gases, gases_missing = [], []\n",
+    "for g in thermo_gas:\n",
+    "    if g in RMcD_gas_upper:\n",
+    "        ig = np.where(RMcD_gas_upper == g)[0]\n",
+    "        gases.append(RMcD_gas[ig][0])\n",
+    "    else:\n",
+    "        gases_missing.append(g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gases in both static_weather and Ryan's opacity library: (13 total)\n",
+      "['TiO', 'SiO', 'SiH', 'H2O', 'H2', 'H2S', 'MgH', 'FeH', 'AlH', 'CaO', 'CaH', 'C2H2', 'CH4']\n",
+      "\n",
+      "Gases missing opacities: (25 total)\n",
+      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO2', 'TIS', 'SIS', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FE(OH)2', 'ALOH', 'AL2O', 'ALO2H', 'CA(OH)2', 'CAS', 'CAOH', 'C2', 'C3', 'C2H']\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Gases in both static_weather and Ryan's opacity library: ({} total)\".format(len(gases)))\n",
+    "print(gases)\n",
+    "print(\"\\nGases missing opacities: ({} total)\".format(len(gases_missing)))\n",
+    "print(gases_missing)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/dev/cloudacademyMap/gas_opac\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd ~/dev/cloudacademyMap/gas_opac"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Takes a few minutes to read in**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading opacity database file\n",
+      "TiO done\n",
+      "SiO done\n",
+      "SiH done\n",
+      "H2O done\n",
+      "H2 done\n",
+      "H2S done\n",
+      "MgH done\n",
+      "FeH done\n",
+      "AlH done\n",
+      "CaO done\n",
+      "CaH done\n",
+      "C2H2 done\n",
+      "CH4 done\n",
+      "CPU times: user 2min, sys: 54.3 s, total: 2min 54s\n",
+      "Wall time: 3min 17s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "sw_xsects = demo.Extract_opacity(np.array(gases), P, T, wavel, opacity_treatment)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.2, 330)"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_opacity(np.array(gases), sw_xsects, P, T, wavel, marker='o', ls=':', alpha=0.5)\n",
+    "plt.semilogx()\n",
+    "plt.xlim(0.2, 330)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "304"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(thermo['p'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## To do next\n",
+    "\n",
+    "[x] Load opacities for each (p, T) value\n",
+    "\n",
+    "[x] Calculate dtau_dz for each element and vertical profile.\n",
+    "\n",
+    "[x] Save the dtau_dz profiles to a file.\n",
+    "\n",
+    "[ ] Write a function for reading in file.\n",
+    "\n",
+    "[ ] Write a function for summing the gas contributions to dtau/dz.\n",
+    "\n",
+    "[ ] Add those dtau_dz values to the atmosphere depth calculation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Look at densities as a function of temperature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0xb2836d278>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for g in gases:\n",
+    "    plt.plot(thermo['T'], thermo['n_' + g.upper()], label=g)\n",
+    "plt.semilogy()\n",
+    "plt.xlim(500, 3000)\n",
+    "plt.xlabel('Temperature (K)')\n",
+    "plt.ylabel('$n_Z$')\n",
+    "plt.legend(loc='lower right', frameon=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Sanity check for pressure, temperature interpolation\n",
+    "# Suggested by Ryan\n",
+    "#T0 = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500]\n",
+    "#T1 = np.arange(100, 3000, 50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading opacity database file\n",
+      "TiO done\n",
+      "SiO done\n",
+      "SiH done\n",
+      "H2O done\n",
+      "H2 done\n",
+      "H2S done\n",
+      "MgH done\n",
+      "FeH done\n",
+      "AlH done\n",
+      "CaO done\n",
+      "CaH done\n",
+      "C2H2 done\n",
+      "CH4 done\n",
+      "CPU times: user 6min 11s, sys: 51 s, total: 7min 2s\n",
+      "Wall time: 7min 19s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "opacity_treatment = 'Log-avg'\n",
+    "test = demo.Extract_opacity_PTpairs(np.array(gases), thermo['p'], thermo['T'], wavel, opacity_treatment)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.00000000e+00, 0.00000000e+00, 2.14347212e-22, 4.47281423e-22,\n",
+       "       1.29905700e-21, 3.53249151e-22, 1.04683496e-22, 2.52623100e-23,\n",
+       "       8.56768717e-24, 1.58196485e-24, 9.39862143e-26, 3.68280847e-26,\n",
+       "       2.96488882e-27, 5.33163439e-28, 3.14810018e-29, 3.65333659e-30,\n",
+       "       3.32698108e-30, 1.56147535e-30, 2.14301779e-31, 1.40997078e-29,\n",
+       "       6.98666068e-31, 2.51045302e-27, 2.40541312e-30, 2.66165606e-31,\n",
+       "       5.96403292e-30, 4.35892019e-29, 7.09350429e-33, 8.54948670e-28,\n",
+       "       1.86176468e-34, 1.76090418e-32, 0.00000000e+00])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test['TiO'][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calc_dtau_dz(gas, opac_dict):\n",
+    "    n_z = thermo['n_' + gas.upper()]\n",
+    "    sigma = opac_dict[gas]\n",
+    "    \n",
+    "    NP  = len(n_z) # number of vertical data points\n",
+    "    NWL = len(sigma[0,:]) # number of wavelengths\n",
+    "    \n",
+    "    result = np.zeros(shape=(NP, NWL))\n",
+    "    for i in range(NP):\n",
+    "        result[i,:] = n_z[i] * sigma[i,:] # cm^-1\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dtau_dz = dict()\n",
+    "for g in gases:\n",
+    "    dtau_dz[g] = calc_dtau_dz(g, test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0xb27c64e10>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "iw = 10\n",
+    "p = thermo['p'] * u.dyne / u.cm**2\n",
+    "for g in gases:\n",
+    "    plt.plot(dtau_dz[g][:,iw], p.to(u.bar), label=g)\n",
+    "plt.loglog()\n",
+    "plt.ylim(1.e3, 1.e-6)\n",
+    "plt.xlim(1.e-35, 1.e-8)\n",
+    "plt.xlabel(r'$d\\tau/dz$ (cm$^{-1}$)')\n",
+    "plt.ylabel('p (bar)')\n",
+    "plt.legend(loc='lower left', frameon=False, ncol=3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Make a 3D array and save it\n",
+    "\n",
+    "I'm going to use a FITS file for now. Seems like the simplest thing??"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from astropy.io import fits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def write_opac_fits(opac_dict, filename):\n",
+    "    hdr = fits.Header()\n",
+    "    hdr['COMMENT'] = \"dtau/dz for gas phase elements of HATP-7b\"\n",
+    "    hdr['COMMENT'] = \"Made from opacity tables of R. MacDonald\"\n",
+    "    hdr['COMMENT'] = \"See out3_*.dat files for p, T, and z profiles\"\n",
+    "    \n",
+    "    primary_hdu = fits.PrimaryHDU(header=hdr)\n",
+    "    hdus_to_write = [primary_hdu]\n",
+    "    for k in opac_dict.keys():\n",
+    "        hdus_to_write.append(fits.ImageHDU(opac_dict[k], name=k))\n",
+    "    \n",
+    "    hdu_list = fits.HDUList(hdus=hdus_to_write)\n",
+    "    hdu_list.writeto(filename, overwrite=True)\n",
+    "    return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "write_opac_fits(test, 'test.fits')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tt = fits.open('test.fits')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Filename: test.fits\n",
+      "No.    Name      Ver    Type      Cards   Dimensions   Format\n",
+      "  0  PRIMARY       1 PrimaryHDU       7   ()      \n",
+      "  1  TIO           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  2  SIO           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  3  SIH           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  4  H2O           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  5  H2            1 ImageHDU         8   (31, 304)   float64   \n",
+      "  6  H2S           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  7  MGH           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  8  FEH           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  9  ALH           1 ImageHDU         8   (31, 304)   float64   \n",
+      " 10  CAO           1 ImageHDU         8   (31, 304)   float64   \n",
+      " 11  CAH           1 ImageHDU         8   (31, 304)   float64   \n",
+      " 12  C2H2          1 ImageHDU         8   (31, 304)   float64   \n",
+      " 13  CH4           1 ImageHDU         8   (31, 304)   float64   \n"
+     ]
+    }
+   ],
+   "source": [
+    "tt.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cloud-academy",
+   "language": "python",
+   "name": "cloud-academy"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}