Ejemplo n.º 1
0
'''
density_dict,calc_dict = initial_conditions(initial_conditions_gas,M,species,\
                                            rate_numba,calc_dict,particles,\
                                                initials_from_run,t0,path)
density_dict['RO2'] = ppool_density_calc(density_dict, ppool)

#calculating t0 summations
summations_dict = {}
if summations == 1:
    summations_dict = summations_compile(sums)
    sums_dict = {}
    sums_dict = summations_eval(summations_dict, density_dict, calc_dict)
    density_dict.update(sums_dict)

if particles == 1:
    particle_dict = particle_calcs(part_calc_dict, density_dict)
else:
    particle_dict = {}
'''    
saving initial conditions to an output directory for reference
'''
f = open("%s/%s/initial_concentrations.txt" % (path, output_folder), "w")
for i in species:
    f.write('%s=%s ;\n' % (i, density_dict[i]))
f.close()
'''
Calculating the reaction rates and compiling the master array of ODEs
'''
num_species = len(species)  #some calculations ask for the number of species
#better to calculate it once rather than every time
Ejemplo n.º 2
0
def dydy(t, y0):
    '''
    The function to calculate the jacobian that is fed to the integrator

    inputs:
    	t = time
    	y0 = concentration of species

    returns:
    	dydy = array of change in species concentration with change 
    		   in other species concentrations
    '''
    #Update density dictionary
    for i in range(num_species):
        density_dict[species[i]] = y0[i]
    density_dict['RO2'] = ppool_density_calc(density_dict, ppool)

    #if summations are included they need to be updated to the density dictionary also
    if summations == 1:
        sums_dict = summations_eval(summations_dict, density_dict, calc_dict)
        density_dict.update(sums_dict)

    #n = time in seconds from midnight for each day
    n = t - ((int(t / 86400)) * 86400)

    # recalculate photolysis
    # COSX and SECX involve local hour angles dependant on position and time
    # of year (latitude of location and declination of sun)

    lha = (1 + ((n - time_correct) /
                4.32E+4)) * pi  # local hour angle, radians. Midnight start
    cosx = ((numba_cos(lha) * cosld) + sinld)  # solar zenith angle

    # Set negative cosx to zero and calculate the inverse
    # (secx=1/cosx). The MCM photolysis parameterisation
    # (http://mcm.leeds.ac.uk/MCM/parameters/photolysis_param.htt)
    # requires cosx and secx to calculate the photolysis rates.
    if cosx <= 1E-30:
        cosx = 0.0
        secx = 1.0E+30
    else:
        secx = 1.0 / (
            ((cosx + numba_abs(cosx)) / 2) + 1.0E-30)  # no division by 0

    #updates the relevant dictionary whether lights are on or off
    for i in light_on_times:
        if i[0] <= t <= i[1]:
            indoor_photo_dict["cosx"] = cosx
            indoor_photo_dict["secx"] = secx
            photolysis_J(indoor_photo_dict, photo_dict, J_dict)
            break
        else:
            indoor_photo_dict_off["cosx"] = cosx
            indoor_photo_dict_off["secx"] = secx
            photolysis_J(indoor_photo_dict_off, photo_dict, J_dict)

    #diurnal outdoor rates
    if diurnal == 1:
        out_calc_dict["n"] = n
        out_calc_dict["cosx"] = cosx
        out_calc_dict["secx"] = secx
        outdoor_rates_calc(outdoor_dict, outdoor_dict_diurnal, out_calc_dict)

    #recalculate temp,humidity,water
    h2o, rh = h2o_rh(t, temp, rel_humidity, numba_exp)
    calc_dict['h2o'] = h2o

    #recalculate particle sums
    global particle_dict
    if particles == 1:
        particle_dict = particle_calcs(part_calc_dict, density_dict)
    else:
        particle_dict = {}

    #checks time, if between times set for a forced density change the rate
    #is applied to the specific species
    if timed_emissions == 1:
        for key in timed_inputs:
            for i in timed_inputs[key]:
                if i[0] <= t <= i[1]:
                    timed_dict["%s_timed" % key] = i[2]
                    break
                else:
                    timed_dict["%s_timed" % key] = 0

    #recalculate reaction rates
    reaction_rate_dict=reaction_eval(reaction_number,J_dict,calc_dict,density_dict,\
                                     dt,reaction_compiled_dict,outdoor_dict,\
                                         surface_dict,particle_dict,timed_dict)

    #recalculate jacobian
    dydy_jac=dy_dy_calc(dy_dy_dict,J_dict,calc_dict,density_dict,species,\
                        outdoor_dict,surface_dict,particle_dict,num_species,\
                            timed_dict,reaction_rate_dict)
    return dydy_jac
Ejemplo n.º 3
0
def run_inchem(filename, particles, INCHEM_additional, custom, temp, rel_humidity,
               M, const_dict, AER, diurnal, city, date, lat, light_type, 
               light_on_times, glass, HMIX, initials_from_run,
               initial_conditions_gas, timed_emissions, timed_inputs, dt, t0,
               seconds_to_integrate, custom_name, output_graph, output_species):
  
    '''
    import all modules
    '''
    import sys
    import pickle
    from modules.inchem_import import import_all, custom_import 
    from modules.particle_input import particle_import, particle_calcs, reactions_check
    from modules.photolysis import photolysis_J, Zixu_photolysis, Zixu_photolysis_compiled
    from modules.initial_dictionaries import initial_conditions, master_calc, master_compiler,\
        reaction_rate_compile, reaction_eval, write_jacobian_build, INCHEM_species_calc
    from modules.outdoor_concentrations import outdoor_rates, outdoor_rates_diurnal, outdoor_rates_calc
    import numpy as np
    import numba as nb
    from scipy.integrate import ode
    import time
    from modules.surface_dictionary import surface_deposition
    from threadpoolctl import threadpool_limits
    import importlib.util
    import pandas as pd
    import os
    import datetime
    import math
    import time as timing
    from modules.reactivity import reactivity_summation, reactivity_calc, production_calc
    
    sys.setrecursionlimit(4000) #to compile the master array the recursion limit
    #must be increased as some of the evaluated ODEs are greater than the usual
    #system limit
    
    save_rate = 1 #sets the rate at which outputs are saved within the integrator.
    #Useful if the timestep has to be reduced but an output at a specific interval
    #is still required. A save rate of 1 will save every dt, a save rate of 2 will
    #save every 2*dt    
    
    def summations_compile(sums):
        '''
        compiles any custom summations
        
        inputs:
            sums = list of summations [name of sum, calculation]
            
        returns:
            summation_dict = dictionary of summations {name of sum : compiled calculation}
        '''
        summation_dict={}
        for i in sums:
            summation_dict[i[0]]=compile(i[1],'<string>','eval')
        return summation_dict
    
    
    def summations_eval(summation_dict,density_dict,calc_dict):
        '''
        evaluates custom summations
        
        inputs:
            summation_dict = dictionary of summations {name of sum : compiled calculation}
            density_dict = dictionary of current species concentrations {species : concentration}
            calc_dict = dictionary of constants and variables for use in calculations
            
        returns:
            sums_dict = dictionary of evaluated sum calculations {name of sum : value}
        '''
        full_dict={**density_dict,**calc_dict}
        for spec in summation_dict.keys():
            sums_dict[spec]=(eval(summation_dict[spec],{},full_dict)) 
        return sums_dict
    
    
    def h2o_rh(time,temp,rel_humidity,numba_exp):
        '''
        calculates relative humidity and water at a given time and temperature
    
        inputs:
            time = current simulation time (s)
            temp = current temperature value (C)
            rel_humidity = current relative humidity (%), can be calculation
            numba_exp = exponent
            
        returns:
            h20 = water vapour
            rh = relative humidity (%)
        '''
        rh = rel_humidity 
        h2o=6.1078*numba_exp(-1.0e+0*(597.3-0.57*(temp-273.16))*18.0/1.986*
                       (1.0/temp-1.0/273.16))*10./(1.38e-16*temp)*rh               
        return h2o,rh
    
    
    def ppool_density_calc(density_dict,ppool):
        '''
        peroxy radical summation evaluation
        
        inputs:
            density_dict = dictionary of current concentrations
            ppool = list of species to be summed for RO2
        
        returns:
            RO2 = summed peroxy radical species
        '''
        RO2 = 0.
        for p in ppool:
            RO2 += eval(p,{},density_dict)
        return RO2
    
    
    def dy_calc(master_compiled,reaction_rate_dict,calc_dict,density_dict,outdoor_dict,\
                surface_dict,species,timed_dict):
        '''
        evaluating the master array of species
        
        inputs:
            master_compiled = dictionary of compiled ODEs
            reaction_rate_dict = dictionary of reaction rate values at current time
            calc_dict = dictionary of constants and variables for use in calculations
            density_dict = dictionary of current concentrations
            outdoor_dict = dictionary of outdoor species concentrations
            surface_dict = dictionary of surface deposition rates for each species
            species = list of species
            timed_dict = dictionary of rates for any timed inputs for current time
            
        returns:
            dy_dict = dictionary of changes in concentration for each species per second
        '''
        dy_dict={}    
        full_dict={**reaction_rate_dict,**calc_dict,**density_dict,**outdoor_dict,\
                   **surface_dict,**timed_dict}
        
        for specie in species:
            dy_dict[specie]=(eval(master_compiled[specie],{},full_dict))
        return dy_dict
    
    
    def dy_dy_calc(dy_dy_dict,J_dict,calc_dict,density_dict,species,outdoor_dict,\
                   surface_dict,num_species,timed_dict,reaction_rate_dict):
        '''
        Evaluating the Jacobian during integration
        
        inputs:
            dy_dy_dict = dictionary jacobian {index:[x,y,compiled calculation]}
            J_dict = dictionary of current photolysys values
            reaction_rate_dict = dictionary of reaction rate values at current time
            calc_dict = dictionary of constants and variables for use in calculations
            density_dict = dictionary of current concentrations
            outdoor_dict = dictionary of outdoor species concentrations
            surface_dict = dictionary of surface deposition rates for each species
            num_species = number of species
            
        returns:
            dy_dy = dictionary of values of species change with species per second
        '''
        dy_dy=np.zeros((num_species,num_species),dtype=np.float32) #twice as fast as lil_matrix
        
        full_dict={**reaction_rate_dict,**density_dict,**outdoor_dict,**surface_dict,\
                   **calc_dict,**timed_dict}
        for k,v in dy_dy_dict.items():
                dy_dy[v[0],v[1]]=eval(v[2],{},full_dict)
        return dy_dy
    
    
    def dydt(t,y0):
        '''
        The function to calculate dydt that is fed to the integrator
    
        inputs:
        	t = time
        	y0 = concentration of species
    
        returns:
        	dy = dictionary of change in species concentration with change in time
        '''
        #Update density dictionary
        for i in range(num_species):
            density_dict[species[i]]=y0[i]  
        density_dict['RO2']=ppool_density_calc(density_dict,ppool)
        
        #if summations are included they need to be updated to the density dictionary also           
        if summations == True:
            sums_dict = summations_eval(summations_dict,density_dict,calc_dict)
            density_dict.update(sums_dict)
            
        #n = time in seconds from midnight for each day
        n = t-((int(t/86400))*86400)
        
        # recalculate photolysis
        # COSX and SECX involve local hour angles dependant on position and time
        # of year (latitude of location and declination of sun)
    
        lha = (1+((n-time_correct)/4.32E+4))*pi     # local hour angle, radians. Midnight start
        cosx = ((numba_cos(lha)*cosld)+sinld)       # solar zenith angle 
        
        # Set negative cosx to zero and calculate the inverse  
        # (secx=1/cosx). The MCM photolysis parameterisation  
        # (http://mcm.leeds.ac.uk/MCM/parameters/photolysis_param.htt)  
        # requires cosx and secx to calculate the photolysis rates.
        if cosx <= 1E-30:
            cosx = 0.0  
            secx = 1.0E+30  
        else:  
            secx = 1.0 / (((cosx + numba_abs(cosx))/2)+1.0E-30) #no divison by 0
        
        #updates the relevant dictionary whether lights are on or off
        for i in light_on_times:
            if i[0] <= t <= i[1]:
                indoor_photo_dict["cosx"] = cosx
                indoor_photo_dict["secx"] = secx
                photolysis_J(indoor_photo_dict,photo_dict,J_dict)
                break
            else:
                indoor_photo_dict_off["cosx"] = cosx
                indoor_photo_dict_off["secx"] = secx
                photolysis_J(indoor_photo_dict_off,photo_dict,J_dict)
        
        #diurnal outdoor rates
        if diurnal == True:
            out_calc_dict["n"] = n
            out_calc_dict["cosx"] = cosx
            out_calc_dict["secx"] = secx
            outdoor_rates_calc(outdoor_dict,outdoor_dict_diurnal,out_calc_dict)
        
        #recalculate humidity,water
        h2o,rh = h2o_rh(t,temp,rel_humidity,numba_exp)
        calc_dict['h2o']=h2o
     
        #recalculate particle sums
        if particles == True:
            particle_dict = particle_calcs(part_calc_dict,density_dict)
            density_dict.update(particle_dict)
            
        #checks time, if between times set for a forced density change the rate
        #is applied to the specific species
        if timed_emissions == True:
            for key in timed_inputs:
                for i in timed_inputs[key]:
                    if i[0] <= t <= i[1]:
                        timed_dict["%s_timed" % key] = i[2]
                        break
                    else:
                        timed_dict["%s_timed" % key] = 0
        
        #recalculate reaction rates
        reaction_rate_dict=reaction_eval(reaction_number,J_dict,calc_dict,\
                                         density_dict,dt,reaction_compiled_dict,\
                                             outdoor_dict,surface_dict,\
                                                 timed_dict)
        
        #evaluate the mater array to recalculate concentrations
        dy_dict=dy_calc(master_compiled,reaction_rate_dict,calc_dict,density_dict,\
                        outdoor_dict,surface_dict,species,timed_dict)
        
        #output the new concentration values
        dy = [dy_dict[i] for i in species]
        return dy
    
    
    def dydy(t,y0): 
        '''
        The function to calculate the jacobian that is fed to the integrator
    
        inputs:
        	t = time
        	y0 = concentration of species
    
        returns:
        	dydy = array of change in species concentration with change 
        		   in other species concentrations
        '''
        #Update density dictionary
        for i in range(num_species):
            density_dict[species[i]]=y0[i]            
        density_dict['RO2']=ppool_density_calc(density_dict,ppool)
        
        #if summations are included they need to be updated to the density dictionary also            
        if summations == True:
            sums_dict = summations_eval(summations_dict,density_dict,calc_dict)
            density_dict.update(sums_dict)
        
        #n = time in seconds from midnight for each day
        n = t-((int(t/86400))*86400)
        
        # recalculate photolysis
        # COSX and SECX involve local hour angles dependant on position and time
        # of year (latitude of location and declination of sun)
    
        lha = (1+((n-time_correct)/4.32E+4))*pi     # local hour angle, radians. Midnight start
        cosx = ((numba_cos(lha)*cosld)+sinld)       # solar zenith angle 
        
        # Set negative cosx to zero and calculate the inverse  
        # (secx=1/cosx). The MCM photolysis parameterisation  
        # (http://mcm.leeds.ac.uk/MCM/parameters/photolysis_param.htt)  
        # requires cosx and secx to calculate the photolysis rates.
        if cosx <= 1E-30:
            cosx = 0.0  
            secx = 1.0E+30  
        else:  
            secx = 1.0 / (((cosx + numba_abs(cosx))/2)+1.0E-30) # no division by 0
        
        #updates the relevant dictionary whether lights are on or off
        for i in light_on_times:
            if i[0] <= t <= i[1]:
                indoor_photo_dict["cosx"] = cosx
                indoor_photo_dict["secx"] = secx
                photolysis_J(indoor_photo_dict,photo_dict,J_dict)
                break
            else:
                indoor_photo_dict_off["cosx"] = cosx
                indoor_photo_dict_off["secx"] = secx
                photolysis_J(indoor_photo_dict_off,photo_dict,J_dict)
        
        #diurnal outdoor rates
        if diurnal == True:
            out_calc_dict["n"] = n
            out_calc_dict["cosx"] = cosx
            out_calc_dict["secx"] = secx
            outdoor_rates_calc(outdoor_dict,outdoor_dict_diurnal,out_calc_dict)
        
        #recalculate temp,humidity,water
        h2o,rh = h2o_rh(t,temp,rel_humidity,numba_exp)
        calc_dict['h2o']=h2o
     
        #recalculate particle sums
        if particles == True:
            particle_dict = particle_calcs(part_calc_dict,density_dict)
            density_dict.update(particle_dict)
        
        #checks time, if between times set for a forced density change the rate
        #is applied to the specific species
        if timed_emissions == True:
            for key in timed_inputs:
                for i in timed_inputs[key]:
                    if i[0] <= t <= i[1]:
                        timed_dict["%s_timed" % key] = i[2]
                        break
                    else:
                        timed_dict["%s_timed" % key] = 0
                    
        #recalculate reaction rates
        reaction_rate_dict=reaction_eval(reaction_number,J_dict,calc_dict,density_dict,\
                                         dt,reaction_compiled_dict,outdoor_dict,\
                                             surface_dict,timed_dict)
        
        #recalculate jacobian
        dydy_jac=dy_dy_calc(dy_dy_dict,J_dict,calc_dict,density_dict,species,\
                            outdoor_dict,surface_dict,num_species,\
                                timed_dict,reaction_rate_dict)
        return dydy_jac
    
    def integrate_function(iters,t_bound_internal,y0,t0,ret,save_rate,num_species,\
                           total_iter,dt):
        '''
        Using lsoda to calculate density evolution and output as n_new
    
        inputs:
        	iters = number of iterations that have already been performed 
        			through the integrator, used to calculate when an output
        			is saved
        	t_bound_internal = the time to integrate to within this function (s)
        	y0 = initial species concentration
        	t0 = start time (s)
        	ret = integrator return code from scipy.integrate.ode.get_return_code
        		  set as 1 prior to calling the integrator
        	save_rate = how many iterations to perform before saving an output
        	num_species = the total number of species 
        	total_iter = the total number of iterations to be completed
        	dt = time step (s)
    
        returns:
        	dt_out = list of output times
        	n_new = array of output concentrations for each species at each time
        	iters = total number of iterations completed
        	ret = integrator return code from scipy.integrate.ode.get_return_code
        	iter_time = list of time stamps for the completion of each integration
        				over dt
        	calculated_output = dictionary of lists of calculated values for each
        						iteration. These are calculations done using the species
        						concentrations and are only for output purposes
        '''
        #assign arrays to populate
        n_new=[[] for i in range(num_species)]
        dt_out=[]
        iter_time=[]
        
        calculated_output = {}
        calculated_output['RO2'] = []
        if particles == True:
            calculated_output['tsp'] = []
            calculated_output['acidsum'] = []
            calculated_output['tspx'] = []
            calculated_output['mwomv'] = []
        for i in reactivity_dict:
            calculated_output[i] = []
        for i in production_dict:
            calculated_output[i] = []
        for i in J_dict:
            calculated_output[i] = []
        for i in outdoor_dict:
            calculated_output[i] = []
        if summations == True:
            for i in sums_dict:
                calculated_output[i] = []
        
        #set integrator args
        atol = [1e-6]*num_species     #Default 1e-6
        rtol = 1e-6                  #Default 1e-6
        first_step = 1e-10              #size of first integration step to try (s)
        nsteps = 5000                   #max number of internal timesteps
        max_step = dt                   #maximum time step allowed by integrator
        
        #set the integrator and arguments
        r=ode(dydt,dydy).set_integrator('lsoda',atol=atol,rtol=rtol,first_step=\
                                        first_step,nsteps=nsteps,max_step=max_step)
        r.set_initial_value(y0,t0)
        
        #integrate
        while r.successful() and r.t<t_bound_internal:
            print('Iteration ', iters+1,'/', total_iter,'¦',r.t,' to ',r.t+dt)
            r.integrate(r.t+dt)
            iters=iters+1
            ret=r.get_return_code()
            if iters % save_rate == 0: #output every save_rate iterations
                dt_out.append(int(r.t))
                iter_time.append(timing.time()-start_time)
                calculated_output['RO2'].append(density_dict["RO2"])
                reactivity_calc(reactivity_dict,reactivity_compiled,reaction_rate_dict,\
                                calc_dict,density_dict)
                production_calc(production_dict,production_compiled,reaction_rate_dict,\
                                calc_dict,density_dict)
                for i in reactivity_dict:
                    calculated_output[i].append(reactivity_dict[i])
                for i in production_dict:
                    calculated_output[i].append(production_dict[i])
                if particles == True:
                    calculated_output['tsp'].append(density_dict['tsp'])
                    calculated_output['acidsum'].append(density_dict['acidsum'])
                    calculated_output['tspx'].append(density_dict['tspx'])
                    calculated_output['mwomv'].append(density_dict['mwomv'])
                for i in range(num_species):
                    n_new[i].append(r.y[i])
                for i in J_dict:
                    calculated_output[i].append(J_dict[i])
                for i in outdoor_dict:
                    calculated_output[i].append(outdoor_dict[i])
                if summations == True:
                    for i in sums_dict:
                        calculated_output[i].append(density_dict[i])
        return dt_out,n_new,iters,ret,iter_time,calculated_output
       
    '''
    numba functions to increase speed of mathamatical operations
    '''
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_exp(x):
        return np.exp(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_cos(x):
        return np.cos(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_arctan(x):
        return np.arctan(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_sin(x):
        return np.sin(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_arccos(x):
        return np.arccos(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_sqrt(x):
        return np.sqrt(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_abs(x):
        return np.abs(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_log(x):
        return np.log(x)
    
    @nb.jit(nb.f8(nb.f8), nopython=True)
    def numba_log10(x):
        return np.log10(x)
        
    start_time=timing.time() #program start time
    
    '''
    setting the output folder in current working directory
    '''
    path=os.getcwd()
    now = datetime.datetime.now()
    output_folder = ("%s_%s" % (now.strftime("%Y%m%d_%H%M%S"), custom_name))
    os.mkdir('%s/%s' % (path,output_folder))
    with open('%s/__init__.py' % output_folder,'w') as f:
        pass
    
    print('Creating folder:', output_folder)
    
    '''
    Saving a copy of the settings and MCM files to the output folder
    '''
    from shutil import copyfile
    copyfile("settings.py", "%s/%s/settings.py" % (path,output_folder))
    copyfile(filename, "%s/%s/mcm.fac" % (path,output_folder))
    
    t_bound = t0+seconds_to_integrate #Maximum time to integrate to
    iters = 0 #the number of iterations that have been performed already (leave as 0)
    total_iter = math.ceil(int(t_bound-t0)/dt) #calculated to show the user how long is left   
    print('total iterations:', total_iter)
    
    
    '''
    calculate initial values
    '''
    h2o,rh = h2o_rh(t0,temp,rel_humidity,numba_exp)   
    
    species,ppool,rate_numba,reactions_numba=import_all(filename) #import from MCM download
    
    pi = 4.0*numba_arctan(1.0) #for photolysis and some rates
    
    # dictionary for evaluating the reaction rates
    calc_dict={'M':M,
           'numba_exp':numba_exp,
           'temp':temp,
           'numba_log10':numba_log10,
           'numba_sqrt':numba_sqrt,
           'H2O':h2o,
           'PI':pi,
           'HMIX':HMIX,
           'numba_abs':numba_abs}
    
    calc_dict.update(const_dict) # add constants from settings to calc_dict
    
    '''
    Particles
    '''
    particle_species=[]
    if particles == True:
        #if the full MCM is not being used then the calcuations for tsp and anything involving tsp
        #will fail so particles can only be used with the full MCM at the moment 04/2020
        particle_species, particle_reactions, particle_vap_dict, part_calc_dict = particle_import()
        species = species + particle_species #add particle species to species list
        reactions_numba = reactions_check(reactions_numba,particle_reactions,species)
        rate_numba = rate_numba + [['kacid' , '1.5e-32*numba_exp(14770/temp)']]
        calc_dict.update(particle_vap_dict)
    
    '''
    Custom reactions and rates. Those not in the MCM download, the code does not
    check this so please make sure you are not adding any reactions that already 
    exist as it will just duplicate them.
    '''
    sums = []
    if custom == True:
        custom_filename="custom_input.txt"
        custom_rates, custom_reactions, custom_species, custom_RO2, sums = \
            custom_import(custom_filename,species)
        # Check that rates/constants/RO2 have not been added as species
        custom_species = [item for item in custom_species
                          if item not in (['RO2'] + list(calc_dict.keys()) +
                                          [name[0] for name in rate_numba])]
        species = species + custom_species
        rate_numba = rate_numba + custom_rates
        reactions_numba = reactions_numba + custom_reactions
        ppool = ppool + custom_RO2
        copyfile("custom_input.txt", "%s/%s/custom_input.txt" % (path,output_folder))
     
    '''
    INCHEM reactions and rates that are not included in MCM download.
    '''    
    if INCHEM_additional == True:
        from modules.inchem_chemistry import INCHEM_RO2, INCHEM_reactions, \
            INCHEM_rates, INCHEM_sums
        INCHEM_species = INCHEM_species_calc(INCHEM_reactions,species)
        species = species + INCHEM_species
        ppool = ppool + INCHEM_RO2
        reactions_numba = reactions_numba + INCHEM_reactions
        rate_numba = rate_numba + INCHEM_rates
        sums.extend(INCHEM_sums)
        '''
        Write INCHEM inputs to output folder for future reference
        '''
        with open("%s/%s/INCHEM_inputs.txt" % (path,output_folder), 'w') as f:
            f.write('Species:\n')
            for i in INCHEM_species:
                f.write("%s\n" % i)
            f.write('RO2 species:\n')
            for i in INCHEM_RO2:
                f.write("%s\n" % i)
            f.write('Summations:\n')
            for i in INCHEM_sums:
                f.write("%s\n" % i)
            f.write('Rates:\n')
            for i in INCHEM_rates:
                f.write("%s\n" % i)
            f.write('Reactions:\n')
            for i in INCHEM_reactions:
                f.write("%s\n" % i)
    
    '''
    Additional clean up, checking for summations from custom inputs
    '''
    summations = False
    if custom == True or INCHEM_additional == True:
        if len(sums) >= 1:
            summations = True
           
    reaction_number=[]
    for i in range(len(reactions_numba)): #for assigning within the master array
        reaction_number.append('r%s' % i)
        
    #if it's in the calc dict it shouldn't be calculated in any of the integrations
    for i in calc_dict.keys():
        if i in species: 
            species.remove(i)
        for j in rate_numba:
            if j[0] == i:
                rate_numba.remove(j)
                print("%s from custom_input.txt ignored. Defined elsewhere." % i)
    
    
    '''
    Photolysis
    
    The simulation works on solar time of day and does not require any input 
    of longitude. However, if a comparison is being done with measured data then
    the time_correct variable can be used to shift the photolysis a number of
    seconds in either direction, this will also shift the outdoor photolysis
    used in some of the outdoor concentration calculations. Not all of the
    outdoor concentrations rely on this method of calculation so adjustments
    must also be made to any other outdoor rates and thus I do not recommend 
    using this method. I would instead adjust the full output after the run.
    '''
    #calculations for determining solar position given time of year    
    day, month, year = map(int, date.split('-'))
    date = datetime.date(year, month, day)
    year_day = (date - datetime.date(year, 1, 1)).days + 1
    days_in_year = (datetime.date(year,12,31) - datetime.date(year, 1, 1)).days + 1
    radian = 180.0/pi
    dec = -23.45 * np.cos(((360/days_in_year)/radian)*(year_day+10))
    
    lat = lat/radian #conversion to radians
    dec = dec/radian #conversion to radians
    
    time_correct = 0 #adjustment for correction of solar time to measured time
    
    #calculations for spherical law of cosines for solar zenith angle
    sinld = numba_sin(lat)*numba_sin(dec)
    cosld = numba_cos(lat)*numba_cos(dec)
    
    photo_dict=Zixu_photolysis_compiled() #compiled equations
    
    #full dictionary of attenuation factors for different lights/glass
    light_dict=Zixu_photolysis(numba_abs,numba_exp) 
    
    
    indoor_photo_dict={**light_dict[light_type],**light_dict[glass]}
    indoor_photo_dict_off={**light_dict["off"],**light_dict[glass]}
    
    n = t0-((int(t0/86400))*86400) # keeps time within 24 hour cycle 
    
    # COSX and SECX involve local hour angles dependant on position and time
    # of year (latitude of location and declination of sun)
    lha = (1+((n-time_correct)/4.32E+4))*pi    # local hour angle, radians. Midnight start
    cosx = ((numba_cos(lha)*cosld)+sinld) # solar zenith angle
     
    # (http://mcm.leeds.ac.uk/MCM/parameters/photolysis_param.htt)
    # Keep cosx 0 or positive, we don't have negative photolysis
    if cosx <= 1E-30:
        cosx = 0.0  
        secx = 1.0E+30  
    else:  
        secx = 1.0 / (((cosx + numba_abs(cosx))/2)+1.0E-30)
    
    light_on_times = [[j * 3600 for j in i]for i in light_on_times] #conversion to seconds
    
    J_dict = {}
    for i in light_on_times:
        if i[0] <= t0 <= i[1]:
            indoor_photo_dict["cosx"] = cosx
            indoor_photo_dict["secx"] = secx
            photolysis_J(indoor_photo_dict,photo_dict,J_dict)
            break
        else:
            indoor_photo_dict_off["cosx"] = cosx
            indoor_photo_dict_off["secx"] = secx
            photolysis_J(indoor_photo_dict_off,photo_dict,J_dict)
    
    '''
    Outdoor species concentration calculations
    '''        
    out_calc_dict = {"numba_abs":numba_abs,
                     "numba_exp":numba_exp,
                     "numba_cos":numba_cos,
                     "numba_sin":numba_sin,
                     "n":n,
                     "cosx":cosx,
                     "secx":secx}
    
    #Outdoor dictionaries
    outdoor_dict=outdoor_rates(AER,particles,species)
    if diurnal == True:
        outdoor_dict_diurnal = outdoor_rates_diurnal(city)
        outdoor_rates_calc(outdoor_dict,outdoor_dict_diurnal,out_calc_dict)
        #diurnal rates will overide static rates if species shown in both
    
    '''
    Surface deposition
    '''
    surface_dict=surface_deposition(HMIX)
    for specie in species:
        if particles == True and specie in particle_species:
            surface_dict['%s_SURF' % specie]=0.004*HMIX
        elif '%s_SURF' % specie not in surface_dict.keys():
            surface_dict['%s_SURF' % specie]=0
    
    '''
    timed concentrations
    '''
    timed_dict={}
    if timed_emissions == True:
        for specie in species:
            timed_dict["%s_timed" % specie] = 0
        for key in timed_inputs:
            if key in species:
                for i in timed_inputs[key]:
                    if i[0] <= t0 <= i[1]:
                        timed_dict["%s_timed" % key] = i[2]
                        break
                    else:
                        timed_dict["%s_timed" % key] = 0
            else:
                print('%s not found in species list (timed input)' % key)
    
    '''
    importing initial concentrations
    '''
    density_dict,calc_dict = initial_conditions(initial_conditions_gas,M,species,\
                                                rate_numba,calc_dict,particles,\
                                                    initials_from_run,t0,path)
    density_dict['RO2']=ppool_density_calc(density_dict,ppool)
    
    #calculating t0 summations
    summations_dict={}
    if summations == True:
        summations_dict = summations_compile(sums)
        sums_dict={}
        sums_dict=summations_eval(summations_dict,density_dict,calc_dict)
        density_dict.update(sums_dict)
    
    if particles == True:
        particle_dict = particle_calcs(part_calc_dict,density_dict)
        density_dict.update(particle_dict)
    
    '''    
    saving initial conditions to an output directory for reference
    '''
    f = open("%s/%s/initial_concentrations.txt" % (path,output_folder),"w")
    for i in species:
        f.write('%s=%s ;\n' % (i,density_dict[i]))
    f.close()
    
    '''
    Calculating the reaction rates and compiling the master array of ODEs
    '''
    num_species=len(species) #some calculations ask for the number of species
    #better to calculate it once rather than every time
    
    reaction_compiled_dict=reaction_rate_compile(reactions_numba,reaction_number)
    reaction_rate_dict=reaction_eval(reaction_number,J_dict,calc_dict,density_dict,\
                                     dt,reaction_compiled_dict,outdoor_dict,\
                                         surface_dict,timed_dict)
    
    #creating the master array
    master_array_dict=master_calc(reactions_numba,species,reaction_number,particles,\
                                  particle_species,timed_emissions)
    
    #saving the master array to the output folder
    with open('%s/%s/master_array.pickle' % (path,output_folder),'wb') as handle:
        pickle.dump(master_array_dict,handle)
    
    #compiling the master array
    master_compiled=master_compiler(master_array_dict,species)
    
    #Create the jacobian and save it to the output folder
    write_jacobian_build(master_array_dict,species,output_folder,path)
    
    #import the jacobian function to create the jacobian dictionary which is a
    #dictionary of compiled calculations
    spec = importlib.util.spec_from_file_location("jac.jacobian_calc",\
                                                  "%s/%s/Jacobian.py" % (path,output_folder))
    jac = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(jac)
    #jac = importlib.import_module(path+output_folder+".Jacobian")
    dy_dy_dict=jac.jacobian_calc(species) 
    
    # reactivity and production calculations, details in the reactivity.py script
    reactivity_compiled, production_compiled = reactivity_summation(master_array_dict)
    reactivity_dict = {}
    reactivity_calc(reactivity_dict,reactivity_compiled,reaction_rate_dict,calc_dict,\
                    density_dict)
    production_dict = {}
    production_calc(production_dict,production_compiled,reaction_rate_dict,calc_dict,\
                    density_dict)
     
    '''
    #Integration
    '''
    #Create an array of concentrations to be updated during the integration. This
    #can then be used to repopulate the dictionaries with updated values
    y0=[[] for i in range(num_species)]     
    for i in range(num_species):    
        y0[i]=density_dict[species[i]]
    
    #Create arrays for storing the output. 
    n_new=np.array([[y0[i]] for i in range(num_species)])
    dt_out=np.array([])
    dt_out=np.append(dt_out,int(t0)) 
    iter_time_tot=[timing.time()-start_time]
    calculated_output_tot = {}
    calculated_output_tot['RO2'] = [density_dict['RO2']]
    if particles == True:
        calculated_output_tot['tsp'] = [density_dict['tsp']]
        calculated_output_tot['acidsum'] = [density_dict['acidsum']]
        calculated_output_tot['tspx'] = [density_dict['tspx']]
        calculated_output_tot['mwomv'] = [density_dict['mwomv']]
    for i in reactivity_dict:
        calculated_output_tot[i] = [reactivity_dict[i]]
    for i in production_dict:
        calculated_output_tot[i] = [production_dict[i]]
    for i in J_dict:
        calculated_output_tot[i] = [J_dict[i]]
    for i in outdoor_dict:
        calculated_output_tot[i] = [outdoor_dict[i]]
    if summations == True:
        for i in sums_dict:
            calculated_output_tot[i] = [density_dict[i]]
    
    ret=1 #if ret=2 success. ODE return code
    
    print('Integration starting')
    
    with threadpool_limits(limits=4, user_api='blas'): #limits threads used by integration
        while iters < total_iter and ret > 0:  
                n_new_in = n_new[:,-1]
                dt_out_in = dt_out[-1]
                dt_out_temp,n_new_temp,iters,ret,iter_time,calculated_output=\
                    integrate_function(iters,t_bound,n_new_in,dt_out_in,ret,save_rate,\
                                       num_species,total_iter,dt)
                dt_out=np.append(dt_out,dt_out_temp)
                n_new=np.append(n_new,n_new_temp,axis=1)
                iter_time_tot.extend(iter_time)
                for x in calculated_output:
                    calculated_output_tot[x].extend(calculated_output[x])
                
    output_data = pd.DataFrame(np.transpose(n_new),columns=species,index=dt_out)
    output_data = output_data.join(pd.DataFrame(calculated_output_tot,index=dt_out))
    
    integration_times = pd.DataFrame(np.transpose(iter_time_tot),index=dt_out)
    
    end_time=timing.time()
    delta = datetime.timedelta(seconds=(end_time-start_time))
    print('Return code:', ret) #ODE return code
    print('Total run time =', str(delta - datetime.timedelta(microseconds=delta.microseconds)))
    
    print('Saving output')
    
    # saves all of the output data to the output folder
    with open('%s/%s/out_data.pickle' % (path,output_folder),'wb') as handle:
        pickle.dump(output_data,handle)  
        
    #saves times for integrating each time step to a csv, useful for
    #analysing slow points in the system
    integration_times.to_csv("%s/%s/integration_times.csv" % (path,output_folder))
    print('Output saved')
    if output_graph == True:
        # creates and saves a simple graph of the set species from settings
        import matplotlib.pyplot as plt
        from itertools import cycle
        plt.figure(dpi=600,figsize=(8,4))
        colour=iter(plt.cm.gist_rainbow(np.linspace(0,1,len(output_species))))
        linestyle=cycle(['solid','dotted','dashed','dashdot'])
        for x in output_species:
            c=next(colour)
            l=next(linestyle)
            plt.plot(output_data.index/3600,output_data[x],label=x,c=c,linestyle=l)
        plt.yscale("log")
        plt.legend(loc='upper center', bbox_to_anchor=(0.45, -0.15),
          fancybox=True, shadow=True, ncol=6)
        plt.xlabel("Time of day (hours)")
        plt.ylabel("Concentration (molecules/cm\N{SUPERSCRIPT THREE})")
        plt.savefig('%s/%s/graph.png' % (path,output_folder), bbox_inches='tight')

        # additionally saves a csv of these set species for easy analysis
        output_data.to_csv("%s/%s/output.csv" % (path,output_folder), columns = output_species)

        plt.show()

    return None