def calculate(params): #print("The critical N deposition rate is " + str(params.crit_dep) + " kg N ha-1 yr-1") # load needed variables for calculations biome = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "gnlct.asc"), numtype=float, mask=params.mask) a_tot = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "a_tot.asc"), numtype=float, mask=params.mask) nfix_ara = ascraster.Asciigrid( ascii_file=params.filename_nfixation_cropland, numtype=float, mask=params.mask) nfix_igl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_intgl, numtype=float, mask=params.mask) nox_em = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nox_em.asc"), numtype=float, mask=params.mask) nh3_tot_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_egl.asc"), numtype=float, mask=params.mask) nh3_tot_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_igl.asc"), numtype=float, mask=params.mask) nh3_tot_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_ara.asc"), numtype=float, mask=params.mask) nh3_ef_man_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_ara.asc"), numtype=float, mask=params.mask) nh3_ef_man_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_igl.asc"), numtype=float, mask=params.mask) nh3_ef_fer_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fer_ara.asc"), numtype=float, mask=params.mask) nh3_ef_fer_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fer_igl.asc"), numtype=float, mask=params.mask) frnfe_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_ara.asc"), numtype=float, mask=params.mask) frnfe_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_igl.asc"), numtype=float, mask=params.mask) fara = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fara.asc"), numtype=float, mask=params.mask) figl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "figl.asc"), numtype=float, mask=params.mask) fsro_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fsro_ag.asc"), numtype=float, mask=params.mask) frnup_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_ara.asc"), numtype=float, mask=params.mask) frnup_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_igl.asc"), numtype=float, mask=params.mask) nup_max_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nup_max_ara.asc"), numtype=float, mask=params.mask) nup_max_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nup_max_igl.asc"), numtype=float, mask=params.mask) nin_max_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nin_max_ara.asc"), numtype=float, mask=params.mask) nin_max_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nin_max_igl.asc"), numtype=float, mask=params.mask) # make grid with critical N deposition per biome ndep_crit_ha = ascraster.duplicategrid(nfix_ara) # watch out: can ndep_crit_ha become both -9999 and -1 (NA value?) for i in range(ndep_crit_ha.length): ndep_crit_ha.set_data(i, -9999) for icell in range(biome.length): val = biome.get_data(icell) # Ice (7) or Hot desert (16) if (val == 7 or val == 16): cl = 5.0 # Boreal forest (10), Cool coniferous forest (11) or scrubland (17) elif (val == 10 or val == 11 or val == 17): cl = 7.5 # Tundra (8) or wooded tundra (9)or Warm mixed forest (14) elif (val == 8 or val == 9 or val == 14): cl = 10.0 # Temperate mixed forest (12) Temperate deciduous forest (13) elif (val == 12 or val == 13): cl = 12.5 # Savanna (18) elif (val == 18): cl = 15.0 # Grassland/steppe (15) elif (val == 15): cl = 17.5 # Tropical woodland (19) or Tropical forest (20) elif (val == 19 or val == 20): cl = 20 # Biome can also have value 0 or none (-1) else: continue ndep_crit_ha.set_data(icell, cl) print_debug(biome, "biome =") fileout = os.path.join(params.outputdir, "ndep_crit_ha.asc") ndep_crit_ha.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_ha, "ndep_crit_ha =") ## * Total critical deposition * ndep_crit_tot = ascraster.duplicategrid(ndep_crit_ha) ndep_crit_tot.multiply(a_tot) fileout = os.path.join(params.outputdir, "ndep_crit_tot.asc") ndep_crit_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_tot, "ndep_crit_tot =") ## * Critical NH3 emissions * nh3em_ara_igl = ascraster.duplicategrid(nh3_tot_ara) nh3em_ara_igl.add(nh3_tot_igl) # 'ara' nh3_fraction_ara = ascraster.duplicategrid(nh3_tot_ara) nh3_fraction_ara.divide(nh3em_ara_igl, default_nodata_value=-9999) nh3em_crit_ara = ascraster.duplicategrid(ndep_crit_tot) nh3em_crit_ara.substract(nox_em) nh3em_crit_ara.substract(nh3_tot_egl) nh3em_crit_ara.multiply(nh3_fraction_ara) print_debug(nh3em_crit_ara, "nh3em_crit_ara =") # 'igl' nh3_fraction_igl = ascraster.duplicategrid(nh3_tot_igl) nh3_fraction_igl.divide(nh3em_ara_igl, default_nodata_value=-9999) nh3em_crit_igl = ascraster.duplicategrid(ndep_crit_tot) nh3em_crit_igl.substract(nox_em) nh3em_crit_igl.substract(nh3_tot_egl) nh3em_crit_igl.multiply(nh3_fraction_igl) print_debug(nh3em_crit_igl, "nh3em_crit_igl =") ## * Critical N inputs from manure * one_grid = ascraster.duplicategrid(frnfe_ara) for i in range(one_grid.length): one_grid.set_data(i, 1.0) # 'ara' one_min_frnfe_ara = ascraster.duplicategrid(one_grid) one_min_frnfe_ara.substract(frnfe_ara) frnfe_division_ara = ascraster.duplicategrid(frnfe_ara) frnfe_division_ara.divide(one_min_frnfe_ara, default_nodata_value=-9999) denominator_ara = ascraster.duplicategrid(frnfe_division_ara) denominator_ara.multiply(nh3_ef_fer_ara) denominator_ara.add(nh3_ef_man_ara) nman_crit_dep_ara = ascraster.duplicategrid(nh3em_crit_ara) nman_crit_dep_ara.divide(denominator_ara, default_nodata_value=-9999) for icell in range(nman_crit_dep_ara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) if (f_ara == 0 and f_igl > 0): nman_ara = 0 else: continue nman_crit_dep_ara.set_data(icell, nman_ara) for icell in range(nman_crit_dep_ara.length): nman_ara3 = nman_crit_dep_ara.get_data(icell) if (nman_ara3 is None): continue if (nman_ara3 < 0): nman_ara = 0 else: continue nman_crit_dep_ara.set_data(icell, nman_ara) fileout = os.path.join(params.outputdir, "nman_crit_dep_ara.asc") nman_crit_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nman_crit_dep_ara, "nman_crit_dep_ara =") # 'igl' one_min_frnfe_igl = ascraster.duplicategrid(one_grid) one_min_frnfe_igl.substract(frnfe_igl) frnfe_division_igl = ascraster.duplicategrid(frnfe_igl) frnfe_division_igl.divide(one_min_frnfe_igl, default_nodata_value=-9999) denominator_igl = ascraster.duplicategrid(frnfe_division_igl) denominator_igl.multiply(nh3_ef_fer_igl) denominator_igl.add(nh3_ef_man_igl) nman_crit_dep_igl = ascraster.duplicategrid(nh3em_crit_igl) nman_crit_dep_igl.divide(denominator_igl, default_nodata_value=-9999) for icell in range(nman_crit_dep_igl.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) if (f_igl == 0 and f_ara > 0): nman_igl = 0 else: continue nman_crit_dep_igl.set_data(icell, nman_igl) for icell in range(nman_crit_dep_igl.length): nman_igl3 = nman_crit_dep_igl.get_data(icell) if (nman_igl3 is None): continue if (nman_igl3 < 0): nman_igl = 0 else: continue nman_crit_dep_igl.set_data(icell, nman_igl) fileout = os.path.join(params.outputdir, "nman_crit_dep_igl.asc") nman_crit_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nman_crit_dep_igl, "nman_crit_dep_igl =") ## calculate critical N input from fertilizer # 'ara' nfer_crit_dep_ara = ascraster.duplicategrid(nman_crit_dep_ara) nfer_crit_dep_ara.multiply(frnfe_division_ara) for icell in range(nfer_crit_dep_ara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) if (f_ara == 0 and f_igl > 0): nfer_ara = 0 else: continue nfer_crit_dep_ara.set_data(icell, nfer_ara) fileout = os.path.join(params.outputdir, "nfer_crit_dep_ara.asc") nfer_crit_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nfer_crit_dep_ara, "nfer_crit_dep_ara =") # 'igl' nfer_crit_dep_igl = ascraster.duplicategrid(nman_crit_dep_igl) nfer_crit_dep_igl.multiply(frnfe_division_igl) for icell in range(nfer_crit_dep_igl.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) if (f_igl == 0 and f_ara > 0): nfer_igl = 0 else: continue nfer_crit_dep_igl.set_data(icell, nfer_igl) fileout = os.path.join(params.outputdir, "nfer_crit_dep_igl.asc") nfer_crit_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nfer_crit_dep_igl, "nfer_crit_dep_igl =") ## * Critical N inputs from fertilizer plus manure * ## # 'ara' nman_fer_crit_dep_ara = ascraster.duplicategrid(nman_crit_dep_ara) nman_fer_crit_dep_ara.add(nfer_crit_dep_ara) fileout = os.path.join(params.outputdir, "nman_fer_crit_dep_ara.asc") nman_fer_crit_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' nman_fer_crit_dep_igl = ascraster.duplicategrid(nman_crit_dep_igl) nman_fer_crit_dep_igl.add(nfer_crit_dep_igl) fileout = os.path.join(params.outputdir, "nman_fer_crit_dep_igl.asc") nman_fer_crit_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## * NH3 emissions at critical N input * # 'ara' nh3em_man_crit_dep_ara = ascraster.duplicategrid(nman_crit_dep_ara) nh3em_man_crit_dep_ara.multiply(nh3_ef_man_ara) nh3em_fer_crit_dep_ara = ascraster.duplicategrid(nfer_crit_dep_ara) nh3em_fer_crit_dep_ara.multiply(nh3_ef_fer_ara) nh3em_crit_dep_ara = ascraster.duplicategrid(nh3em_fer_crit_dep_ara) nh3em_crit_dep_ara.add(nh3em_man_crit_dep_ara) print_debug(nh3em_crit_dep_ara, "nh3em_crit_dep_ara =") # 'igl' nh3em_man_crit_dep_igl = ascraster.duplicategrid(nman_crit_dep_igl) nh3em_man_crit_dep_igl.multiply(nh3_ef_man_igl) nh3em_fer_crit_dep_igl = ascraster.duplicategrid(nfer_crit_dep_igl) nh3em_fer_crit_dep_igl.multiply(nh3_ef_fer_igl) nh3em_crit_dep_igl = ascraster.duplicategrid(nh3em_fer_crit_dep_igl) nh3em_crit_dep_igl.add(nh3em_man_crit_dep_igl) print_debug(nh3em_crit_dep_igl, "nh3em_crit_dep_igl =") ## * N deposition at critical N inputs * ndep_crit_dep_tot = ascraster.duplicategrid(nh3em_crit_dep_ara) ndep_crit_dep_tot.add(nh3em_crit_dep_igl) ndep_crit_dep_tot.add(nox_em) ndep_crit_dep_tot.add(nh3_tot_egl) fileout = os.path.join(params.outputdir, "ndep_crit_dep_tot.asc") ndep_crit_dep_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_dep_tot, "ndep_crit_dep_tot =") # 'ara' ndep_crit_dep_ara = ascraster.duplicategrid(ndep_crit_dep_tot) ndep_crit_dep_ara.multiply(fara) print_debug(ndep_crit_dep_ara, "ndep_crit_dep_ara =") # 'igl' ndep_crit_dep_igl = ascraster.duplicategrid(ndep_crit_dep_tot) ndep_crit_dep_igl.multiply(figl) print_debug(ndep_crit_dep_igl, "ndep_crit_dep_igl =") ## * Total critical N inputs * # 'ara' nin_crit_dep_ara = ascraster.duplicategrid(nman_crit_dep_ara) nin_crit_dep_ara.add(nfer_crit_dep_ara) nin_crit_dep_ara.add(ndep_crit_dep_ara) nin_crit_dep_ara.add(nfix_ara) fileout = os.path.join(params.outputdir, "nin_crit_dep_ara.asc") nin_crit_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_dep_ara, "nin_crit_dep_ara =") # 'igl' nin_crit_dep_igl = ascraster.duplicategrid(nman_crit_dep_igl) nin_crit_dep_igl.add(nfer_crit_dep_igl) nin_crit_dep_igl.add(ndep_crit_dep_igl) nin_crit_dep_igl.add(nfix_igl) fileout = os.path.join(params.outputdir, "nin_crit_dep_igl.asc") nin_crit_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_dep_igl, "nin_crit_dep_igl =") # 'ara+igl' nin_crit_dep_araigl = ascraster.duplicategrid(nin_crit_dep_ara) nin_crit_dep_araigl.add(nin_crit_dep_igl) fileout = os.path.join(params.outputdir, "nin_crit_dep_araigl.asc") nin_crit_dep_araigl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## * N surface runoff at critical N inputs * # 'ara' nsro_crit_dep_ara = ascraster.duplicategrid(nin_crit_dep_ara) nsro_crit_dep_ara.multiply(fsro_ag) print_debug(nsro_crit_dep_ara, "nsro_crit_dep_ara =") # 'igl' nsro_crit_dep_igl = ascraster.duplicategrid(nin_crit_dep_igl) nsro_crit_dep_igl.multiply(fsro_ag) print_debug(nsro_crit_dep_igl, "nsro_crit_dep_igl =") ## * N uptake at critical N inputs * # 'ara' nup_crit_dep_ara = ascraster.duplicategrid(nin_crit_dep_ara) nup_crit_dep_ara.substract(nsro_crit_dep_ara) nup_crit_dep_ara.multiply(frnup_ara) fileout = os.path.join(params.outputdir, "nup_crit_dep_ara.asc") nup_crit_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_dep_ara, "nup_crit_dep_ara =") # 'igl' nup_crit_dep_igl = ascraster.duplicategrid(nin_crit_dep_igl) nup_crit_dep_igl.substract(nsro_crit_dep_igl) nup_crit_dep_igl.multiply(frnup_igl) fileout = os.path.join(params.outputdir, "nup_crit_dep_igl.asc") nup_crit_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_dep_igl, "nup_crit_dep_igl =") ## * NUE at critical N inputs * # 'ara' nue_crit_dep_ara = ascraster.duplicategrid(nup_crit_dep_ara) nue_crit_dep_ara.divide(nin_crit_dep_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_crit_dep_ara.asc") nue_crit_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_crit_dep_ara, "nue_crit_dep_ara =") # 'igl' nue_crit_dep_igl = ascraster.duplicategrid(nup_crit_dep_igl) nue_crit_dep_igl.divide(nin_crit_dep_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_crit_dep_igl.asc") nue_crit_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_crit_dep_igl, "nue_crit_dep_igl =") ## * Maximum uptake fraction * # 'ara' fnup_max_dep_ara = ascraster.duplicategrid(nup_max_ara) fnup_max_dep_ara.divide(nup_crit_dep_ara) fileout = os.path.join(params.outputdir, "fnup_max_dep_ara.asc") fnup_max_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_max_dep_ara, "fnup_max_dep_ara =") # 'igl' fnup_max_dep_igl = ascraster.duplicategrid(nup_max_igl) fnup_max_dep_igl.divide(nup_crit_dep_igl) fileout = os.path.join(params.outputdir, "fnup_max_dep_igl.asc") fnup_max_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_max_dep_igl, "fnup_max_dep_igl =") ## * Correction factor for grid cells where Nup,crit > Nup,max * # 'ara' fnup_corr_dep_ara = ascraster.duplicategrid(nin_max_ara) fnup_corr_dep_ara.substract(nfix_ara) temp2_ara = ascraster.duplicategrid(nh3_tot_egl) temp2_ara.add(nox_em) temp2_ara.multiply(fara) fnup_corr_dep_ara.substract(temp2_ara) temp3_ara = ascraster.duplicategrid(nh3em_crit_dep_ara) temp3_ara.multiply(fara) temp3_ara.add(nman_crit_dep_ara) temp3_ara.add(nfer_crit_dep_ara) fnup_corr_dep_ara.divide(temp3_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_dep_ara.asc") fnup_corr_dep_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_dep_ara, "fnup_corr_dep_ara =") # 'igl' fnup_corr_dep_igl = ascraster.duplicategrid(nin_max_igl) fnup_corr_dep_igl.substract(nfix_igl) temp2_igl = ascraster.duplicategrid(nh3_tot_egl) temp2_igl.add(nox_em) temp2_igl.multiply(figl) fnup_corr_dep_igl.substract(temp2_igl) temp3_igl = ascraster.duplicategrid(nh3em_crit_dep_igl) temp3_igl.multiply(figl) temp3_igl.add(nman_crit_dep_igl) temp3_igl.add(nfer_crit_dep_igl) fnup_corr_dep_igl.divide(temp3_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_dep_igl.asc") fnup_corr_dep_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_dep_igl, "fnup_corr_dep_igl =") ########### FORWARD CALCULATIONS TO CHECK ########### if icell_debug < 0: pass else: fw = ndep_crit_dep_tot.get_data(icell_debug) bw = ndep_crit_tot.get_data(icell_debug) if fw is None: print( "FW/BW_TEST:_Forward_calculation_not_possible:_Nin,crit = None" ) else: fw = round(fw, 4) bw = round(bw, 4) if fw == bw: print("FW/BW_TEST = SUCCESFUL") else: print("FW/BW_TEST = NOT_SUCCESFUL")
def calculate(params): #print("The critical N deposition rate is " + str(params.crit_dep) + " kg N ha-1 yr-1") # load needed variables for calculations biome = ascraster.Asciigrid(ascii_file=os.path.join(params.inputdir,"gnlct.asc") ,numtype=float,mask=params.mask) a_tot = ascraster.Asciigrid(ascii_file=os.path.join(params.inputdir,"a_tot.asc") ,numtype=float,mask=params.mask) nox_em = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nox_em.asc") ,numtype=float,mask=params.mask) nh3_tot_egl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nh3_tot_egl.asc") ,numtype=float,mask=params.mask) nh3_ef_man_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nh3_ef_man_agri.asc") ,numtype=float,mask=params.mask) nh3_ef_fert_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nh3_ef_fert_agri.asc"),numtype=float,mask=params.mask) frnfe_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"frnfe_agri.asc") ,numtype=float,mask=params.mask) fagri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"fagri.asc") ,numtype=float,mask=params.mask) n_fix_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"n_fix_agri.asc") ,numtype=float,mask=params.mask) fsro_ag = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"fsro_ag.asc") ,numtype=float,mask=params.mask) frnup_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"frnup_agri.asc") ,numtype=float,mask=params.mask) n_up_max = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"n_up_max.asc") ,numtype=float,mask=params.mask) n_in_max = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"n_in_max.asc") ,numtype=float,mask=params.mask) # make grid with critical N deposition per biome ndep_crit_ha = ascraster.duplicategrid(n_fix_agri) # watch out: can ndep_crit_ha become both -9999 and -1 (NA value?) for i in range(ndep_crit_ha.length): ndep_crit_ha.set_data(i,-9999) for icell in range(biome.length): val = biome.get_data(icell) # Ice (7) or Hot desert (16) if (val == 7 or val == 16): cl = 5.0 # Boreal forest (10), Cool coniferous forest (11) or scrubland (17) elif (val == 10 or val == 11 or val == 17): cl = 7.5 # Tundra (8) or wooded tundra (9)or Warm mixed forest (14) elif (val == 8 or val == 9 or val == 14): cl = 10.0 # Temperate mixed forest (12) Temperate deciduous forest (13) elif (val == 12 or val == 13): cl = 12.5 # Savanna (18) elif (val == 18): cl = 15.0 # Grassland/steppe (15) elif (val == 15): cl = 17.5 # Tropical woodland (19) or Tropical forest (20) elif (val == 19 or val == 20): cl = 20 # Biome can also have value 0 or none (-1) else: continue ndep_crit_ha.set_data(icell,cl) print_debug(biome,"The biome ID is") fileout = os.path.join(params.outputdir,"ndep_crit_ha.asc") ndep_crit_ha.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_crit_ha,"The critical N deposition per hectare is") # calculate total critical deposition: Ndep,tot(crit) = Ndep,crit,ha * A ndep_crit_tot = ascraster.duplicategrid(ndep_crit_ha) ndep_crit_tot.multiply(a_tot) #fileout = os.path.join(params.outputdir,"ndep_crit_tot.asc") #ndep_crit_tot.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_crit_tot,"The total critical N deposition is") # calculate critical N input from manure nh3_em_crit_agri = ascraster.duplicategrid(ndep_crit_tot) nh3_em_crit_agri.substract(nox_em) nh3_em_crit_agri.substract(nh3_tot_egl) one_grid = ascraster.duplicategrid(frnfe_agri) for i in range(one_grid.length): one_grid.set_data(i,1.0) one_min_frnfe = ascraster.duplicategrid(one_grid) one_min_frnfe.substract(frnfe_agri) frnfe_division = ascraster.duplicategrid(frnfe_agri) frnfe_division.divide(one_min_frnfe, default_nodata_value = -9999) denominator = ascraster.duplicategrid(frnfe_division) denominator.multiply(nh3_ef_fert_agri) denominator.add(nh3_ef_man_agri) nman_crit_dep = ascraster.duplicategrid(nh3_em_crit_agri) nman_crit_dep.divide(denominator, default_nodata_value = -9999) for icell in range (nman_crit_dep.length): nman = nman_crit_dep.get_data(icell) if (nman is None): continue if (nman < 0): man = 0 else: continue nman_crit_dep.set_data(icell,man) fileout = os.path.join(params.outputdir,"nman_crit_dep.asc") nman_crit_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nman_crit_dep,"The critical N input from manure for the N deposition criterion is") # calculate critical N input from fertilizer nfert_crit_dep = ascraster.duplicategrid(nman_crit_dep) nfert_crit_dep.multiply(frnfe_division) fileout = os.path.join(params.outputdir,"nfert_crit_dep.asc") nfert_crit_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nfert_crit_dep,"The critical N input from fertilizer for the N deposition criterion is") # calculate related N deposition nh3em_man_crit_dep = ascraster.duplicategrid(nman_crit_dep) nh3em_man_crit_dep.multiply(nh3_ef_man_agri) fileout = os.path.join(params.outputdir,"nh3em_man_crit_dep.asc") nh3em_man_crit_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) nh3em_fert_crit_dep = ascraster.duplicategrid(nfert_crit_dep) nh3em_fert_crit_dep.multiply(nh3_ef_fert_agri) fileout = os.path.join(params.outputdir,"nh3em_fert_crit_dep.asc") nh3em_fert_crit_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) nh3em_crit_dep = ascraster.duplicategrid(nh3em_fert_crit_dep) nh3em_crit_dep.add(nh3em_man_crit_dep) # fileout = os.path.join(params.outputdir,"nh3em_crit_dep.asc") nh3em_crit_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) # #nh3em_crit_dep.add(nh3_tot_egl) ndep_crit_dep_tot = ascraster.duplicategrid(nh3em_crit_dep) ndep_crit_dep_tot.add(nox_em) ndep_crit_dep_tot.add(nh3_tot_egl) print_debug(ndep_crit_dep_tot,"The total critical N deposition for the N deposition criterion is") ndep_crit_dep_agri = ascraster.duplicategrid(ndep_crit_dep_tot) ndep_crit_dep_agri.multiply(fagri) print_debug(ndep_crit_dep_agri,"The critical N deposition on agricultural land for the N deposition criterion is") # calculate total critical N inputs wrt N deposition nin_crit_dep_agri = ascraster.duplicategrid(nman_crit_dep) nin_crit_dep_agri.add(nfert_crit_dep) nin_crit_dep_agri.add(ndep_crit_dep_agri) nin_crit_dep_agri.add(n_fix_agri) fileout = os.path.join(params.outputdir,"nin_crit_dep_agri.asc") nin_crit_dep_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nin_crit_dep_agri,"The total critical input to agriclture for the N deposition criterion is") # calculate N surface runoff at critical N inputs deposition nsro_crit_dep_agri = ascraster.duplicategrid(nin_crit_dep_agri) nsro_crit_dep_agri.multiply(fsro_ag) print_debug(nsro_crit_dep_agri,"The critical N surface runoff for the N deposition criterion is") # calculate N uptake at critical N inputs deposition nup_crit_dep_agri = ascraster.duplicategrid(nin_crit_dep_agri) nup_crit_dep_agri.substract(nsro_crit_dep_agri) nup_crit_dep_agri.multiply(frnup_agri) fileout = os.path.join(params.outputdir,"nup_crit_dep_agri.asc") nup_crit_dep_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nup_crit_dep_agri,"The N uptake for the N deposition criterion is") # calculate implied NUE nue_crit_dep_agri = ascraster.duplicategrid(nup_crit_dep_agri) nue_crit_dep_agri.divide(nin_crit_dep_agri, default_nodata_value = -9999) #fileout = os.path.join(params.outputdir,"nue_crit_dep_agri.asc") #nue_crit_dep_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_crit_dep_agri,"The NUE for the N deposition criterion is") # calculate maximum uptake fraction fnup_max_dep = ascraster.duplicategrid(n_up_max) fnup_max_dep.divide(nup_crit_dep_agri) fileout = os.path.join(params.outputdir,"fnup_max_dep.asc") fnup_max_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fnup_max_dep,"The fraction maximum uptake / critical uptake for deposition is") # calculate correction factor for those cases where critical N uptake exceeds max. N uptake fnup_corr_dep = ascraster.duplicategrid(n_in_max) fnup_corr_dep.substract(n_fix_agri) temp2 = ascraster.duplicategrid(nh3_tot_egl) temp2.add(nox_em) temp2.multiply(fagri) fnup_corr_dep.substract(temp2) temp3 = ascraster.duplicategrid(nh3em_crit_dep) temp3.multiply(fagri) temp3.add(nman_crit_dep) temp3.add(nfert_crit_dep) fnup_corr_dep.divide(temp3, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"fnup_corr_dep.asc") fnup_corr_dep.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fnup_corr_dep,"The correction factor for cases where Nup,crit>Nup,max is") ########### FORWARD CALCULATIONS TO CHECK ########### if icell_debug<0: pass else: fw = ndep_crit_dep_tot.get_data(icell_debug) bw = ndep_crit_tot.get_data(icell_debug) if fw is None: print("FW / BW TEST: Forward calculation not possible (Nin,crit=None)") else: fw = round(fw,4) bw = round(bw,4) if fw == bw: print("FW / BW TEST: SUCCESFUL") else: print("FW / BW TEST: NOT SUCCESFUL") ############################################################################################
def calculate_emission_per_person(params,isocode,regiondata_dict,PopNum): ''' Calculate the N and P emission per person with a GDP formula of van Drecht or use historical N and P emissions (based on FAO protein consumption). In the latter case, the van Drecht formula is used only in case of a future year. In case of FAO protein consumption the lost of N and P is also calculated. ''' # Initialisation of the output parameters. Nemiss = {} Pemiss = {} # Other declarations Nemiss_PopNum = {} Pemiss_PopNum = {} N_human_waste_other = {} P_human_waste_other = {} # Read protein consumption per person. protein = data_class.get_data(params.fileprotein,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=0.0) print_debug("Protein",protein) # Convert protein into N and P for key in isocode: Nemiss[key] = protein[key] * g_per_d_to_kg_per_yr * params.N_fraction_protein Pemiss[key] = params.fPN * Nemiss[key] print_debug("Nemiss",Nemiss) print_debug("Pemiss",Pemiss) # Read from file the sheet with the wasting at retail and the sheet for household level losses frac_retail_loss = data_class.get_data(params.file_retail_loss,year=params.year,sep=params.sep,isocode=isocode,method=1) frac_household_loss = data_class.get_data(params.file_household_loss,year=params.year,sep=params.sep,isocode=isocode,method=1) print_debug("frac_retail_loss",frac_retail_loss) print_debug("frac_household_loss",frac_household_loss) # Calculate the actual amount of N and P consumed. for key in isocode: Nval = Nemiss[key] Pval = Pemiss[key] Nemiss_PopNum[key] = Nval * PopNum[key] Pemiss_PopNum[key] = Pval * PopNum[key] Nemiss[key] *= (1.0 - frac_retail_loss[key]) * (1.0 - frac_household_loss[key]) * (1.0 - params.fraction_human_skin_loss) Pemiss[key] *= (1.0 - frac_retail_loss[key]) * (1.0 - frac_household_loss[key]) * (1.0 - params.fraction_human_skin_loss) N_human_waste_other[key] = Nval - Nemiss[key] P_human_waste_other[key] = Pval - Pemiss[key] # Add to global database regiondata.put2regiondata(Nemiss_PopNum,regiondata_dict,"Nemiss_PopNum") regiondata.put2regiondata(Pemiss_PopNum,regiondata_dict,"Pemiss_PopNum") regiondata.put2regiondata(N_human_waste_other,regiondata_dict,"N_human_waste_other") regiondata.put2regiondata(P_human_waste_other,regiondata_dict,"P_human_waste_other") # Print debug information to screen. print_debug("Nemiss of humans per person",Nemiss) print_debug("Pemiss of humans per person",Pemiss) print_debug("Nemiss of humans",Nemiss_PopNum) print_debug("Pemiss of humans",Pemiss_PopNum) print_debug("N_human_waste per person",N_human_waste_other) print_debug("P_human_waste per person",P_human_waste_other) return Nemiss,Pemiss
def calculate(params): #print("The critical N concentration in surface water is", params.crit_sw) # load needed variables for calculations nfix_ara = ascraster.Asciigrid( ascii_file=params.filename_nfixation_cropland, numtype=float, mask=params.mask) nfix_igl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_intgl, numtype=float, mask=params.mask) nallo = ascraster.Asciigrid( ascii_file=params.filename_n_point_alloch_matter, numtype=float, mask=params.mask) nww = ascraster.Asciigrid(ascii_file=params.filename_n_point_wastewater, numtype=float, mask=params.mask) naqua = ascraster.Asciigrid(ascii_file=params.filename_n_point_aquaculture, numtype=float, mask=params.mask) ndep_sw = ascraster.Asciigrid( ascii_file=params.filename_n_point_dep_surfacewater, numtype=float, mask=params.mask) nfix_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "nfix_grass_ext.asc"), numtype=float, mask=params.mask) nfix_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "nfix_nat.asc"), numtype=float, mask=params.mask) nup_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "n_up_grass_ext.asc"), numtype=float, mask=params.mask) q = ascraster.Asciigrid(ascii_file=os.path.join(params.inputdir, "q.asc"), numtype=float, mask=params.mask) npoint_tot = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "npoint_tot.asc"), numtype=float, mask=params.mask) nero_tot = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nero_tot.asc"), numtype=float, mask=params.mask) nload_fixed_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nload_fixed_ag.asc"), numtype=float, mask=params.mask) nload_fixed_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nload_fixed_nat.asc"), numtype=float, mask=params.mask) nload_var_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nload_var_ag.asc"), numtype=float, mask=params.mask) nload_var_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nload_var_nat.asc"), numtype=float, mask=params.mask) fle_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fle_ag.asc"), numtype=float, mask=params.mask) fle_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fle_nat.asc"), numtype=float, mask=params.mask) fsro_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fsro_ag.asc"), numtype=float, mask=params.mask) fsro_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fsro_nat.asc"), numtype=float, mask=params.mask) frnup_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_ara.asc"), numtype=float, mask=params.mask) frnup_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_igl.asc"), numtype=float, mask=params.mask) fgw_rec_le_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fgw_rec_le_ag.asc"), numtype=float, mask=params.mask) fgw_rec_le_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fgw_rec_le_nat.asc"), numtype=float, mask=params.mask) nox_em = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nox_em.asc"), numtype=float, mask=params.mask) nh3_tot_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_egl.asc"), numtype=float, mask=params.mask) nh3_ef_man_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_ara.asc"), numtype=float, mask=params.mask) nh3_ef_man_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_igl.asc"), numtype=float, mask=params.mask) nh3_ef_fer_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fer_ara.asc"), numtype=float, mask=params.mask) nh3_ef_fer_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fer_igl.asc"), numtype=float, mask=params.mask) nh3_ef_man_fer_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_fer_ara.asc"), numtype=float, mask=params.mask) nh3_ef_man_fer_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_fer_igl.asc"), numtype=float, mask=params.mask) frnfe_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_ara.asc"), numtype=float, mask=params.mask) frnfe_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_igl.asc"), numtype=float, mask=params.mask) frn_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frn_ara.asc"), numtype=float, mask=params.mask) frn_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frn_igl.asc"), numtype=float, mask=params.mask) fara = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fara.asc"), numtype=float, mask=params.mask) figl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "figl.asc"), numtype=float, mask=params.mask) fegl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fegl.asc"), numtype=float, mask=params.mask) fnat = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fnat.asc"), numtype=float, mask=params.mask) nup_max_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nup_max_ara.asc"), numtype=float, mask=params.mask) nup_max_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nup_max_igl.asc"), numtype=float, mask=params.mask) nin_max_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nin_max_ara.asc"), numtype=float, mask=params.mask) nin_max_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nin_max_igl.asc"), numtype=float, mask=params.mask) nman_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nman_egl.asc"), numtype=float, mask=params.mask) ## One grid one_grid = ascraster.duplicategrid(nfix_ara) for i in range(one_grid.length): one_grid.set_data(i, 1.0) # calculate Nload,crit,sw =Q*Nconc,sw(crit) nload_crit_sw = ascraster.duplicategrid(q) nload_crit_sw.multiply(params.crit_sw) fileout = os.path.join(params.outputdir, "nload_crit_sw.asc") nload_crit_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nload_crit_sw, "nload_crit_sw =") # calculate fixed N load to surface water nload_fixed_tot = ascraster.duplicategrid(nallo) nload_fixed_tot.add(nero_tot) nload_fixed_tot.add(nload_fixed_nat) print_debug(nload_fixed_tot, "nload_fixed_tot =") nload_var_ag_nat = ascraster.duplicategrid(nload_var_ag) nload_var_ag_nat.add(nload_var_nat) nload_var_other = ascraster.duplicategrid(nww) nload_var_other.add(naqua) nload_var_other.add(ndep_sw) nload_var_other.add( nload_fixed_ag ) # is zero if combined with scenario 1 (all ag. N load = variable) nload_var_tot = ascraster.duplicategrid(nload_var_ag_nat) nload_var_tot.add(nload_var_other) nload_var_ag_nat_percent = ascraster.duplicategrid(nload_var_ag_nat) nload_var_ag_nat_percent.divide(nload_var_tot, default_nodata_value=-9999) nload_var_other_percent = ascraster.duplicategrid(nload_var_other) nload_var_other_percent.divide(nload_var_tot, default_nodata_value=-9999) nload_var_crit_tot = ascraster.duplicategrid(nload_crit_sw) nload_var_crit_tot.substract(nload_fixed_tot) nload_var_crit_ag_nat = ascraster.duplicategrid(nload_var_crit_tot) nload_var_crit_ag_nat.multiply(nload_var_ag_nat_percent) nload_var_crit_other = ascraster.duplicategrid(nload_var_crit_tot) nload_var_crit_other.multiply(nload_var_other_percent) ## Parameter 'v' # 'ara' v_ara_part1 = ascraster.duplicategrid(fgw_rec_le_ag) v_ara_part1.multiply(fle_ag) v_ara_part2 = ascraster.duplicategrid(v_ara_part1) v_ara_part2.multiply(frnup_ara) v_ara_part3 = ascraster.duplicategrid(v_ara_part2) v_ara_part3.multiply(fsro_ag) v_ara_part4 = ascraster.duplicategrid(fgw_rec_le_ag) v_ara_part4.multiply(fle_ag) v_ara_part4.multiply(fsro_ag) v_ara = ascraster.duplicategrid(v_ara_part1) v_ara.substract(v_ara_part2) v_ara.add(v_ara_part3) v_ara.substract(v_ara_part4) v_ara.add(fsro_ag) print_debug(v_ara, "v_ara =") # 'igl' v_igl_part1 = ascraster.duplicategrid(fgw_rec_le_ag) v_igl_part1.multiply(fle_ag) v_igl_part2 = ascraster.duplicategrid(v_igl_part1) v_igl_part2.multiply(frnup_igl) v_igl_part3 = ascraster.duplicategrid(v_igl_part2) v_igl_part3.multiply(fsro_ag) v_igl_part4 = ascraster.duplicategrid(fgw_rec_le_ag) v_igl_part4.multiply(fle_ag) v_igl_part4.multiply(fsro_ag) v_igl = ascraster.duplicategrid(v_igl_part1) v_igl.substract(v_igl_part2) v_igl.add(v_igl_part3) v_igl.substract(v_igl_part4) v_igl.add(fsro_ag) print_debug(v_igl, "v_igl =") ## parameter 'w' # 'egl' w_egl_part1 = ascraster.duplicategrid(fgw_rec_le_ag) w_egl_part1.multiply(fle_ag) w_egl_part2 = ascraster.duplicategrid(w_egl_part1) w_egl_part2.multiply(fsro_ag) w_egl = ascraster.duplicategrid(w_egl_part1) w_egl.substract(w_egl_part2) w_egl.add(fsro_ag) print_debug(w_egl, "w_egl =") # 'nat' w_nat_part1 = ascraster.duplicategrid(fgw_rec_le_nat) w_nat_part1.multiply(fle_nat) w_nat_part2 = ascraster.duplicategrid(w_nat_part1) w_nat_part2.multiply(fsro_nat) w_nat = ascraster.duplicategrid(w_nat_part1) w_nat.substract(w_nat_part2) w_nat.add(fsro_nat) print_debug(w_nat, "w_nat =") ## parameter 'y1' y1_part1 = ascraster.duplicategrid(nfix_ara) y1_part1.multiply(v_ara) y1_part2 = ascraster.duplicategrid(nfix_igl) y1_part2.multiply(v_igl) y1_part3 = ascraster.duplicategrid(nfix_egl) y1_part3.add(nman_egl) y1_part3.multiply(w_egl) y1_part4 = ascraster.duplicategrid(nfix_nat) y1_part4.multiply(w_nat) y1 = ascraster.duplicategrid(y1_part1) y1.add(y1_part2) y1.add(y1_part3) y1.add(y1_part4) print_debug(y1, "y1 =") ## parameter 'y2' y2_part1 = ascraster.duplicategrid(fara) y2_part1.multiply(v_ara) y2_part2 = ascraster.duplicategrid(figl) y2_part2.multiply(v_igl) y2_part3 = ascraster.duplicategrid(fegl) y2_part3.multiply(w_egl) y2_part4 = ascraster.duplicategrid(fnat) y2_part4.multiply(w_nat) y2 = ascraster.duplicategrid(y2_part1) y2.add(y2_part2) y2.add(y2_part3) y2.add(y2_part4) print_debug(y2, "y2 =") # calculate parameter 'z' # 'ara' (LET OP: for z_ara, we use frn_igl!) one_min_frn_igl = ascraster.duplicategrid(one_grid) one_min_frn_igl.substract(frn_igl) z_ara = ascraster.duplicategrid(frn_igl) z_ara.divide(one_min_frn_igl, default_nodata_value=-9999) print_debug(z_ara, "z_ara =") # 'igl' (LET OP: for z_igl, we use frn_ara!) one_min_frn_ara = ascraster.duplicategrid(one_grid) one_min_frn_ara.substract(frn_ara) z_igl = ascraster.duplicategrid(frn_ara) z_igl.divide(one_min_frn_ara, default_nodata_value=-9999) print_debug(z_igl, "z_igl =") # calculate parameter 'x' # ara x_ara_part1 = ascraster.duplicategrid(y2) x_ara_part1.multiply(nh3_ef_man_fer_ara) x_ara = ascraster.duplicategrid(y2) x_ara.multiply(nh3_ef_man_fer_igl) x_ara.add(v_igl) x_ara.multiply(z_ara) x_ara.add(x_ara_part1) x_ara.add(v_ara) print_debug(x_ara, "x_ara =") # igl x_igl_part1 = ascraster.duplicategrid(y2) x_igl_part1.multiply(nh3_ef_man_fer_igl) x_igl = ascraster.duplicategrid(y2) x_igl.multiply(nh3_ef_man_fer_ara) x_igl.add(v_ara) x_igl.multiply(z_igl) x_igl.add(x_igl_part1) x_igl.add(v_igl) print_debug(x_igl, "x_igl =") ## calculate critical N input from manure ## OPTION2 - for grid cells with BOTH 'ara' AND 'igl' # 'ara' numerator_V2_ara = ascraster.duplicategrid(nload_var_crit_ag_nat) n1_V2_ara = ascraster.duplicategrid(nox_em) n1_V2_ara.add(nh3_tot_egl) n1_V2_ara.multiply(y2) numerator_V2_ara.substract(y1) numerator_V2_ara.substract(n1_V2_ara) one_min_frnfe_ara = ascraster.duplicategrid(one_grid) one_min_frnfe_ara.substract(frnfe_ara) frnfe_division_ara = ascraster.duplicategrid(frnfe_ara) frnfe_division_ara.divide(one_min_frnfe_ara, default_nodata_value=-9999) denominator_V2_ara = ascraster.duplicategrid(frnfe_division_ara) denominator_V2_ara.add(one_grid) denominator_V2_ara.multiply(x_ara) nman_crit_sw_V2_ara = ascraster.duplicategrid(numerator_V2_ara) nman_crit_sw_V2_ara.divide(denominator_V2_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_sw_V2_ara.asc") nman_crit_sw_V2_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' numerator_V2_igl = ascraster.duplicategrid(numerator_V2_ara) one_min_frnfe_igl = ascraster.duplicategrid(one_grid) one_min_frnfe_igl.substract(frnfe_igl) frnfe_division_igl = ascraster.duplicategrid(frnfe_igl) frnfe_division_igl.divide(one_min_frnfe_igl, default_nodata_value=-9999) denominator_V2_igl = ascraster.duplicategrid(frnfe_division_igl) denominator_V2_igl.add(one_grid) denominator_V2_igl.multiply(x_igl) nman_crit_sw_V2_igl = ascraster.duplicategrid(numerator_V2_igl) nman_crit_sw_V2_igl.divide(denominator_V2_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_sw_V2_igl.asc") nman_crit_sw_V2_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## OPTION 2 - for grid cells with EITHER 'ara' OR 'igl' # 'ara' numerator_V1_ara = ascraster.duplicategrid(numerator_V2_ara) n1_V1_ara = ascraster.duplicategrid(nup_egl) n1_V1_ara.multiply(fgw_rec_le_ag) n1_V1_ara.multiply(fle_ag) numerator_V1_ara.add(n1_V1_ara) d1_V1_ara = ascraster.duplicategrid(nh3_ef_man_ara) d1_V1_ara.multiply(y2) d1_V1_ara.add(v_ara) d2_V1_ara = ascraster.duplicategrid(nh3_ef_fer_ara) d2_V1_ara.multiply(y2) d2_V1_ara.add(v_ara) d2_V1_ara.multiply(frnfe_division_ara) denominator_V1_ara = ascraster.duplicategrid(d1_V1_ara) denominator_V1_ara.add(d2_V1_ara) nman_crit_sw_V1_ara = ascraster.duplicategrid(numerator_V1_ara) nman_crit_sw_V1_ara.divide(denominator_V1_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_sw_V1_ara.asc") nman_crit_sw_V1_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' numerator_V1_igl = ascraster.duplicategrid(numerator_V1_ara) d1_V1_igl = ascraster.duplicategrid(nh3_ef_man_igl) d1_V1_igl.multiply(y2) d1_V1_igl.add(v_igl) d2_V1_igl = ascraster.duplicategrid(nh3_ef_fer_igl) d2_V1_igl.multiply(y2) d2_V1_igl.add(v_ara) d2_V1_igl.multiply(frnfe_division_igl) denominator_V1_igl = ascraster.duplicategrid(d1_V1_igl) denominator_V1_igl.add(d2_V1_igl) nman_crit_sw_V1_igl = ascraster.duplicategrid(numerator_V1_igl) nman_crit_sw_V1_igl.divide(denominator_V1_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_sw_V1_igl.asc") nman_crit_sw_V1_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # MAKE GRID WITH CRITICAL INPUTS FROM MANURE DEPENDING ON OPTION # ara nman_crit_sw_ara = ascraster.duplicategrid(nman_crit_sw_V1_ara) for icell in range(fara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) nman_ara2 = nman_crit_sw_V2_ara.get_data(icell) if (f_ara is None or f_igl is None): continue elif (f_ara > 0 and f_igl > 0): nman_ara = nman_ara2 elif (f_ara == 0 and f_igl > 0): nman_ara = 0 else: continue nman_crit_sw_ara.set_data(icell, nman_ara) for icell in range(nman_crit_sw_ara.length): nman_ara3 = nman_crit_sw_ara.get_data(icell) if (nman_ara3 is None): continue if (nman_ara3 < 0): nman_ara = 0 else: continue nman_crit_sw_ara.set_data(icell, nman_ara) fileout = os.path.join(params.outputdir, "nman_crit_sw_ara.asc") nman_crit_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nman_crit_sw_ara, "nman_crit_sw_ara =") # igl nman_crit_sw_igl = ascraster.duplicategrid(nman_crit_sw_V1_igl) for icell in range(figl.length): f_igl = figl.get_data(icell) f_ara = fara.get_data(icell) nman_igl2 = nman_crit_sw_V2_igl.get_data(icell) if (f_ara is None or f_igl is None): continue elif (f_ara > 0 and f_igl > 0): nman_igl = nman_igl2 elif (f_ara > 0 and f_igl == 0): nman_igl = 0 else: continue nman_crit_sw_igl.set_data(icell, nman_igl) for icell in range(nman_crit_sw_igl.length): nman_igl3 = nman_crit_sw_igl.get_data(icell) if (nman_igl3 is None): continue if (nman_igl3 < 0): nman_igl = 0 else: continue nman_crit_sw_igl.set_data(icell, nman_igl) fileout = os.path.join(params.outputdir, "nman_crit_sw_igl.asc") nman_crit_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nman_crit_sw_igl, "nman_crit_sw_igl =") ## * Critical N input from fertilizer * # 'ara' nfer_crit_sw_ara = ascraster.duplicategrid(nman_crit_sw_ara) nfer_crit_sw_ara.multiply(frnfe_division_ara) # set to zero for all cells with no ara but igl (to avoid error in calculating nh3 emissions / deposition for these cells) for icell in range(nfer_crit_sw_ara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) nfer_ara = nfer_crit_sw_ara.get_data(icell) if (f_ara == 0 and f_igl > 0): nfer_ara = 0 else: continue nfer_crit_sw_ara.set_data(icell, nfer_ara) fileout = os.path.join(params.outputdir, "nfer_crit_sw_ara.asc") nfer_crit_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nfer_crit_sw_ara, "nfer_crit_sw_ara =") # 'igl' nfer_crit_sw_igl = ascraster.duplicategrid(nman_crit_sw_igl) nfer_crit_sw_igl.multiply(frnfe_division_igl) # set to zero for all cells with no igl but ara (to avoid error in calculating nh3 emissions / deposition for these cells) for icell in range(nfer_crit_sw_igl.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) nfer_igl = nfer_crit_sw_igl.get_data(icell) if (f_igl == 0 and f_ara > 0): nfer_igl = 0 else: continue nfer_crit_sw_igl.set_data(icell, nfer_igl) fileout = os.path.join(params.outputdir, "nfer_crit_sw_igl.asc") nfer_crit_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nfer_crit_sw_igl, "nfer_crit_sw_igl =") ## * Critical N inputs from fertilizer plus manure * ## # 'ara' nman_fer_crit_sw_ara = ascraster.duplicategrid(nman_crit_sw_ara) nman_fer_crit_sw_ara.add(nfer_crit_sw_ara) fileout = os.path.join(params.outputdir, "nman_fer_crit_sw_ara.asc") nman_fer_crit_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' nman_fer_crit_sw_igl = ascraster.duplicategrid(nman_crit_sw_igl) nman_fer_crit_sw_igl.add(nfer_crit_sw_igl) fileout = os.path.join(params.outputdir, "nman_fer_crit_sw_igl.asc") nman_fer_crit_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## * NH3 emissions at critical N input * # 'ara' nh3em_man_crit_sw_ara = ascraster.duplicategrid(nman_crit_sw_ara) nh3em_man_crit_sw_ara.multiply(nh3_ef_man_ara) nh3em_fer_crit_sw_ara = ascraster.duplicategrid(nfer_crit_sw_ara) nh3em_fer_crit_sw_ara.multiply(nh3_ef_fer_ara) nh3em_crit_sw_ara = ascraster.duplicategrid(nh3em_man_crit_sw_ara) nh3em_crit_sw_ara.add(nh3em_fer_crit_sw_ara) print_debug(nh3em_crit_sw_ara, "nh3em_crit_sw_ara =") # 'igl' nh3em_man_crit_sw_igl = ascraster.duplicategrid(nman_crit_sw_igl) nh3em_man_crit_sw_igl.multiply(nh3_ef_man_igl) nh3em_fer_crit_sw_igl = ascraster.duplicategrid(nfer_crit_sw_igl) nh3em_fer_crit_sw_igl.multiply(nh3_ef_fer_igl) nh3em_crit_sw_igl = ascraster.duplicategrid(nh3em_man_crit_sw_igl) nh3em_crit_sw_igl.add(nh3em_fer_crit_sw_igl) print_debug(nh3em_crit_sw_igl, "nh3em_crit_sw_igl =") ## * N deposition at critical N input * ndep_crit_sw_tot = ascraster.duplicategrid(nh3em_crit_sw_ara) ndep_crit_sw_tot.add(nh3em_crit_sw_igl) ndep_crit_sw_tot.add(nox_em) ndep_crit_sw_tot.add(nh3_tot_egl) fileout = os.path.join(params.outputdir, "ndep_crit_sw_tot.asc") ndep_crit_sw_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_sw_tot, "ndep_crit_sw_tot =") # 'ara' ndep_crit_sw_ara = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_ara.multiply(fara) print_debug(ndep_crit_sw_ara, "ndep_crit_sw_ara =") # 'igl' ndep_crit_sw_igl = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_igl.multiply(figl) print_debug(ndep_crit_sw_igl, "ndep_crit_sw_igl =") # 'nat' ndep_crit_sw_nat = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_nat.multiply(fnat) print_debug(ndep_crit_sw_nat, "ndep_crit_sw_nat =") # 'egl' ndep_crit_sw_egl = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_egl.multiply(fegl) print_debug(ndep_crit_sw_egl, "ndep_crit_sw_egl =") ## * Total critical N inputs * # 'ara' nin_crit_sw_ara = ascraster.duplicategrid(nman_crit_sw_ara) nin_crit_sw_ara.add(nfer_crit_sw_ara) nin_crit_sw_ara.add(ndep_crit_sw_ara) nin_crit_sw_ara.add(nfix_ara) fileout = os.path.join(params.outputdir, "nin_crit_sw_ara.asc") nin_crit_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_sw_ara, "nin_crit_sw_ara =") # 'igl' nin_crit_sw_igl = ascraster.duplicategrid(nman_crit_sw_igl) nin_crit_sw_igl.add(nfer_crit_sw_igl) nin_crit_sw_igl.add(ndep_crit_sw_igl) nin_crit_sw_igl.add(nfix_igl) fileout = os.path.join(params.outputdir, "nin_crit_sw_igl.asc") nin_crit_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_sw_igl, "nin_crit_sw_igl =") # 'ara+igl' nin_crit_sw_araigl = ascraster.duplicategrid(nin_crit_sw_ara) nin_crit_sw_araigl.add(nin_crit_sw_igl) fileout = os.path.join(params.outputdir, "nin_crit_sw_araigl.asc") nin_crit_sw_araigl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'nat' nin_crit_sw_nat = ascraster.duplicategrid(ndep_crit_sw_nat) nin_crit_sw_nat.add(nfix_nat) print_debug(nin_crit_sw_nat, "nin_crit_sw_nat =") # 'egl' nin_crit_sw_egl = ascraster.duplicategrid(ndep_crit_sw_egl) nin_crit_sw_egl.add(nfix_egl) nin_crit_sw_egl.add(nman_egl) print_debug(nin_crit_sw_egl, "nin_crit_sw_egl =") ## * N surface runoff at critical N inputs * # 'ara' nsro_crit_sw_ara = ascraster.duplicategrid(nin_crit_sw_ara) nsro_crit_sw_ara.multiply(fsro_ag) print_debug(nsro_crit_sw_ara, "nsro_crit_sw_ara =") # 'igl' nsro_crit_sw_igl = ascraster.duplicategrid(nin_crit_sw_igl) nsro_crit_sw_igl.multiply(fsro_ag) print_debug(nsro_crit_sw_igl, "nsro_crit_sw_igl =") # 'nat' nsro_crit_sw_nat = ascraster.duplicategrid(nin_crit_sw_nat) nsro_crit_sw_nat.multiply(fsro_nat) print_debug(nsro_crit_sw_nat, "nsro_crit_sw_nat =") # 'egl' nsro_crit_sw_egl = ascraster.duplicategrid(nin_crit_sw_egl) nsro_crit_sw_egl.multiply(fsro_ag) print_debug(nsro_crit_sw_egl, "nsro_crit_sw_egl =") ## * N uptake at critical N inputs * # 'ara' nup_crit_sw_ara = ascraster.duplicategrid(nin_crit_sw_ara) nup_crit_sw_ara.substract(nsro_crit_sw_ara) nup_crit_sw_ara.multiply(frnup_ara) fileout = os.path.join(params.outputdir, "nup_crit_sw_ara.asc") nup_crit_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_sw_ara, "nup_crit_sw_ara =") # 'igl' nup_crit_sw_igl = ascraster.duplicategrid(nin_crit_sw_igl) nup_crit_sw_igl.substract(nsro_crit_sw_igl) nup_crit_sw_igl.multiply(frnup_igl) fileout = os.path.join(params.outputdir, "nup_crit_sw_igl.asc") nup_crit_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_sw_igl, "nup_crit_sw_igl =") ## * NUE at critical N inputs * # 'ara' nue_crit_sw_ara = ascraster.duplicategrid(nup_crit_sw_ara) nue_crit_sw_ara.divide(nin_crit_sw_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_crit_sw_ara.asc") nue_crit_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_crit_sw_ara, "nue_crit_sw_ara =") # 'igl' nue_crit_sw_igl = ascraster.duplicategrid(nup_crit_sw_igl) nue_crit_sw_igl.divide(nin_crit_sw_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_crit_sw_igl.asc") nue_crit_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_crit_sw_igl, "nue_crit_sw_igl =") ## * Maximum uptake fraction * # 'ara' fnup_max_sw_ara = ascraster.duplicategrid(nup_max_ara) fnup_max_sw_ara.divide(nup_crit_sw_ara) fileout = os.path.join(params.outputdir, "fnup_max_sw_ara.asc") fnup_max_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_max_sw_ara, "fnup_max_sw_ara =") # 'igl' fnup_max_sw_igl = ascraster.duplicategrid(nup_max_igl) fnup_max_sw_igl.divide(nup_crit_sw_igl) fileout = os.path.join(params.outputdir, "fnup_max_sw_igl.asc") fnup_max_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_max_sw_igl, "fnup_max_sw_igl =") ## * Correction factor for grid cells where Nup,crit > Nup,max * # 'ara' fnup_corr_sw_ara = ascraster.duplicategrid(nin_max_ara) fnup_corr_sw_ara.substract(nfix_ara) temp2_ara = ascraster.duplicategrid(nh3_tot_egl) temp2_ara.add(nox_em) temp2_ara.multiply(fara) fnup_corr_sw_ara.substract(temp2_ara) temp3_ara = ascraster.duplicategrid(nh3em_crit_sw_ara) temp3_ara.multiply(fara) temp3_ara.add(nman_crit_sw_ara) temp3_ara.add(nfer_crit_sw_ara) fnup_corr_sw_ara.divide(temp3_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_sw_ara.asc") fnup_corr_sw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_sw_ara, "fnup_corr_sw_ara =") # 'igl' fnup_corr_sw_igl = ascraster.duplicategrid(nin_max_igl) fnup_corr_sw_igl.substract(nfix_igl) temp2_igl = ascraster.duplicategrid(nh3_tot_egl) temp2_igl.add(nox_em) temp2_igl.multiply(figl) fnup_corr_sw_igl.substract(temp2_igl) temp3_igl = ascraster.duplicategrid(nh3em_crit_sw_igl) temp3_igl.multiply(figl) temp3_igl.add(nman_crit_sw_igl) temp3_igl.add(nfer_crit_sw_igl) fnup_corr_sw_igl.divide(temp3_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_sw_igl.asc") fnup_corr_sw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_sw_igl, "fnup_corr_sw_igl =") ########### FORWARD CALCULATIONS TO CHECK ########### ## * Critical N budget * # 'ara' nbud_crit_sw_ara = ascraster.duplicategrid(nin_crit_sw_ara) nbud_crit_sw_ara.substract(nup_crit_sw_ara) print_debug(nbud_crit_sw_ara, "nbud_crit_sw_ara =") # 'igl' nbud_crit_sw_igl = ascraster.duplicategrid(nin_crit_sw_igl) nbud_crit_sw_igl.substract(nup_crit_sw_igl) print_debug(nbud_crit_sw_igl, "nbud_crit_sw_igl =") # 'nat' nbud_crit_sw_nat = ascraster.duplicategrid(nin_crit_sw_nat) print_debug(nbud_crit_sw_nat, "nbud_crit_sw_nat =") # 'egl' nbud_crit_sw_egl = ascraster.duplicategrid(nin_crit_sw_egl) nbud_crit_sw_egl.substract(nup_egl) print_debug(nbud_crit_sw_egl, "nbud_crit_sw_egl =") ## * Critical leaching * # 'ara' nle_crit_sw_ara = ascraster.duplicategrid(nbud_crit_sw_ara) nle_crit_sw_ara.substract(nsro_crit_sw_ara) nle_crit_sw_ara.multiply(fle_ag) print_debug(nle_crit_sw_ara, "nle_crit_sw_ara =") # 'igl' nle_crit_sw_igl = ascraster.duplicategrid(nbud_crit_sw_igl) nle_crit_sw_igl.substract(nsro_crit_sw_igl) nle_crit_sw_igl.multiply(fle_ag) print_debug(nle_crit_sw_igl, "nle_crit_sw_igl =") # 'nat' nle_crit_sw_nat = ascraster.duplicategrid(nbud_crit_sw_nat) nle_crit_sw_nat.substract(nsro_crit_sw_nat) nle_crit_sw_nat.multiply(fle_nat) print_debug(nle_crit_sw_nat, "nle_crit_sw_nat =") # 'egl' nle_crit_sw_egl = ascraster.duplicategrid(nbud_crit_sw_egl) nle_crit_sw_egl.substract(nsro_crit_sw_egl) nle_crit_sw_egl.multiply(fle_ag) print_debug(nle_crit_sw_egl, "nle_crit_sw_egl =") ## * groundwater N load from recent inputs * # 'ara' ngw_rec_crit_sw_ara = ascraster.duplicategrid(nle_crit_sw_ara) ngw_rec_crit_sw_ara.multiply(fgw_rec_le_ag) print_debug(ngw_rec_crit_sw_ara, "ngw_rec_crit_sw_ara =") # 'igl' ngw_rec_crit_sw_igl = ascraster.duplicategrid(nle_crit_sw_igl) ngw_rec_crit_sw_igl.multiply(fgw_rec_le_ag) print_debug(ngw_rec_crit_sw_igl, "ngw_rec_crit_sw_igl =") # 'nat' ngw_rec_crit_sw_nat = ascraster.duplicategrid(nle_crit_sw_nat) ngw_rec_crit_sw_nat.multiply(fgw_rec_le_nat) print_debug(ngw_rec_crit_sw_nat, "ngw_rec_crit_sw_nat =") # 'egl' ngw_rec_crit_sw_egl = ascraster.duplicategrid(nle_crit_sw_egl) ngw_rec_crit_sw_egl.multiply(fgw_rec_le_ag) print_debug(ngw_rec_crit_sw_egl, "ngw_rec_crit_sw_egl =") ## * Variable critical N load to surface water * # 'ara' nload_var_crit_sw_ara = ascraster.duplicategrid(nsro_crit_sw_ara) nload_var_crit_sw_ara.add(ngw_rec_crit_sw_ara) print_debug(nload_var_crit_sw_ara, "nload_var_crit_sw_ara =") # 'igl' nload_var_crit_sw_igl = ascraster.duplicategrid(nsro_crit_sw_igl) nload_var_crit_sw_igl.add(ngw_rec_crit_sw_igl) print_debug(nload_var_crit_sw_igl, "nload_var_crit_sw_igl =") # 'nat' nload_var_crit_sw_nat = ascraster.duplicategrid(nsro_crit_sw_nat) nload_var_crit_sw_nat.add(ngw_rec_crit_sw_nat) print_debug(nload_var_crit_sw_nat, "nload_var_crit_sw_nat =") # 'egl' nload_var_crit_sw_egl = ascraster.duplicategrid(nsro_crit_sw_egl) nload_var_crit_sw_egl.add(ngw_rec_crit_sw_egl) print_debug(nload_var_crit_sw_egl, "nload_var_crit_sw_egl =") ## * calculate n load tot crit sw TEST * nload_crit_sw_test = ascraster.duplicategrid(nload_var_crit_sw_ara) nload_crit_sw_test.add(nload_var_crit_sw_igl) nload_crit_sw_test.add(nload_var_crit_sw_nat) nload_crit_sw_test.add(nload_var_crit_sw_egl) nload_crit_sw_test.add(nload_var_crit_other) nload_crit_sw_test.add(nload_fixed_tot) fileout = os.path.join(params.outputdir, "nload_crit_sw_test.asc") nload_crit_sw_test.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ########### FORWARD CALCULATIONS TO CHECK ########### if icell_debug < 0: pass else: fw = nload_crit_sw_test.get_data(icell_debug) bw = nload_crit_sw.get_data(icell_debug) #print(fw) #print(bw) if fw is None: print( "FW/BW_TEST:_Forward_calculation_not_possible:_Nin,crit = None" ) else: fw = round(fw, 2) bw = round(bw, 2) if fw == bw: print("FW/BW_TEST = SUCCESFUL") else: print("FW/BW_TEST = NOT_SUCCESFUL")
def calculate(params,mask,isocode,isogrid): ''' Allocation of fertilizer on the basis of agricultural landarea grid. The new map of agricultural land in km2 is returned as well as the N and P fertilizer. ''' # Read region codes (regcodes) reggrid = ascraster.Asciigrid(ascii_file=params.fileregion,mask=mask,numtype=int) # Make a list of isocodes for the provinces. regcode = list(set(reggrid.values)) # Read P fertilizer per region, missing regions are set to zero. Pfert_reg = data_class.get_data(params.filePfertuse,year=params.year,sep=params.sep,isocode=regcode,method=0,weighing=0.0) print_debug("Pfert_reg",Pfert_reg) # Read N fertilizer per region, missing regions are set to zero. Nfert_reg = data_class.get_data(params.fileNfertuse,year=params.year,sep=params.sep,isocode=regcode,method=0,weighing=0.0) print_debug("Nfert_reg",Nfert_reg) # Read agricultural land per province, missing provinces are set to zero. agri_area_table = data_class.get_data(params.filefertarea,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=0.0) print_debug("agri_area_table",agri_area_table) # Read the basic map with the amount of agricultural land in km2 per grid cell agriland = ascraster.Asciigrid(ascii_file=params.fileagrilandarea,mask=mask,numtype=float) # Read the basic map with the amount of land in km2 per grid cell arealand = ascraster.Asciigrid(ascii_file=params.landarea,mask=mask,numtype=float) # Create two output grids with zeros and fill these with the ranking method. agri_area = ascraster.duplicategrid(agriland) agri_area.add_values(agri_area.length * [0.0]) Pfert = ascraster.duplicategrid(agri_area) Nfert = ascraster.duplicategrid(agri_area) # Make a dictionairy of pointers for all the isocodes in the grid. pointer_dict = {} for icell in xrange(isogrid.length): iso = isogrid.get_data(icell) if (iso != None): iso = int(iso) try: pointer_dict[iso].append(icell) except KeyError: pointer_dict[iso] = [icell] for key in isocode: # Select agricultural land of the key country # First step is to allocate the agricultural area for each province. weight_key = [] qmax_key = [] try: pointer1 = pointer_dict[key] except KeyError: pointer1 = [] sumqmax = 0.0 sumweight = 0.0 for icell in pointer1: area = agriland.get_data(icell,0.0) maxarea = arealand.get_data(icell,0.0) # Fill weighing data and max data qmax_key.append(maxarea) weight_key.append(area) sumqmax += qmax_key[-1] sumweight += weight_key[-1] if (sumweight < 0.0001): # Make uniform weighing to all cells. for icell in range(len(weight_key)): weight_key[icell] = 1 sumweight += weight_key[icell] # Take the table information on agricultural area. area_demand = agri_area_table[key] if (area_demand > sumqmax): raise MyError("It is not possible to allocate " + str(area_demand) + " km2 in provincenumber " + str(key),\ "Maximum area that is possible to allocate in this province is: "+str(sumqmax)) # Do the allocation area_new = allocweighing.allocweighing(area_demand,sumweight,weight_key,qmax_key) if (abs(sum(area_new) - agri_area_table[key]) > 0.001*agri_area_table[key]): print "***** There is not enough allocated for agri_area for region "+str(key)+". Difference: " + str(agri_area_table[key]-sum(area_new)) print "***** Needed for agri_area for region "+str(key)+" " + str(agri_area_table[key]) # Fill gridded result for item in xrange(len(area_new)): agri_area.set_data(pointer1[item],area_new[item]) # Now the fertilizer is allocated to the gridcells, based on agricultural land area. This means that # each grid cell will have another load but the same application rate (kg N/ha) pointer_dict = {} for icell in xrange(reggrid.length): iso = reggrid.get_data(icell) if (iso != None): iso = int(iso) try: pointer_dict[iso].append(icell) except KeyError: pointer_dict[iso] = [icell] for key in regcode: weight_key = [] qmax_key = [] try: pointer1 = pointer_dict[key] except KeyError: pointer1 = [] sumqmax = 0.0 sumweight = 0.0 for icell in pointer1: # Note the new map of the previous step is used here. area = agri_area.get_data(icell,0.0) maxarea = 10000000. # Fill weighing data and max data qmax_key.append(maxarea) weight_key.append(area) sumqmax += qmax_key[-1] sumweight += weight_key[-1] if (sumweight < 0.0001): # Make uniform weighing to all cells. for icell in range(len(weight_key)): weight_key[icell] = 1 sumweight += weight_key[icell] # Grid these country connected population data with help of the population density map fert_demand = Nfert_reg[key] fert_new = allocweighing.allocweighing(fert_demand,sumweight,weight_key,qmax_key) if (abs(sum(fert_new) - Nfert_reg[key]) > 0.001*Nfert_reg[key]): print "***** There is not enough allocated for Nfert_reg for region "+str(key)+". Difference: " + str(Nfert_reg[key]-sum(fert_new)) print "***** Needed for Nfert_reg for region "+str(key)+" " + str(Nfert_reg[key]) # Fill gridded result for item in xrange(len(fert_new)): Nfert.set_data(pointer1[item],fert_new[item]) for key in regcode: weight_key = [] qmax_key = [] try: pointer1 = pointer_dict[key] except KeyError: pointer1 = [] sumqmax = 0.0 sumweight = 0.0 for icell in pointer1: # Note the new map of the previous step is used here. area = agri_area.get_data(icell,0.0) maxarea = 10000000. # Fill weighing data and max data qmax_key.append(maxarea) weight_key.append(area) sumqmax += qmax_key[-1] sumweight += weight_key[-1] if (sumweight < 0.0001): # Make uniform weighing to all cells. for icell in range(len(weight_key)): weight_key[icell] = 1 sumweight += weight_key[icell] # Grid these country connected population data with help of the population density map fert_demand = Pfert_reg[key] # Change fertilizer from P2O5 to P fert_demand *= 62.0/142.0 fert_new = allocweighing.allocweighing(fert_demand,sumweight,weight_key,qmax_key) if (abs(sum(fert_new) - Pfert_reg[key]* 62.0/142.0) > 0.001*Pfert_reg[key]* 62.0/142.0): print "***** There is not enough allocated for Pfert_reg for region "+str(key)+". Difference: " + str(Pfert_reg[key]* (62.0/142.0)-sum(fert_new)) print "***** Needed for Pfert_reg for region "+str(key)+" " + str(Pfert_reg[key]) # Fill gridded result for item in xrange(len(fert_new)): Pfert.set_data(pointer1[item],fert_new[item]) # Write to output file agri_area.write_ascii_file(params.fileagri_area) Nfert.write_ascii_file(params.fileNfert) Pfert.write_ascii_file(params.filePfert) total = sum(agri_area.values) print "Total agricultural area in km2: ",total print "Total N fertilzer in kg N: ",sum(Nfert.values) print "Total P fertilizer in kg P: ",sum(Pfert.values) print "Total N fertilzer in kg N/ha: ",sum(Nfert.values)/(100*total) print "Total P fertilizer in kg P/ha: ",sum(Pfert.values)/(100*total) return agri_area,Nfert,Pfert
def read_popnum(params,mask,isogrid,isocode): ''' Read population numbers from grid or from table. If it is given on a table then a weighing grid is needed to allocate the population on the grid. Table and grid is returned. ''' # Scale the population of timescen so that the # total population of the region is correct. PopNum = data_class.get_data(params.filePopNum,year=params.year,sep=params.sep) # PopNum is given in thousand people. So we have to multiply by 1000 for key in PopNum: PopNum[key] *= 1000 # Add isocodes when they are not in list isocode for key in PopNum: try: qq=isocode.index(key) except ValueError: # Isocode found which is not taken into account print "ISOCODE " + str(key) +" is not used for number of people: " + str(PopNum[key]) + " people are missed." PopNum[key] = 0.0 # Add popnum for missing isocodes. Population is zero for key in isocode: try: qq=PopNum[key] except KeyError: # New iso code found. PopNum[key] = 0.0 print "Number of people read : " + str(sum(PopNum.itervalues())) + " is found." print_debug("PopNum in read_popnum",PopNum) # Read population number grid which is used to scale the table population numbers information popgrid_scale = ascraster.Asciigrid(ascii_file=params.filePopNumgrid,mask=mask,numtype=float) # Read land area landarea = ascraster.Asciigrid(ascii_file=params.landarea,mask=mask,numtype=float) # Make new population number grid zero popgrid = ascraster.duplicategrid(popgrid_scale) popgrid.add_values(popgrid.length * [0.0]) # Make a dictionary of pointers for all the isocodes in the grid. pointer_dict = {} for icell in xrange(isogrid.length): iso = isogrid.get_data(icell) if (iso != None): iso = int(iso) try: pointer_dict[iso].append(icell) except KeyError: pointer_dict[iso] = [icell] for key in isocode: if (PopNum[key] <= 0.): print "WEIGHING: table population is ZERO in region: " + str(key) continue # Select population of the key country weight_key = [] qmax_key = [] try: pointer1 = pointer_dict[key] except KeyError: print "Key: " + str(key) + " is not found in the isogrid." print "Table information of population numbers is changed for region: " + str(int(key)) +\ " from " + str(PopNum[key]) + " to 0.0" continue sumqmax = 0.0 sumweight = 0.0 for icell in pointer1: pop = popgrid_scale.get_data(icell,0.0) # Fill weighing data and max data qmax_key.append(params.max_popdens * landarea.get_data(icell,0.0)) weight_key.append(pop) sumqmax += qmax_key[-1] sumweight += weight_key[-1] # Warn for possible errors if (sumweight <= 0.): print "WEIGHING: grid population is ZERO in region: " + str(key) if (len(weight_key) > 0): # There are cells on the grid for this region. So make a uniform distribution weight_key = len(weight_key) * [1.0] sumweight = sum(weight_key) if (sumqmax < PopNum[key]): print "WEIGHING: PopNum ",PopNum[key], " is bounded by sumqmax",sumqmax, " in region: " + str(key) # Grid these country population data with help of the popgrid_scale map PopNum_reg = PopNum[key] popnum_new = allocweighing.allocweighing(PopNum_reg,sumweight,weight_key,qmax_key) if (key == debug_code): sum1 = 0.0 for item in xrange(len(popnum_new)): sum1 += popnum_new[item] print "New population number: ",sum1 # Fill gridded result sum1 = 0.0 for item in xrange(len(popnum_new)): popgrid.set_data(pointer1[item],popnum_new[item]) sum1 += popnum_new[item] # Check whether the table information has landed in the popgrid if (math.fabs(sum1 - PopNum[key]) > 0.01): print "Table information of population numbers is changed for region: " + str(int(key)) +\ " from " + str(PopNum[key]) + " to " + str(sum1) print "Total number of people: " + str(sum(PopNum.itervalues())) + " is found." return PopNum,popgrid
def run_pointsrc_model(args): ''' Run point sources model main routine @param listargs: list of arguments passed trough command-line or other script Must look like sys.argv so make sure is starts with scriptname. ''' # Parse command-line arguments and set parameters for script try: param = cmd_options_pointsrc.InputPointsrc(args) params = param.options params_var = param.options_var except SystemExit: raise MyError("Error has occured in the reading of the commandline options.") # Start timer and logging s = my_sys.SimpleTimer() log = my_logging.Log(params.outputdir,"%s_%i.log" % (params.scenarioname,params.year)) print "Log will be written to %s" % log.logFile # If no arguments are provided do a run with defaults in params if len(args) == 0: log.write_and_print("No arguments provided: starting default run...") # time start of run log.write_and_print("Starting run....") log.write("# Parameters used:",print_time=False,lcomment=False) for option in str(params_var).split(", "): log.write("--%s = %s" % (option.split(": ")[0].strip("{").strip("'"), option.split(": ")[1].strip("}").strip("'")), print_time=False,lcomment=False) log.write("All parameters used:") for option in str(params).split(", "): log.write("# %s = %s" % (option.split(": ")[0].strip("{").strip("'"), option.split(": ")[1].strip("}").strip("'")), print_time=False,lcomment=False) log.write("# End of all parameters used.",print_time=False,lcomment=False) # Check whether there are command-line arguments which are not used if (len(param.args) > 0): txt = "The following command line arguments will not be used:" log.write_and_print(txt + str(param.args)) # Write svn information of input and scripts to log file. log.write("******************************************************",print_time=False,lcomment=True) log.write("Version information:",print_time=False,lcomment=True) log.write("Version information main script:",print_time=False,lcomment=True) log.write("Revision $LastChangedDate: 2013-09-25 13:37:10 +0200 (Tue, 25 Sep 2013)",print_time=False,lcomment=True) log.write("Date $LastChangedRevision: 344 $",print_time=False,lcomment=True) #message = get_versioninfo.get_versioninfo(params.inputdir,params.outputdir) #message.extend(get_versioninfo.get_versioninfo("tools",params.outputdir)) #for item in range(len(message)): # log.write(str(message[item]),print_time=False,lcomment=True) log.write("******************************************************",print_time=False,lcomment=True) # Read mask of the input grids. We take the iso grid as mask for this. # The mask takes care to do the calculations on an efficient way. Only # the grid cells which are in the mask are calculated and stored. if (params.lmask): mask = ascraster.create_mask(params.file_mask, 0.0,'GT',numtype=float) log.write_and_print(s.interval("Reading mask")) else: mask = None log.write_and_print(s.interval("No mask is used for this simulation.")) # Make a list of all district codes that we want to calculate # Could be done by reading a grid, but now it is done by reading a input file with a complet set of isocodes. isocode = make_iso_list.make_iso_list(params,mask) # Read provence codes (isocodes) isogrid = ascraster.Asciigrid(ascii_file=params.fileiso,mask=mask,numtype=int) # Read total number of population PopNumTot,popgrid, = read_popnum.read_popnum(params,mask,isogrid,isocode) print_debug("PopNumTot",PopNumTot) # Calculate the coastal population. PopNum_coast,popgrid_coast = coast_population.calculate(params,mask,isogrid,isocode,popgrid) # Calculation of number of people without hte coastal population PopNum = {} for key in isocode: PopNum[key] = PopNumTot[key] - PopNum_coast[key] # Create regiondata class regiondata_dict = create_regiondata.create_regiondata(params,isocode) regiondata.put2regiondata(PopNumTot,regiondata_dict,"PopNum") regiondata.put2regiondata(PopNum_coast,regiondata_dict,"PopNum_coast") print_debug("PopNum_without_coast",PopNum) print_debug("PopNum_coast",PopNum_coast) # Determine the N and P emission per person. Nemiss,Pemiss = calculate_emission_per_person.calculate_emission_per_person(params,isocode,regiondata_dict,PopNumTot) log.write_and_print(s.interval("Ready with calculation of N and P emission per capita.")) # Calculation of N and P emissionto the coastal zone N_emiss_coast = {} P_emiss_coast = {} for key in isocode: N_emiss_coast[key] = PopNum_coast[key] * Nemiss[key] P_emiss_coast[key] = PopNum_coast[key] * Pemiss[key] regiondata.put2regiondata(N_emiss_coast,regiondata_dict,"N_emiss_coast") regiondata.put2regiondata(P_emiss_coast,regiondata_dict,"P_emiss_coast") print_debug("N_emiss_coast",N_emiss_coast) print_debug("P_emiss_coast",P_emiss_coast) # Read the percentage urban population. PopUrb = data_class.get_data(params.filePopUrb,year=params.year,sep=params.sep,isocode=isocode,method=1) print_debug("PopUrb",PopUrb) # Calculatation of urban and connected number of people PopUrbNum = {} for key in isocode: PopUrbNum[key] = PopNum[key] * (PopUrb[key]/100.0) regiondata.put2regiondata(PopUrbNum,regiondata_dict,"PopUrbNum") print_debug("PopUrbNum",PopUrbNum) # Calculatation of connected number of people # Read the percentage of the connected population. PopCon = data_class.get_data(params.filePopCon,year=params.year,sep=params.sep,isocode=isocode,method=1) print_debug("PopCon",PopCon) PopConNum = {} for key in isocode: PopConNum[key] = PopNum[key] * (PopCon[key]/100.0) regiondata.put2regiondata(PopConNum,regiondata_dict,"PopConNum") print_debug("PopConNum",PopConNum) # Get P emissions in kg P per year per inhabitant from laundry detergents and from dishwasher detergents. EmPldet = data_class.get_data(params.filePlaundry,year=params.year,sep=params.sep,isocode=isocode,method=1) EmPddet = data_class.get_data(params.filePdishwasher,year=params.year,sep=params.sep,isocode=isocode,method=1) # Add to global database regiondata.put2regiondata(EmPldet,regiondata_dict,"EmPldet") regiondata.put2regiondata(EmPddet,regiondata_dict,"EmPddet") print_debug("EmPldet",EmPldet) print_debug("EmPddet",EmPddet) # Calculation of industry emission to surface water Nemiss_industry,Pemiss_industry = industry_emission.calculate(params,isocode,regiondata_dict,PopNumTot,\ Nemiss,Pemiss,EmPldet,EmPddet,PopUrbNum,PopConNum) log.write_and_print(s.interval("Ready with calculation of N and P emission from industry.")) # Read the percentage of the primary, secondary and tertiary treatment. PrimTreatment = data_class.get_data(params.filePrimTreatment,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=0.0) print_debug("PrimTreatment",PrimTreatment) SecTreatment = data_class.get_data(params.fileSecTreatment,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=0.0) print_debug("SecTreatment",SecTreatment) TertTreatment = data_class.get_data(params.fileTertTreatment,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=0.0) print_debug("TertTreatment",TertTreatment) # Sum of the percentage treatment is smaller or equal to percentage population connected. # Determine the percentage of connected but not treated. NoTreatment = {} for key in isocode: total = PrimTreatment[key] + SecTreatment[key] + TertTreatment[key] if (total > PopCon[key] and total > 0.0): reduction = PopCon[key]/total print "Reduction of treatment for isocode country: " + str(key) + " with reduction: " + str(reduction) PrimTreatment[key] *= reduction SecTreatment[key] *= reduction TertTreatment[key] *= reduction NoTreatment[key] = 0.0 else: NoTreatment[key] = PopCon[key] - total print_debug("NoTreatment: sum equal to PopCon",NoTreatment) print_debug("PrimTreatment: sum equal to PopCon",PrimTreatment) print_debug("SecTreatment: sum equal to PopCon",SecTreatment) print_debug("TertTreatment: sum equal to PopCon",TertTreatment) # Determine the percentage of not-connected and not treated in urban areas. NotConnected = {} for key in isocode: if (PopUrb[key] > PopCon[key]): NotConnected[key] = PopUrb[key] - PopCon[key] else: NotConnected[key] = 0.0 print_debug("NotConnected",NotConnected) # Read the fraction removal of the primary, secondary and tertiary treatment for N and P. N_PrimRemoval = data_class.get_data(params.fileN_PrimRemoval,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=params.N_PrimRemoval_def) print_debug("N_PrimRemoval",N_PrimRemoval) N_SecRemoval = data_class.get_data(params.fileN_SecRemoval,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=params.N_SecRemoval_def) print_debug("N_SecRemoval",N_SecRemoval) N_TertRemoval = data_class.get_data(params.fileN_TertRemoval,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=params.N_TertRemoval_def) print_debug("N_TertRemoval",N_TertRemoval) P_PrimRemoval = data_class.get_data(params.fileP_PrimRemoval,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=params.P_PrimRemoval_def) print_debug("P_PrimRemoval",P_PrimRemoval) P_SecRemoval = data_class.get_data(params.fileP_SecRemoval,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=params.P_SecRemoval_def) print_debug("P_SecRemoval",P_SecRemoval) P_TertRemoval = data_class.get_data(params.fileP_TertRemoval,year=params.year,sep=params.sep,isocode=isocode,method=0,weighing=params.P_TertRemoval_def) print_debug("P_TertRemoval",P_TertRemoval) # Get the reuse fraction for agricultural, which comes from the unconnected people. agricultural_reuse = data_class.get_data(params.file_agri_reuse,year=params.year,sep=params.sep,isocode=isocode,method=1) # Calculate the percentage of each flow to NoConnectionRemoval (N and P) N_NoConnRemoval = {} P_NoConnRemoval = {} N_NoConnRemoval_agri = {} P_NoConnRemoval_agri = {} N_NoConnRemoval_other = {} P_NoConnRemoval_other = {} for key in isocode: N_NoConnRemoval[key] = 100.0 - (100.0 * (1.0 - agricultural_reuse[key]) * 0.5 * (1.0 - params.human_N_vol)) P_NoConnRemoval[key] = 100.0 - (100.0 * (1.0 - agricultural_reuse[key]) * 0.5) N_NoConnRemoval_agri[key] = 100.0 * agricultural_reuse[key] * (1.0 - params.human_N_vol) P_NoConnRemoval_agri[key] = 100.0 * agricultural_reuse[key] N_NoConnRemoval_other[key] = 100.0 * params.human_N_vol + \ 100.0 * (1.0 - params.human_N_vol)*(1.0 - agricultural_reuse[key])*0.5 P_NoConnRemoval_other[key] = 100.0 * (1.0 - agricultural_reuse[key]) * 0.5 print_debug("N_NoConnRemoval",N_NoConnRemoval) print_debug("P_NoConnRemoval",P_NoConnRemoval) print_debug("N_NoConnRemoval_agri",N_NoConnRemoval_agri) print_debug("P_NoConnRemoval_agri",P_NoConnRemoval_agri) print_debug("N_NoConnRemoval_other",N_NoConnRemoval_other) print_debug("P_NoConnRemoval_other",P_NoConnRemoval_other) regiondata.put2regiondata(N_NoConnRemoval,regiondata_dict,"N_NoConnRemoval") regiondata.put2regiondata(P_NoConnRemoval,regiondata_dict,"P_NoConnRemoval") # Calculate the total emission of the people Ntot = {} Ptot = {} NtotConnected = {} PtotConnected = {} NnotConnected = {} PnotConnected = {} Nsewerage_other = {} Psewerage_other = {} Npipe_loss = {} Ppipe_loss = {} # Remove the following when testing is ready Nhuman_connect = {} Nhuman_connect_with_pipe_loss = {} Phuman_connect = {} Phuman_connect_with_pipe_loss = {} Pdetergents1 = {} EmPldet_tot = {} EmPddet_tot = {} for key in isocode: Ntot[key] = PopNumTot[key] * Nemiss[key] Ptot[key] = PopNumTot[key] * Pemiss[key] + (PopNum[key]*PopCon[key]/100.0)*(EmPldet[key] + EmPddet[key]) NtotConnected[key] = Ntot[key] * (PopCon[key]/100.0) Nhuman_connect[key] = NtotConnected[key] PtotConnected[key] = (PopNum[key] * PopCon[key]/100.0)*(EmPldet[key] + EmPddet[key] + Pemiss[key]) Phuman_connect[key] = PtotConnected[key] Pdetergents1[key] = (PopNum[key] * PopCon[key]/100.0)*(EmPldet[key] + EmPddet[key]) EmPldet_tot[key] = (PopNum[key] * PopCon[key]/100.0) * EmPldet[key] EmPddet_tot[key] = (PopNum[key] * PopCon[key]/100.0) * EmPddet[key] # There is an extra loss of N and P due to leakage of pipes etc. Npipe_loss[key] = NtotConnected[key] * params.sewer_pipe_loss_fraction NtotConnected[key] *= (1.0 - params.sewer_pipe_loss_fraction) Nhuman_connect_with_pipe_loss[key] = NtotConnected[key] Ppipe_loss[key] = PtotConnected[key] * params.sewer_pipe_loss_fraction PtotConnected[key] *= (1.0 - params.sewer_pipe_loss_fraction) Phuman_connect_with_pipe_loss[key] = PtotConnected[key] # Add industry to the total connected load. NtotConnected[key] += Nemiss_industry[key] PtotConnected[key] += Pemiss_industry[key] NnotConnected[key] = Ntot[key] * NotConnected[key]/100.0 PnotConnected[key] = (PopNum[key] * Pemiss[key]) * (NotConnected[key]/100.0) print_debug("NotConnected",NotConnected) print_debug("PopCon",PopCon) print_debug("Ntot total population",Ntot) print_debug("Ptot total population",Ptot) print_debug("Nhuman_connect",Nhuman_connect) print_debug("Nhuman_connect_with_pipe_loss",Nhuman_connect_with_pipe_loss) print_debug("Phuman_connect",Phuman_connect) print_debug("Phuman_connect_with_pipe_loss",Phuman_connect_with_pipe_loss) print_debug("Pdetergents1",Pdetergents1) print_debug("Nemiss_industry",Nemiss_industry) print_debug("Pemiss_industry",Pemiss_industry) print_debug("NtotConnected included industry with pipe lost",NtotConnected) print_debug("PtotConnected included industry with pipe lost",PtotConnected) print_debug("NnotConnected",NnotConnected) print_debug("PnotConnected",PnotConnected) # Put all parameters in global database regiondata.put2regiondata(NtotConnected,regiondata_dict,"NtotConnected") regiondata.put2regiondata(NnotConnected,regiondata_dict,"NnotConnected") regiondata.put2regiondata(Ntot,regiondata_dict,"Ntot") regiondata.put2regiondata(PtotConnected,regiondata_dict,"PtotConnected") regiondata.put2regiondata(PnotConnected,regiondata_dict,"PnotConnected") regiondata.put2regiondata(Ptot,regiondata_dict,"Ptot") regiondata.put2regiondata(EmPddet_tot,regiondata_dict,"EmPddet_tot") regiondata.put2regiondata(EmPldet_tot,regiondata_dict,"EmPldet_tot") # Convert treatment faction of total people to fraction for the connected people. for key in isocode: if (PopCon[key] > 0.0): PrimTreatment[key] /= PopCon[key] SecTreatment[key] /= PopCon[key] TertTreatment[key] /= PopCon[key] NoTreatment[key] /= PopCon[key] else: PrimTreatment[key] = 0.0 SecTreatment[key] = 0.0 TertTreatment[key] = 0.0 NoTreatment[key] = 0.0 print_debug("PrimTreatment",PrimTreatment) print_debug("SecTreatment",SecTreatment) print_debug("TertTreatment",TertTreatment) print_debug("NoTreatment",NoTreatment) # Retention for the connected situation Nretention={} Pretention={} for key in isocode: Nretention[key] = N_PrimRemoval[key] * PrimTreatment[key] +\ N_SecRemoval[key] * SecTreatment[key] +\ N_TertRemoval[key] * TertTreatment[key] Pretention[key] = P_PrimRemoval[key] * PrimTreatment[key] +\ P_SecRemoval[key] * SecTreatment[key] +\ P_TertRemoval[key] * TertTreatment[key] print_debug("Nretention",Nretention) print_debug("Pretention",Pretention) regiondata.put2regiondata(Nretention,regiondata_dict,"Nretention") regiondata.put2regiondata(Pretention,regiondata_dict,"Pretention") NtotConnected_eff = {} PtotConnected_eff = {} NnotConnected_eff = {} PnotConnected_eff = {} Ntot_eff = {} Ptot_eff = {} NnotConnect_agri ={} NnotConnect_other ={} PnotConnect_agri ={} PnotConnect_other ={} Nhuman_connect_tosw = {} Nindustry_connect_tosw = {} Phuman_connect_tosw = {} Pindustry_connect_tosw = {} Nother_prim = {} Pother_prim = {} Nother_sec = {} Pother_sec = {} Nother_tert = {} Pother_tert = {} for key in isocode: Nsewerage_other[key] = NtotConnected[key] * (Nretention[key]/100.0) + Npipe_loss[key] Nother_prim[key] = NtotConnected[key] * (N_PrimRemoval[key] * PrimTreatment[key] /100.0) Nother_sec[key] = NtotConnected[key] * (N_SecRemoval[key] * SecTreatment[key] /100.0) Nother_tert[key] = NtotConnected[key] * (N_TertRemoval[key] * TertTreatment[key] /100.0) NtotConnected_eff[key] = NtotConnected[key] * (1.0 - (Nretention[key]/100.0)) Nhuman_connect_tosw[key] = Nhuman_connect_with_pipe_loss[key] * (1.0 - (Nretention[key]/100.0)) Nindustry_connect_tosw[key] = Nemiss_industry[key] * (1.0 - (Nretention[key]/100.0)) Pindustry_connect_tosw[key] = Pemiss_industry[key] * (1.0 - (Pretention[key]/100.0)) Psewerage_other[key] = PtotConnected[key] * (Pretention[key]/100.0) + Ppipe_loss[key] Pother_prim[key] = PtotConnected[key] * (P_PrimRemoval[key] * PrimTreatment[key] /100.0) Pother_sec[key] = PtotConnected[key] * (P_SecRemoval[key] * SecTreatment[key] /100.0) Pother_tert[key] = PtotConnected[key] * (P_TertRemoval[key] * TertTreatment[key] /100.0) PtotConnected_eff[key] = PtotConnected[key] * (1.0 - (Pretention[key]/100.0)) Phuman_connect_tosw[key] = Phuman_connect_with_pipe_loss[key] * (1.0 - (Pretention[key]/100.0)) # Not connected part. NnotConnected_eff[key] = NnotConnected[key] * (1.0 - (N_NoConnRemoval[key]/100.0)) PnotConnected_eff[key] = PnotConnected[key] * (1.0 - (P_NoConnRemoval[key]/100.0)) NnotConnect_agri[key] = NnotConnected[key] * (N_NoConnRemoval_agri[key]/100.0) PnotConnect_agri[key] = PnotConnected[key] * (P_NoConnRemoval_agri[key]/100.0) NnotConnect_other[key] = NnotConnected[key] * (N_NoConnRemoval_other[key]/100.0) PnotConnect_other[key] = PnotConnected[key] * (P_NoConnRemoval_other[key]/100.0) # Make a total to surface water. Ntot_eff[key] = NtotConnected_eff[key] + NnotConnected_eff[key] Ptot_eff[key] = PtotConnected_eff[key] + PnotConnected_eff[key] print_debug("NtotConnected_eff",NtotConnected_eff) print_debug("Nhuman_connect_tosw",Nhuman_connect_tosw) print_debug("Nindustry_connect_tosw",Nindustry_connect_tosw) print_debug("Nsewerage_other",Nsewerage_other) print_debug("PtotConnected_eff",PtotConnected_eff) print_debug("Phuman_connect_tosw",Phuman_connect_tosw) print_debug("Pindustry_connect_tosw",Pindustry_connect_tosw) print_debug("Psewerage_other",Psewerage_other) print_debug("NnotConnected_eff",NnotConnected_eff) print_debug("PnotConnected_eff",PnotConnected_eff) print_debug("NnotConnect_agri",NnotConnect_agri) print_debug("NnotConnect_other",NnotConnect_other) print_debug("PnotConnect_agri",PnotConnect_agri) print_debug("PnotConnect_other",PnotConnect_other) print_debug("Ntot_eff",Ntot_eff) print_debug("Ptot_eff",Ptot_eff) # Put all parameters in global database regiondata.put2regiondata(NtotConnected_eff,regiondata_dict,"NtotConnected_eff") regiondata.put2regiondata(NnotConnected_eff,regiondata_dict,"NnotConnected_eff") regiondata.put2regiondata(NnotConnect_agri,regiondata_dict,"NnotConnect_agri") regiondata.put2regiondata(NnotConnect_other,regiondata_dict,"NnotConnect_other") regiondata.put2regiondata(Nsewerage_other,regiondata_dict,"Nsewerage_other") regiondata.put2regiondata(Nother_prim,regiondata_dict,"Nother_prim") regiondata.put2regiondata(Nother_sec,regiondata_dict,"Nother_sec") regiondata.put2regiondata(Nother_tert,regiondata_dict,"Nother_tert") regiondata.put2regiondata(Ntot_eff,regiondata_dict,"Ntot_eff") regiondata.put2regiondata(PtotConnected_eff,regiondata_dict,"PtotConnected_eff") regiondata.put2regiondata(PnotConnected_eff,regiondata_dict,"PnotConnected_eff") regiondata.put2regiondata(PnotConnect_agri,regiondata_dict,"PnotConnect_agri") regiondata.put2regiondata(PnotConnect_other,regiondata_dict,"PnotConnect_other") regiondata.put2regiondata(Psewerage_other,regiondata_dict,"Psewerage_other") regiondata.put2regiondata(Pother_prim,regiondata_dict,"Pother_prim") regiondata.put2regiondata(Pother_sec,regiondata_dict,"Pother_sec") regiondata.put2regiondata(Pother_tert,regiondata_dict,"Pother_tert") regiondata.put2regiondata(Ptot_eff,regiondata_dict,"Ptot_eff") log.write_and_print(s.interval("Ready with calculation of N and P emission to surface water.")) # Make N and P human waste in kg. testN = {} testP = {} for key in isocode: pop = max(PopUrbNum[key],PopConNum[key]) emisN_rur = regiondata_dict[key].N_human_waste_other + Nemiss[key] emisP_rur = regiondata_dict[key].P_human_waste_other + Pemiss[key] regiondata_dict[key].N_human_waste_other *= pop regiondata_dict[key].P_human_waste_other *= pop testN[key] = regiondata_dict[key].N_human_waste_other testP[key] = regiondata_dict[key].P_human_waste_other regiondata_dict[key].Nemiss_pop_rural = emisN_rur * (PopNum[key] - pop) regiondata_dict[key].Pemiss_pop_rural = emisP_rur * (PopNum[key] - pop) print_debug("N_human_waste_other",testN) print_debug("P_human_waste_other",testP) del testN del testP # Read septic tank connection for the rural population Septic_connection = data_class.get_data(params.fileSeptic_rural,year=params.year,sep=params.sep,isocode=isocode,method=1) Nemiss_rural_sw = {} Pemiss_rural_sw = {} for key in isocode: regiondata_dict[key].Nemiss_rural_sw = regiondata_dict[key].Nemiss_pop_rural *(1.0-0.01*Septic_connection[key]) *\ (1.0 - params.Nreduction_septic_to_river) regiondata_dict[key].Pemiss_rural_sw = regiondata_dict[key].Pemiss_pop_rural *(1.0-0.01*Septic_connection[key]) *\ (1.0 - params.Preduction_septic_to_river) regiondata_dict[key].Nemiss_rural_grw = regiondata_dict[key].Nemiss_pop_rural *(0.01*Septic_connection[key]) *\ (1.0 - params.Nreduction_septic_to_grw) regiondata_dict[key].Pemiss_rural_grw = regiondata_dict[key].Pemiss_pop_rural *(0.01*Septic_connection[key]) *\ (1.0 - params.Preduction_septic_to_grw) regiondata_dict[key].Nemiss_rural_other = regiondata_dict[key].Nemiss_pop_rural *(1.0 - 0.01*Septic_connection[key]) *\ params.Nreduction_septic_to_river + regiondata_dict[key].Nemiss_pop_rural *\ (0.01 * Septic_connection[key]) *\ params.Nreduction_septic_to_grw regiondata_dict[key].Pemiss_rural_other = regiondata_dict[key].Pemiss_pop_rural *(1.0 - 0.01*Septic_connection[key]) *\ params.Preduction_septic_to_river + regiondata_dict[key].Pemiss_pop_rural *\ (0.01 * Septic_connection[key]) *\ params.Preduction_septic_to_grw # Add rural emissions to surface water effluent. regiondata_dict[key].Ntot_eff += regiondata_dict[key].Nemiss_rural_sw regiondata_dict[key].Ptot_eff += regiondata_dict[key].Pemiss_rural_sw Nemiss_rural_sw[key] = regiondata_dict[key].Nemiss_rural_sw Pemiss_rural_sw[key] = regiondata_dict[key].Pemiss_rural_sw # Add the agricultural load and the load to other sector for key in isocode: regiondata_dict[key].Ntotal_agri = regiondata_dict[key].NnotConnect_agri regiondata_dict[key].Ntotal_other = regiondata_dict[key].NnotConnect_other +\ regiondata_dict[key].N_human_waste_other +\ regiondata_dict[key].Nindustry_other +\ regiondata_dict[key].Nother_prim + regiondata_dict[key].Nother_sec +\ regiondata_dict[key].Nother_tert + Npipe_loss[key] +\ regiondata_dict[key].Nemiss_rural_grw +\ regiondata_dict[key].Nemiss_rural_other regiondata_dict[key].Nother_NH3 = NnotConnected[key] * params.human_N_vol regiondata_dict[key].Nother_soil = Npipe_loss[key] + \ regiondata_dict[key].NnotConnect_other - regiondata_dict[key].Nother_NH3 +\ regiondata_dict[key].Nemiss_rural_grw regiondata_dict[key].Ptotal_agri = regiondata_dict[key].PnotConnect_agri regiondata_dict[key].Ptotal_other = regiondata_dict[key].PnotConnect_other +\ regiondata_dict[key].P_human_waste_other +\ regiondata_dict[key].Pindustry_other +\ regiondata_dict[key].Pother_prim + regiondata_dict[key].Pother_sec +\ regiondata_dict[key].Pother_tert + Ppipe_loss[key] +\ regiondata_dict[key].Pemiss_rural_grw +\ regiondata_dict[key].Pemiss_rural_other regiondata_dict[key].Pother_soil = Ppipe_loss[key] +\ regiondata_dict[key].PnotConnect_other +\ regiondata_dict[key].Pemiss_rural_grw # Distribute the results on the grid. if (params.grid_output == 1): allocation_emission.allocation_emission(params,mask,isocode,isogrid,PopNumTot,popgrid,PopCon,PopUrb,\ NtotConnected_eff,PtotConnected_eff,NnotConnected_eff,\ PnotConnected_eff,NtotConnected,\ N_PrimRemoval,PrimTreatment,\ N_SecRemoval,SecTreatment,\ N_TertRemoval,TertTreatment,\ Nemiss_rural_sw,Pemiss_rural_sw, PopNum_coast,popgrid_coast) load_coast.calculate(params,mask,isocode,isogrid,popgrid_coast,Nemiss,Pemiss) log.write_and_print(s.interval("Ready with allocation of N and P emission to grid cells.")) # Aggregation of the tabular information on another id-grid than basinid's if (params.aggregationgrid != None): make_index_grid.make_index_grid(params,mask,regiondata_dict,isogrid) qq = os.path.basename(params.aggregationgrid) filename = os.path.join(params.outputdir,params.scenarioname +"_" + str(params.year) + "_" + qq + ".csv") mouth.aggregate(regiondata_dict,params.aggregationgrid,mask,\ filename,params.sep,keyname="isocode") # Aggregate to global level for key in regiondata_dict.keys(): try: regiondata_dict["Total"].sum(regiondata_dict[key]) except KeyError: regiondata_dict["Total"] = regiondata_dict[key].copy() # Write all region information to output file: fp = open(params.fileoutput_table,"w") regiondata_dict[isocode[0]].write_header(fp,sep=params.sep) write_dict.write_dict(fp_in=fp,filename=None,dic=regiondata_dict,headerkey="",sep=params.sep,lkey=0,ldebug=1,fatal=0) fp.close() log.write_and_print(s.total("Total run")) del log
def calculate(params): print("nconc_le_crit_gw =", params.crit_gw) # load needed variables for calculations q = ascraster.Asciigrid(ascii_file=os.path.join(params.inputdir, "q.asc"), numtype=float, mask=params.mask) nle_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "nle_ag.asc"), numtype=float, mask=params.mask) nfix_ara = ascraster.Asciigrid( ascii_file=params.filename_nfixation_cropland, numtype=float, mask=params.mask) nfix_igl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_intgl, numtype=float, mask=params.mask) fsro_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fsro_ag.asc"), numtype=float, mask=params.mask) fara = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fara.asc"), numtype=float, mask=params.mask) figl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "figl.asc"), numtype=float, mask=params.mask) fegl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fegl.asc"), numtype=float, mask=params.mask) fnat = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fnat.asc"), numtype=float, mask=params.mask) fle_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fle_ag.asc"), numtype=float, mask=params.mask) frnup_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_ara.asc"), numtype=float, mask=params.mask) frnup_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_igl.asc"), numtype=float, mask=params.mask) nup_max_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nup_max_ara.asc"), numtype=float, mask=params.mask) nup_max_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nup_max_igl.asc"), numtype=float, mask=params.mask) nox_em = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nox_em.asc"), numtype=float, mask=params.mask) nh3_tot_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_egl.asc"), numtype=float, mask=params.mask) nh3_tot_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_igl.asc"), numtype=float, mask=params.mask) nh3_tot_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_ara.asc"), numtype=float, mask=params.mask) nh3_ef_man_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_ara.asc"), numtype=float, mask=params.mask) nh3_ef_man_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_igl.asc"), numtype=float, mask=params.mask) nh3_ef_fer_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fer_ara.asc"), numtype=float, mask=params.mask) nh3_ef_fer_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fer_igl.asc"), numtype=float, mask=params.mask) frnfe_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_ara.asc"), numtype=float, mask=params.mask) frnfe_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_igl.asc"), numtype=float, mask=params.mask) nin_max_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nin_max_ara.asc"), numtype=float, mask=params.mask) nin_max_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nin_max_igl.asc"), numtype=float, mask=params.mask) nle_ara = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nle_ara.asc"), numtype=float, mask=params.mask) nle_igl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nle_igl.asc"), numtype=float, mask=params.mask) ## * Critical N leaching * one_grid = ascraster.duplicategrid(q) for i in range(one_grid.length): one_grid.set_data(i, 1.0) one_min_fsro = ascraster.duplicategrid(one_grid) one_min_fsro.substract(fsro_ag) # 'ara' nle_crit_gw_ara = ascraster.duplicategrid(one_min_fsro) nle_crit_gw_ara.multiply(q) nle_crit_gw_ara.multiply(fara) nle_crit_gw_ara.multiply(params.crit_gw) fileout = os.path.join(params.outputdir, "nle_crit_gw_ara.asc") nle_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nle_crit_gw_ara, "nle_crit_gw_ara =") # 'igl' nle_crit_gw_igl = ascraster.duplicategrid(one_min_fsro) nle_crit_gw_igl.multiply(q) nle_crit_gw_igl.multiply(figl) nle_crit_gw_igl.multiply(params.crit_gw) fileout = os.path.join(params.outputdir, "nle_crit_gw_igl.asc") nle_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nle_crit_gw_igl, "nle_crit_gw_igl =") ## * Parameter v * # 'ara' v_ara_part1 = ascraster.duplicategrid(one_grid) v_ara_part1.substract(frnup_ara) v_ara_part2 = ascraster.duplicategrid(fsro_ag) v_ara_part2.multiply(frnup_ara) v_ara = ascraster.duplicategrid(v_ara_part1) v_ara.add(v_ara_part2) v_ara.substract(fsro_ag) v_ara.multiply(fle_ag) # 'igl' v_igl_part1 = ascraster.duplicategrid(one_grid) v_igl_part1.substract(frnup_igl) v_igl_part2 = ascraster.duplicategrid(fsro_ag) v_igl_part2.multiply(frnup_igl) v_igl = ascraster.duplicategrid(v_igl_part1) v_igl.add(v_igl_part2) v_igl.substract(fsro_ag) v_igl.multiply(fle_ag) ## * Critical N input from manure * ## OPTION 1 - for grid cells with EITHER 'ara' OR 'igl' # 'ara' num1_ara = ascraster.duplicategrid(nle_crit_gw_ara) num1_ara.divide(v_ara, default_nodata_value=-9999) num1_ara.substract(nfix_ara) num2_V1_ara = ascraster.duplicategrid(nox_em) num2_V1_ara.add(nh3_tot_egl) num2_V1_ara.multiply(fara) num_V1_ara = ascraster.duplicategrid(num1_ara) num_V1_ara.substract(num2_V1_ara) den1_ara = ascraster.duplicategrid(fara) den1_ara.multiply(nh3_ef_man_ara) den1_ara.add(one_grid) den2_ara = ascraster.duplicategrid(fara) den2_ara.multiply(nh3_ef_fer_ara) den2_ara.add(one_grid) one_min_frnfe_ara = ascraster.duplicategrid(one_grid) one_min_frnfe_ara.substract(frnfe_ara) frnfe_division_ara = ascraster.duplicategrid(frnfe_ara) frnfe_division_ara.divide(one_min_frnfe_ara, default_nodata_value=-9999) den2_ara.multiply(frnfe_division_ara) den_ara = ascraster.duplicategrid(den1_ara) den_ara.add(den2_ara) nman_crit_gw_V1_ara = ascraster.duplicategrid(num_V1_ara) nman_crit_gw_V1_ara.divide(den_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_gw_V1_ara.asc") nman_crit_gw_V1_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' num1_igl = ascraster.duplicategrid(nle_crit_gw_igl) num1_igl.divide(v_igl, default_nodata_value=-9999) num1_igl.substract(nfix_igl) num2_V1_igl = ascraster.duplicategrid(nox_em) num2_V1_igl.add(nh3_tot_egl) num2_V1_igl.multiply(figl) num_V1_igl = ascraster.duplicategrid(num1_igl) num_V1_igl.substract(num2_V1_igl) den1_igl = ascraster.duplicategrid(figl) den1_igl.multiply(nh3_ef_man_igl) den1_igl.add(one_grid) den2_igl = ascraster.duplicategrid(figl) den2_igl.multiply(nh3_ef_fer_igl) den2_igl.add(one_grid) one_min_frnfe_igl = ascraster.duplicategrid(one_grid) one_min_frnfe_igl.substract(frnfe_igl) frnfe_division_igl = ascraster.duplicategrid(frnfe_igl) frnfe_division_igl.divide(one_min_frnfe_igl, default_nodata_value=-9999) den2_igl.multiply(frnfe_division_igl) den_igl = ascraster.duplicategrid(den1_igl) den_igl.add(den2_igl) nman_crit_gw_V1_igl = ascraster.duplicategrid(num_V1_igl) nman_crit_gw_V1_igl.divide(den_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_gw_V1_igl.asc") nman_crit_gw_V1_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## OPTION2 - for grid cells with BOTH 'ara' AND 'igl' # 'ara' num2_V2_ara = ascraster.duplicategrid(nle_crit_gw_igl) num2_V2_ara.divide(nle_igl, default_nodata_value=-9999) num2_V2_ara.multiply(nh3_tot_igl) num2_V2_ara.add(nox_em) num2_V2_ara.add(nh3_tot_egl) num2_V2_ara.multiply(fara) num_V2_ara = ascraster.duplicategrid(num1_ara) num_V2_ara.substract(num2_V2_ara) nman_crit_gw_V2_ara = ascraster.duplicategrid(num_V2_ara) nman_crit_gw_V2_ara.divide(den_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_gw_V2_ara.asc") nman_crit_gw_V2_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' num2_V2_igl = ascraster.duplicategrid(nle_crit_gw_ara) num2_V2_igl.divide(nle_ara, default_nodata_value=-9999) num2_V2_igl.multiply(nh3_tot_ara) num2_V2_igl.add(nox_em) num2_V2_igl.add(nh3_tot_egl) num2_V2_igl.multiply(figl) num_V2_igl = ascraster.duplicategrid(num1_igl) num_V2_igl.substract(num2_V2_igl) nman_crit_gw_V2_igl = ascraster.duplicategrid(num_V2_igl) nman_crit_gw_V2_igl.divide(den_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nman_crit_gw_V2_igl.asc") nman_crit_gw_V2_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # MAKE GRID WITH CRITICAL INPUTS FROM MANURE DEPENDING ON OPTION # ara nman_crit_gw_ara = ascraster.duplicategrid(nman_crit_gw_V1_ara) for icell in range(fara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) nman_ara2 = nman_crit_gw_V2_ara.get_data(icell) nle = nle_ag.get_data(icell) if (f_ara is None or f_igl is None): continue elif (f_ara > 0 and f_igl > 0 and nle > 0): nman_ara = nman_ara2 elif (f_ara == 0 and f_igl > 0): nman_ara = 0 else: continue nman_crit_gw_ara.set_data(icell, nman_ara) for icell in range(nman_crit_gw_ara.length): nman_ara3 = nman_crit_gw_ara.get_data(icell) if (nman_ara3 is None): continue if (nman_ara3 < 0): nman_ara = 0 else: continue nman_crit_gw_ara.set_data(icell, nman_ara) fileout = os.path.join(params.outputdir, "nman_crit_gw_ara.asc") nman_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nman_crit_gw_ara, "nman_crit_gw_ara =") # igl nman_crit_gw_igl = ascraster.duplicategrid(nman_crit_gw_V1_igl) for icell in range(figl.length): f_igl = figl.get_data(icell) f_ara = fara.get_data(icell) nman_igl2 = nman_crit_gw_V2_igl.get_data(icell) nle = nle_ag.get_data(icell) if (f_ara is None or f_igl is None): continue elif (f_ara > 0 and f_igl > 0 and nle > 0): nman_igl = nman_igl2 elif (f_ara > 0 and f_igl == 0): nman_igl = 0 else: continue nman_crit_gw_igl.set_data(icell, nman_igl) for icell in range(nman_crit_gw_igl.length): nman_igl3 = nman_crit_gw_igl.get_data(icell) if (nman_igl3 is None): continue if (nman_igl3 < 0): nman_igl = 0 else: continue nman_crit_gw_igl.set_data(icell, nman_igl) fileout = os.path.join(params.outputdir, "nman_crit_gw_igl.asc") nman_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nman_crit_gw_igl, "nman_crit_gw_igl =") ## * Critical N input from fertilizer * # 'ara' nfer_crit_gw_ara = ascraster.duplicategrid(nman_crit_gw_ara) nfer_crit_gw_ara.multiply(frnfe_division_ara) # set to zero for all cells with no ara but igl (to avoid error in calculating nh3 emissions / deposition for these cells) for icell in range(nfer_crit_gw_ara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) if (f_ara == 0 and f_igl > 0): nfer_ara = 0 else: continue nfer_crit_gw_ara.set_data(icell, nfer_ara) fileout = os.path.join(params.outputdir, "nfer_crit_gw_ara.asc") nfer_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nfer_crit_gw_ara, "nfer_crit_gw_ara =") # 'igl' nfer_crit_gw_igl = ascraster.duplicategrid(nman_crit_gw_igl) nfer_crit_gw_igl.multiply(frnfe_division_igl) # set to zero for all cells with no igl but ara (to avoid error in calculating nh3 emissions / deposition for these cells) for icell in range(nfer_crit_gw_igl.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) if (f_igl == 0 and f_ara > 0): nfer_igl = 0 else: continue nfer_crit_gw_igl.set_data(icell, nfer_igl) fileout = os.path.join(params.outputdir, "nfer_crit_gw_igl.asc") nfer_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nfer_crit_gw_igl, "nfer_crit_gw_igl =") ## * Critical N inputs from fertilizer plus manure * ## # 'ara' nman_fer_crit_gw_ara = ascraster.duplicategrid(nman_crit_gw_ara) nman_fer_crit_gw_ara.add(nfer_crit_gw_ara) fileout = os.path.join(params.outputdir, "nman_fer_crit_gw_ara.asc") nman_fer_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) # 'igl' nman_fer_crit_gw_igl = ascraster.duplicategrid(nman_crit_gw_igl) nman_fer_crit_gw_igl.add(nfer_crit_gw_igl) fileout = os.path.join(params.outputdir, "nman_fer_crit_gw_igl.asc") nman_fer_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## * NH3 emissions at critical N input * # 'ara' nh3em_man_crit_gw_ara = ascraster.duplicategrid(nman_crit_gw_ara) nh3em_man_crit_gw_ara.multiply(nh3_ef_man_ara) nh3em_fer_crit_gw_ara = ascraster.duplicategrid(nfer_crit_gw_ara) nh3em_fer_crit_gw_ara.multiply(nh3_ef_fer_ara) nh3em_crit_gw_ara = ascraster.duplicategrid(nh3em_man_crit_gw_ara) nh3em_crit_gw_ara.add(nh3em_fer_crit_gw_ara) print_debug(nh3em_crit_gw_ara, "nh3em_crit_gw_ara =") # 'igl' nh3em_man_crit_gw_igl = ascraster.duplicategrid(nman_crit_gw_igl) nh3em_man_crit_gw_igl.multiply(nh3_ef_man_igl) nh3em_fer_crit_gw_igl = ascraster.duplicategrid(nfer_crit_gw_igl) nh3em_fer_crit_gw_igl.multiply(nh3_ef_fer_igl) nh3em_crit_gw_igl = ascraster.duplicategrid(nh3em_man_crit_gw_igl) nh3em_crit_gw_igl.add(nh3em_fer_crit_gw_igl) print_debug(nh3em_crit_gw_igl, "nh3em_crit_gw_igl =") ## * N deposition at critical N input * ndep_crit_gw_tot = ascraster.duplicategrid(nh3em_crit_gw_ara) ndep_crit_gw_tot.add(nh3em_crit_gw_igl) ndep_crit_gw_tot.add(nox_em) ndep_crit_gw_tot.add(nh3_tot_egl) fileout = os.path.join(params.outputdir, "ndep_crit_gw_tot.asc") ndep_crit_gw_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_gw_tot, "ndep_crit_gw_tot =") # OPTION 1 - for grid cells with EITHER ara OR igl # 'ara' ndep_crit_gw_V1_ara = ascraster.duplicategrid(ndep_crit_gw_tot) ndep_crit_gw_V1_ara.multiply(fara) # 'igl' ndep_crit_gw_V1_igl = ascraster.duplicategrid(ndep_crit_gw_tot) ndep_crit_gw_V1_igl.multiply(figl) # OPTION 2 - for grid cells with BOTH ara + igl # 'ara' ndep_crit_gw_V2_ara = ascraster.duplicategrid(nle_crit_gw_igl) ndep_crit_gw_V2_ara.divide(nle_igl, default_nodata_value=-9999) ndep_crit_gw_V2_ara.multiply(nh3_tot_igl) ndep_crit_gw_V2_ara.add(nh3em_crit_gw_ara) ndep_crit_gw_V2_ara.add(nox_em) ndep_crit_gw_V2_ara.add(nh3_tot_egl) ndep_crit_gw_V2_ara.multiply(fara) # 'igl' ndep_crit_gw_V2_igl = ascraster.duplicategrid(nle_crit_gw_ara) ndep_crit_gw_V2_igl.divide(nle_ara, default_nodata_value=-9999) ndep_crit_gw_V2_igl.multiply(nh3_tot_ara) ndep_crit_gw_V2_igl.add(nh3em_crit_gw_igl) ndep_crit_gw_V2_igl.add(nox_em) ndep_crit_gw_V2_igl.add(nh3_tot_egl) ndep_crit_gw_V2_igl.multiply(figl) # MAKE ONE GRID FOR N DEPOSITION # 'ara' ndep_crit_gw_ara = ascraster.duplicategrid(ndep_crit_gw_V1_ara) for icell in range(ndep_crit_gw_ara.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) ndep_ara2 = ndep_crit_gw_V2_ara.get_data(icell) nle = nle_ag.get_data(icell) if (f_ara is None or f_igl is None): continue elif (f_ara > 0 and f_igl > 0 and nle > 0): ndep_ara = ndep_ara2 else: continue ndep_crit_gw_ara.set_data(icell, ndep_ara) fileout = os.path.join(params.outputdir, "ndep_crit_gw_ara.asc") ndep_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_gw_ara, "ndep_crit_gw_ara =") # 'igl' ndep_crit_gw_igl = ascraster.duplicategrid(ndep_crit_gw_V1_igl) for icell in range(ndep_crit_gw_igl.length): f_ara = fara.get_data(icell) f_igl = figl.get_data(icell) ndep_igl2 = ndep_crit_gw_V2_igl.get_data(icell) nle = nle_ag.get_data(icell) if (f_ara is None or f_igl is None): continue elif (f_ara > 0 and f_igl > 0 and nle > 0): ndep_igl = ndep_igl2 else: continue ndep_crit_gw_igl.set_data(icell, ndep_igl) fileout = os.path.join(params.outputdir, "ndep_crit_gw_igl.asc") ndep_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_gw_igl, "ndep_crit_gw_igl =") ##TEST: Total N deposition as sum of depositions# ndep_crit_gw_egl = ascraster.duplicategrid(ndep_crit_gw_tot) ndep_crit_gw_egl.multiply(fegl) ndep_crit_gw_nat = ascraster.duplicategrid(ndep_crit_gw_tot) ndep_crit_gw_nat.multiply(fnat) ndep_crit_gw_tot_TEST = ascraster.duplicategrid(ndep_crit_gw_ara) ndep_crit_gw_tot_TEST.add(ndep_crit_gw_igl) ndep_crit_gw_tot_TEST.add(ndep_crit_gw_egl) ndep_crit_gw_tot_TEST.add(ndep_crit_gw_nat) fileout = os.path.join(params.outputdir, "ndep_crit_gw_tot_TEST.asc") ndep_crit_gw_tot_TEST.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_crit_gw_tot_TEST, "ndep_crit_gw_tot_TEST =") ## * Total critical N inputs * # 'ara' nin_crit_gw_ara = ascraster.duplicategrid(nman_crit_gw_ara) nin_crit_gw_ara.add(nfer_crit_gw_ara) nin_crit_gw_ara.add(ndep_crit_gw_ara) nin_crit_gw_ara.add(nfix_ara) fileout = os.path.join(params.outputdir, "nin_crit_gw_ara.asc") nin_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_gw_ara, "nin_crit_gw_ara =") # 'igl' nin_crit_gw_igl = ascraster.duplicategrid(nman_crit_gw_igl) nin_crit_gw_igl.add(nfer_crit_gw_igl) nin_crit_gw_igl.add(ndep_crit_gw_igl) nin_crit_gw_igl.add(nfix_igl) fileout = os.path.join(params.outputdir, "nin_crit_gw_igl.asc") nin_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_gw_igl, "nin_crit_gw_igl =") # 'ara+igl' nin_crit_gw_araigl = ascraster.duplicategrid(nin_crit_gw_ara) nin_crit_gw_araigl.add(nin_crit_gw_igl) fileout = os.path.join(params.outputdir, "nin_crit_gw_araigl.asc") nin_crit_gw_araigl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ## * N surface runoff at critical N inputs * # 'ara' nsro_crit_gw_ara = ascraster.duplicategrid(nin_crit_gw_ara) nsro_crit_gw_ara.multiply(fsro_ag) print_debug(nsro_crit_gw_ara, "nsro_crit_gw_ara =") # 'igl' nsro_crit_gw_igl = ascraster.duplicategrid(nin_crit_gw_igl) nsro_crit_gw_igl.multiply(fsro_ag) print_debug(nsro_crit_gw_igl, "nsro_crit_gw_igl =") ## * N uptake at critical N inputs * # 'ara' nup_crit_gw_ara = ascraster.duplicategrid(nin_crit_gw_ara) nup_crit_gw_ara.substract(nsro_crit_gw_ara) nup_crit_gw_ara.multiply(frnup_ara) fileout = os.path.join(params.outputdir, "nup_crit_gw_ara.asc") nup_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_gw_ara, "nup_crit_gw_ara =") # 'igl' nup_crit_gw_igl = ascraster.duplicategrid(nin_crit_gw_igl) nup_crit_gw_igl.substract(nsro_crit_gw_igl) nup_crit_gw_igl.multiply(frnup_igl) fileout = os.path.join(params.outputdir, "nup_crit_gw_igl.asc") nup_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_gw_igl, "nup_crit_gw_igl =") ## * NUE at critical N inputs * # 'ara' nue_crit_gw_ara = ascraster.duplicategrid(nup_crit_gw_ara) nue_crit_gw_ara.divide(nin_crit_gw_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_crit_gw_ara.asc") nue_crit_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_crit_gw_ara, "nue_crit_gw_ara =") # 'igl' nue_crit_gw_igl = ascraster.duplicategrid(nup_crit_gw_igl) nue_crit_gw_igl.divide(nin_crit_gw_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_crit_gw_igl.asc") nue_crit_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_crit_gw_igl, "nue_crit_gw_igl =") ## * Maximum uptake fraction * # 'ara' fnup_max_gw_ara = ascraster.duplicategrid(nup_max_ara) fnup_max_gw_ara.divide(nup_crit_gw_ara) fileout = os.path.join(params.outputdir, "fnup_max_gw_ara.asc") fnup_max_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_max_gw_ara, "fnup_max_gw_ara =") # 'igl' fnup_max_gw_igl = ascraster.duplicategrid(nup_max_igl) fnup_max_gw_igl.divide(nup_crit_gw_igl) fileout = os.path.join(params.outputdir, "fnup_max_gw_igl.asc") fnup_max_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_max_gw_igl, "fnup_max_gw_igl =") ## * Correction factor for grid cells where Nup,crit > Nup,max * # 'ara' fnup_corr_gw_ara = ascraster.duplicategrid(nin_max_ara) fnup_corr_gw_ara.substract(nfix_ara) temp2_ara = ascraster.duplicategrid(nh3_tot_egl) temp2_ara.add(nox_em) temp2_ara.multiply(fara) fnup_corr_gw_ara.substract(temp2_ara) temp3_ara = ascraster.duplicategrid(nh3em_crit_gw_ara) temp3_ara.multiply(fara) temp3_ara.add(nman_crit_gw_ara) temp3_ara.add(nfer_crit_gw_ara) fnup_corr_gw_ara.divide(temp3_ara, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_gw_ara.asc") fnup_corr_gw_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_gw_ara, "fnup_corr_gw_ara =") # 'igl' fnup_corr_gw_igl = ascraster.duplicategrid(nin_max_igl) fnup_corr_gw_igl.substract(nfix_igl) temp2_igl = ascraster.duplicategrid(nh3_tot_egl) temp2_igl.add(nox_em) temp2_igl.multiply(figl) fnup_corr_gw_igl.substract(temp2_igl) temp3_igl = ascraster.duplicategrid(nh3em_crit_gw_igl) temp3_igl.multiply(figl) temp3_igl.add(nman_crit_gw_igl) temp3_igl.add(nfer_crit_gw_igl) fnup_corr_gw_igl.divide(temp3_igl, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_gw_igl.asc") fnup_corr_gw_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_gw_igl, "fnup_corr_gw_igl =") ########### Checking degree of exceedance of critical N leaching by FIXED N inputs ############ # Calculate N leaching caused by N fixation alone nle_nfix_gw_ara = ascraster.duplicategrid(nfix_ara) nle_nfix_gw_ara.multiply(v_ara) nle_nfix_gw_igl = ascraster.duplicategrid(nfix_igl) nle_nfix_gw_igl.multiply(v_igl) nle_nfix_gw = ascraster.duplicategrid(nle_nfix_gw_ara) nle_nfix_gw.add(nle_nfix_gw_igl) fileout = os.path.join(params.outputdir, "nle_nfix_gw.asc") nle_nfix_gw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) #print_debug(nle_nfix_gw,"The N leaching caused by N fixation alone is") # Calculate N leaching caused by NOx emissions alone nle_nox_gw_ara = ascraster.duplicategrid(nox_em) nle_nox_gw_ara.multiply(fara) nle_nox_gw_ara.multiply(v_ara) nle_nox_gw_igl = ascraster.duplicategrid(nox_em) nle_nox_gw_igl.multiply(figl) nle_nox_gw_igl.multiply(v_igl) nle_nox_gw = ascraster.duplicategrid(nle_nox_gw_ara) nle_nox_gw.add(nle_nox_gw_igl) fileout = os.path.join(params.outputdir, "nle_nox_gw.asc") nle_nox_gw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) #print_debug(nle_nox_gw,"The N leaching caused by NOx emissions alone is") # Calculate N leaching caused by NH3,egl emissions alone nle_nh3egl_gw_ara = ascraster.duplicategrid(nh3_tot_egl) nle_nh3egl_gw_ara.multiply(fara) nle_nh3egl_gw_ara.multiply(v_ara) nle_nh3egl_gw_igl = ascraster.duplicategrid(nh3_tot_egl) nle_nh3egl_gw_igl.multiply(figl) nle_nh3egl_gw_igl.multiply(v_igl) nle_nh3egl_gw = ascraster.duplicategrid(nle_nh3egl_gw_ara) nle_nh3egl_gw.add(nle_nh3egl_gw_igl) fileout = os.path.join(params.outputdir, "nle_nh3egl_gw.asc") nle_nh3egl_gw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) #print_debug(nle_nh3egl_gw,"The N leaching caused by NH3 emissions from ext grassland alone is") ############################################################################################# ########### FORWARD CALCULATIONS TO CHECK ########### ## * Critical N budget * # 'ara' nbud_crit_gw_ara = ascraster.duplicategrid(nin_crit_gw_ara) nbud_crit_gw_ara.substract(nup_crit_gw_ara) print_debug(nbud_crit_gw_ara, "nbud_crit_gw_ara =") # 'igl' nbud_crit_gw_igl = ascraster.duplicategrid(nin_crit_gw_igl) nbud_crit_gw_igl.substract(nup_crit_gw_igl) print_debug(nbud_crit_gw_igl, "nbud_crit_gw_igl =") ## * Critical leaching * # 'ara' nle_crit_gw_test_ara = ascraster.duplicategrid(nbud_crit_gw_ara) nle_crit_gw_test_ara.substract(nsro_crit_gw_ara) nle_crit_gw_test_ara.multiply(fle_ag) fileout = os.path.join(params.outputdir, "nle_crit_gw_test_ara.asc") nle_crit_gw_test_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nle_crit_gw_test_ara, "nle_crit_gw_test_ara =") # 'igl' nle_crit_gw_test_igl = ascraster.duplicategrid(nbud_crit_gw_igl) nle_crit_gw_test_igl.substract(nsro_crit_gw_igl) nle_crit_gw_test_igl.multiply(fle_ag) fileout = os.path.join(params.outputdir, "nle_crit_gw_test_igl.asc") nle_crit_gw_test_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nle_crit_gw_test_igl, "nle_crit_gw_test_igl =") ## *TEST IF FORWARD CALCULATIONS EQUAL BACKWARD CALLCULATION* # 'ara' if icell_debug < 0: pass else: fw_ara = nle_crit_gw_test_ara.get_data(icell_debug) bw_ara = nle_crit_gw_ara.get_data(icell_debug) if fw_ara is None: print( "FW/BW_TEST:_Forward_calculation_not_possible:_Nin,crit = None" ) else: fw_ara = round(fw_ara, 4) bw_ara = round(bw_ara, 4) if fw_ara == bw_ara: print("FW/BW_TEST_ARABLE_LAND = SUCCESFUL") else: print("FW/BW_TEST_ARABLE_LAND = NOT_SUCCESFUL") # 'igl' if icell_debug < 0: pass else: fw_igl = nle_crit_gw_test_igl.get_data(icell_debug) bw_igl = nle_crit_gw_igl.get_data(icell_debug) if fw_igl is None: print( "FW/BW_TEST:_Forward_calculation_not_possible:_Nin,crit = None" ) else: fw_igl = round(fw_igl, 4) bw_igl = round(bw_igl, 4) if fw_igl == bw_igl: print("FW/BW_TEST_INTENSIVE_GRASSLAND = SUCCESFUL") else: print("FW/BW_TEST_INTENSIVE_GRASSLAND = NOT_SUCCESFUL")
def allocation_emission(params,mask,isocode,isogrid,PopNum,popgrid,PopCon,PopUrb,\ NtotConnected_eff,PtotConnected_eff,NnotConnected_eff,PnotConnected_eff,\ NtotConnected,\ N_PrimRemoval,PrimTreatment,\ N_SecRemoval,SecTreatment,\ N_TertRemoval,TertTreatment,\ Nemiss_rural_sw,Pemiss_rural_sw,\ PopNum_coast,popgrid_coast): ''' Allocation of the emission on the basis of the population grid (actually the population density). ''' # Create a list to store key numbers which are not used on the grid. keys_lost = [] # Read land area landarea = ascraster.Asciigrid(ascii_file=params.landarea,mask=mask,numtype=float) # Calculate the number of connected people and the number of non-connected people (with emission to surface water in urban areas). PopConNum = {} PopNoConNum = {} PopNum_rural = {} for key in isocode: PopConNum[key] = (0.01 * PopCon[key]) * PopNum[key] PopNoConNum[key] = (0.01 * max(0.0,PopUrb[key] - PopCon[key])) * PopNum[key] PopNum_rural[key] = PopNum[key] - PopConNum[key] - PopNoConNum[key] print_debug("PopConNum begin allocation function",PopConNum) print_debug("PopNoConNum",PopNoConNum) print_debug("NtotConnected_eff",NtotConnected_eff) print_debug("PtotConnected_eff",PtotConnected_eff) print_debug("NnotConnected_eff",NnotConnected_eff) print_debug("PnotConnected_eff",PnotConnected_eff) print_debug("NtotConnected",NtotConnected) print_debug("PrimTreatment",PrimTreatment) print_debug("SecTreatment",SecTreatment) print_debug("TertTreatment",TertTreatment) print_debug("N_PrimRemoval",N_PrimRemoval) print_debug("N_SecRemoval",N_SecRemoval) print_debug("N_TertRemoval",N_TertRemoval) print_debug("Nemiss_rural_sw",Nemiss_rural_sw) print_debug("Pemiss_rural_sw",Pemiss_rural_sw) # Distribute the connected and the no connected urban people with as weighing the population density map. # Here a ranking method is used. Highest population density gets first, until all connected and non connected # people are assigned. # Create two output grids with zeros and fill these with the ranking method. gPopNum = ascraster.duplicategrid(popgrid) gPopNum.add_values(popgrid.length * [0.0]) gPopConNum = ascraster.duplicategrid(popgrid) gPopConNum.add_values(popgrid.length * [0.0]) gPopNoConNum = ascraster.duplicategrid(popgrid) gPopNoConNum.add_values(popgrid.length * [0.0]) gPopNum_rural = ascraster.duplicategrid(popgrid) gPopNum_rural.add_values(popgrid.length * [0.0]) gEmNsw = ascraster.duplicategrid(landarea) gEmNsw.add_values(landarea.length * [0.0]) gEmPsw = ascraster.duplicategrid(landarea) gEmPsw.add_values(landarea.length * [0.0]) if (params.output_per_treatment == 1): gEmNsw_notreat = ascraster.duplicategrid(landarea) gEmNsw_notreat.add_values(landarea.length * [0.0]) gEmNsw_prim = ascraster.duplicategrid(landarea) gEmNsw_prim.add_values(landarea.length * [0.0]) gEmNsw_sec = ascraster.duplicategrid(landarea) gEmNsw_sec.add_values(landarea.length * [0.0]) gEmNsw_tert = ascraster.duplicategrid(landarea) gEmNsw_tert.add_values(landarea.length * [0.0]) gEmNsw_notcon = ascraster.duplicategrid(landarea) gEmNsw_notcon.add_values(landarea.length * [0.0]) gEmNsw_con = ascraster.duplicategrid(landarea) gEmNsw_con.add_values(landarea.length * [0.0]) gEmNsw_rural = ascraster.duplicategrid(landarea) gEmNsw_rural.add_values(landarea.length * [0.0]) # Make a dictionairy of pointers for all the isocodes in the grid. pointer_dict = {} for icell in xrange(isogrid.length): iso = isogrid.get_data(icell) if (iso != None): iso = int(iso) try: pointer_dict[iso].append(icell) except KeyError: pointer_dict[iso] = [icell] for key in isocode: # Select population of the key country # First step is to allocate the people which are connected with ranking. weight_key = [] qmax_key = [] try: pointer1 = pointer_dict[key] except KeyError: pointer1 = [] sumqmax = 0.0 sumweight = 0.0 for icell in pointer1: area = landarea.get_data(icell,0.0) pop = popgrid.get_data(icell,0.0) pop_coast = popgrid_coast.get_data(icell,0.0) # Fill weighing data and max data qmax_key.append(pop-pop_coast) # Here weighing with population density is needed in stead of population numbers. try: weight_key.append(pop/area) except ZeroDivisionError: weight_key.append(0.0) sumqmax += qmax_key[-1] sumweight += weight_key[-1] # Grid these country connected population data with help of the population density map PopNum_reg = PopConNum[key] popconnum_new = allocranking.allocranking(PopNum_reg,sumweight,weight_key,qmax_key) # Fill gridded result for item in xrange(len(popconnum_new)): gPopConNum.set_data(pointer1[item],popconnum_new[item]) # Second step is to allocate the people which are not connected with ranking. # Note that the results of the first step are used here. Where connected people are living, # there are no non connected people. Because all input has been changed by allocranking, we have to # recalculate the input again. weight_key = [] qmax_key = [] sumqmax = 0.0 sumweight = 0.0 for item in xrange(len(pointer1)): icell = pointer1[item] area = landarea.get_data(icell,0.0) pop = popgrid.get_data(icell,0.0) pop_coast = popgrid_coast.get_data(icell,0.0) # Fill weighing data and max data qmax_key.append(pop - popconnum_new[item] - pop_coast) # Here weighing with population density is needed in stead of population numbers. try: weight_key.append(pop/area) except ZeroDivisionError: weight_key.append(0.0) sumqmax += qmax_key[-1] sumweight += weight_key[-1] # Grid these country not connected population data with help of the population density map PopNum_reg = PopNoConNum[key] popnoconnum_new = allocranking.allocranking(PopNum_reg,sumweight,weight_key,qmax_key) # Fill gridded result for item in xrange(len(popnoconnum_new)): gPopNoConNum.set_data(pointer1[item],popnoconnum_new[item]) # Calculate the rural population ( as rest of total minus connected and not-connected) # Substract the connect people and the not connected people. popnum_rural_new = [] for item in xrange(len(popnoconnum_new)): val = max(popgrid.get_data(pointer1[item],0.0) - popgrid_coast.get_data(pointer1[item],0.0)- popconnum_new[item] - popnoconnum_new[item],0.0) popnum_rural_new.append(val) gPopNum_rural.set_data(pointer1[item],val) # # calculate P and N emission per gridcell # # Fill gridded result try: NConnected_per_inh = NtotConnected[key]/PopConNum[key] except ZeroDivisionError: NConnected_per_inh = 0.0 try: NConnected_eff_per_inh = NtotConnected_eff[key]/PopConNum[key] except ZeroDivisionError: NConnected_eff_per_inh = 0.0 try: NnoConnected_eff_per_inh = NnotConnected_eff[key]/PopNoConNum[key] except ZeroDivisionError: NnoConnected_eff_per_inh = 0.0 try: PConnected_eff_per_inh = PtotConnected_eff[key]/PopConNum[key] except ZeroDivisionError: PConnected_eff_per_inh = 0.0 try: PnoConnected_eff_per_inh = PnotConnected_eff[key]/PopNoConNum[key] except ZeroDivisionError: PnoConnected_eff_per_inh = 0.0 try: Nemiss_rural_sw_per_inh = Nemiss_rural_sw[key]/PopNum_rural[key] except ZeroDivisionError: Nemiss_rural_sw_per_inh = 0.0 try: Pemiss_rural_sw_per_inh = Pemiss_rural_sw[key]/PopNum_rural[key] except ZeroDivisionError: Pemiss_rural_sw_per_inh = 0.0 # Allocate the load on the grid. for item in xrange(len(popnoconnum_new)): # Popconnum has a length of whole region. load = popconnum_new[item] * NConnected_eff_per_inh + popnoconnum_new[item] * NnoConnected_eff_per_inh +\ popnum_rural_new[item] * Nemiss_rural_sw_per_inh gEmNsw.set_data(pointer1[item],load) load = popconnum_new[item] * PConnected_eff_per_inh + popnoconnum_new[item] * PnoConnected_eff_per_inh +\ popnum_rural_new[item] * Pemiss_rural_sw_per_inh gEmPsw.set_data(pointer1[item],load) if (params.output_per_treatment == 1): load = popconnum_new[item] * max(0.0,(1.0 - PrimTreatment[key] - \ SecTreatment[key] - TertTreatment[key])) * NConnected_per_inh gEmNsw_notreat.set_data(pointer1[item],load) load = popconnum_new[item] * PrimTreatment[key] * (1.0 - N_PrimRemoval[key] * 0.01) * NConnected_per_inh gEmNsw_prim.set_data(pointer1[item],load) load = popconnum_new[item] * SecTreatment[key] * (1.0 - N_SecRemoval[key] * 0.01) * NConnected_per_inh gEmNsw_sec.set_data(pointer1[item],load) load = popconnum_new[item] * TertTreatment[key] * (1.0 - N_TertRemoval[key] * 0.01) * NConnected_per_inh gEmNsw_tert.set_data(pointer1[item],load) load = popconnum_new[item] * NConnected_eff_per_inh gEmNsw_con.set_data(pointer1[item],load) load = popnoconnum_new[item] * NnoConnected_eff_per_inh gEmNsw_notcon.set_data(pointer1[item],load) # Fill rural emissions load = popnum_rural_new[item] * Nemiss_rural_sw_per_inh gEmNsw_rural.set_data(pointer1[item],load) # Write to output file gEmNsw.write_ascii_file(params.filegEmNsw) gEmPsw.write_ascii_file(params.filegEmPsw) gPopConNum.write_ascii_file(params.filegPopConNum) gPopNoConNum.write_ascii_file(params.filegPopNoConNum) gPopNum_rural.write_ascii_file(params.filegPopNum_rural) if (params.output_per_treatment == 1): gEmNsw_notreat.write_ascii_file(params.filegEmNsw_notreat) gEmNsw_prim.write_ascii_file(params.filegEmNsw_prim) gEmNsw_sec.write_ascii_file(params.filegEmNsw_sec) gEmNsw_tert.write_ascii_file(params.filegEmNsw_tert) gEmNsw_con.write_ascii_file(params.filegEmNsw_con) gEmNsw_notcon.write_ascii_file(params.filegEmNsw_notcon) gEmNsw_rural.write_ascii_file(params.filegEmNsw_rural) print_debug("Nsw_total_grid",total(isogrid,gEmNsw)) print_debug("Psw_total_grid",total(isogrid,gEmPsw)) print_debug("Nsw_popconnum_grid",total(isogrid,gPopConNum)) print_debug("Nsw_popnoconnum_grid",total(isogrid,gPopNoConNum)) print_debug("Nsw_popnum_rural_grid",total(isogrid,gPopNum_rural)) if (params.output_per_treatment == 1): print_debug("Nsw_notreat_grid",total(isogrid,gEmNsw_notreat)) print_debug("Nsw_prim_grid",total(isogrid,gEmNsw_prim)) print_debug("Nsw_sec_grid",total(isogrid,gEmNsw_sec)) print_debug("Nsw_tert_grid",total(isogrid,gEmNsw_tert)) print_debug("Nsw_con_grid",total(isogrid,gEmNsw_con)) print_debug("Nsw_notcon_grid",total(isogrid,gEmNsw_notcon)) print_debug("Nsw_rural_grid",total(isogrid,gEmNsw_rural)) print_debug("GRID: Global total N to surface water: ",total_dict(total(isogrid,gEmNsw))) print_debug("Global total N to surface water: ",total_dict(NtotConnected_eff)+total_dict(NnotConnected_eff)) print_debug("GRID: Global total P to surface water: ",total_dict(total(isogrid,gEmPsw))) print_debug("Global total P to surface water: ",total_dict(PtotConnected_eff)+total_dict(PnotConnected_eff)) if (params.output_per_treatment == 1): print_debug("GRID: Global total N not_treated to surface water: ",total_dict(total(isogrid,gEmNsw_notreat))) print_debug("GRID: Global total N primairy treatment to surface water: ",total_dict(total(isogrid,gEmNsw_prim))) print_debug("GRID: Global total N secondary treatment to surface water: ",total_dict(total(isogrid,gEmNsw_sec))) print_debug("GRID: Global total N tertairy treatment to surface water: ",total_dict(total(isogrid,gEmNsw_tert))) print_debug("GRID: Global total N connected part to surface water: ",total_dict(total(isogrid,gEmNsw_con))) print_debug("Global total N connected part to surface water: ",total_dict(NtotConnected_eff)) print_debug("GRID: Global total N non-connected part to surface water: ",total_dict(total(isogrid,gEmNsw_notcon))) print_debug("Global total N non-connected part to surface water: ",total_dict(NnotConnected_eff)) print_debug("GRID: Global total N rural part to surface water: ",total_dict(total(isogrid,gEmNsw_rural))) print_debug("Global total N rural part to surface water: ",total_dict(Nemiss_rural_sw)) # Make sum of all treatments to check whether everything is oke. gcheck = ascraster.duplicategrid(gEmNsw_notreat) gcheck.add(gEmNsw_prim) gcheck.add(gEmNsw_sec) gcheck.add(gEmNsw_tert) print_debug("GRID: Global total N connected part (as sum of all the treatment grids to surface water: ",total_dict(total(isogrid,gcheck))) print_debug("GRID: Global total N connected part to surface water: ",total_dict(total(isogrid,gEmNsw_con)))
def temp_values(params): ### --------- 1. LAND UNSE FRACTIONS --------- ### # read input files land areas a_tot = ascraster.Asciigrid(ascii_file=params.filename_gridcell_area, numtype=float,mask=params.mask) a_ag = ascraster.Asciigrid(ascii_file=params.filename_agri_area, numtype=float,mask=params.mask) a_ara = ascraster.Asciigrid(ascii_file=params.filename_cropland_area, numtype=float,mask=params.mask) a_igl = ascraster.Asciigrid(ascii_file=params.filename_intgl_area, numtype=float,mask=params.mask) a_egl = ascraster.Asciigrid(ascii_file=params.filename_extgl_area, numtype=float,mask=params.mask) a_nat = ascraster.Asciigrid(ascii_file=params.filename_natural_area, numtype=float,mask=params.mask) # calculate f*g f*g = ascraster.duplicategrid(a_ag) f*g.divide(a_tot, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"f*g.asc") f*g.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(f*g,"f*g =") # calculate fara fara = ascraster.duplicategrid(a_ara) fara.divide(a_tot, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"fara.asc") fara.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(fara,"fara =") # calculate figl figl = ascraster.duplicategrid(a_igl) figl.divide(a_tot, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"figl.asc") figl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(figl,"figl =") # calculate fegl fegl = ascraster.duplicategrid(a_egl) fegl.divide(a_tot, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"fegl.asc") fegl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(fegl,"fegl =") # calculate fnat fnat = ascraster.duplicategrid(a_nat) fnat.divide(a_tot, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"fnat.asc") fnat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fnat,"fnat =") ### --------- 2. INPUTS FERTILIZER, MANURE, FIXATION --------- ### # read input files N inputs nfer_eff_ag = ascraster.Asciigrid(ascii_file=params.filename_fert_inp, numtype=float,mask=params.mask) nfer_eff_ara = ascraster.Asciigrid(ascii_file=params.filename_fert_inp_cropland, numtype=float,mask=params.mask) nfer_eff_igl = ascraster.Asciigrid(ascii_file=params.filename_fert_inp_grassland, numtype=float,mask=params.mask) nman_eff_ag = ascraster.Asciigrid(ascii_file=params.filename_manure_inp, numtype=float,mask=params.mask) nman_eff_ara = ascraster.Asciigrid(ascii_file=params.filename_manure_inp_cropland, numtype=float,mask=params.mask) nman_eff_igl = ascraster.Asciigrid(ascii_file=params.filename_manure_inp_intgl, numtype=float,mask=params.mask) nman_eff_egl = ascraster.Asciigrid(ascii_file=params.filename_manure_inp_extgl, numtype=float,mask=params.mask) nfix_ag = ascraster.Asciigrid(ascii_file=params.filename_nfixation_agri, numtype=float,mask=params.mask) nfix_ara = ascraster.Asciigrid(ascii_file=params.filename_nfixation_cropland, numtype=float,mask=params.mask) nfix_igl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_intgl, numtype=float,mask=params.mask) nfix_egl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_extgl, numtype=float,mask=params.mask) nfix_nat = ascraster.Asciigrid(ascii_file=params.filename_nfixation_nat, numtype=float,mask=params.mask) # read input files NH3 emissions nh3_spread_man = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_manure, numtype=float,mask=params.mask) nh3_spread_man_ara = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_manure_cropland, numtype=float,mask=params.mask) nh3_spread_man_igl = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_manure_intgl, numtype=float,mask=params.mask) nh3_spread_man_egl = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_manure_extgl, numtype=float,mask=params.mask) nh3_stor = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_storage, numtype=float,mask=params.mask) nh3_graz = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_grazing, numtype=float,mask=params.mask) nh3_graz_igl = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_grazing_int, numtype=float,mask=params.mask) nh3_graz_egl = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_grazing_ext, numtype=float,mask=params.mask) nh3_spread_fer = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_fert, numtype=float,mask=params.mask) nh3_spread_fer_ara = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_fert_cropland, numtype=float,mask=params.mask) nh3_spread_fer_igl = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_fert_intgl, numtype=float,mask=params.mask) nh3_spread_fer_egl = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_spread_fert_extgl, numtype=float,mask=params.mask) # split nh3 emissions from storage over intensive grassland, extensive grassland & arable land # intensive grassland nh3_stor_igl = ascraster.duplicategrid(nh3_stor) for icell in range(nh3_stor_igl.length): igl = a_igl.get_data(icell) nh3stor = nh3_stor.get_data(icell) if (igl == None or igl==0) : nh3emigl = 0 elif (igl > 0) : nh3emigl = nh3stor else: continue nh3_stor_igl.set_data(icell,nh3emigl) fileout = os.path.join(params.outputdir, "nh3_stor_igl.asc") nh3_stor_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_stor_igl,"nh3_stor_igl =") # extensive grassland nh3_stor_egl = ascraster.duplicategrid(nh3_stor) for icell in range(nh3_stor_egl.length): egl = a_egl.get_data(icell) nh3stor = nh3_stor.get_data(icell) if (egl == None or egl==0) : nh3emegl = 0 elif (egl > 0) : nh3emegl = nh3stor else: continue nh3_stor_egl.set_data(icell,nh3emegl) fileout = os.path.join(params.outputdir, "nh3_stor_egl.asc") nh3_stor_egl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_stor_egl,"nh3_stor_egl =") # arable land nh3_stor_ara = ascraster.duplicategrid(nh3_stor) for icell in range(nh3_stor_ara.length): ara = a_ara.get_data(icell) igl = a_igl.get_data(icell) egl = a_egl.get_data(icell) nh3stor = nh3_stor.get_data(icell) if (ara == None) : nh3emara = 0 elif (egl == 0 and igl == 0) : nh3emara = nh3stor elif (egl > 0 or igl > 0): nh3emara = 0 nh3emara = 0 else: continue nh3_stor_ara.set_data(icell,nh3emara) fileout = os.path.join(params.outputdir, "nh3_stor_ara.asc") nh3_stor_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_stor_ara,"nh3_stor_ara =") # Calculate total N inputs from *FERTILIZER* (incl. NH3 emissions) # 'ag' nfer_ag = ascraster.duplicategrid(nfer_eff_ag) nfer_ag.add(nh3_spread_fer) fileout = os.path.join(params.outputdir,"nfer_ag.asc") nfer_ag.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nfer_ag,"nfer_ag =") # 'ara' nfer_ara = ascraster.duplicategrid(nfer_eff_ara) nfer_ara.add(nh3_spread_fer_ara) fileout = os.path.join(params.outputdir,"nfer_ara.asc") nfer_ara.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nfer_ara,"nfer_ara =") # 'igl' nfer_igl = ascraster.duplicategrid(nfer_eff_igl) nfer_igl.add(nh3_spread_fer_igl) fileout = os.path.join(params.outputdir,"nfer_igl.asc") nfer_igl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nfer_igl,"nfer_igl =") # 'araigl' nfer_araigl = ascraster.duplicategrid(nfer_ara) nfer_araigl.add(nfer_igl) fileout = os.path.join(params.outputdir,"nfer_araigl.asc") nfer_araigl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) # Calculate total N inputs from *MANURE* (incl. NH3 emissions) # 'ag' nman_ag = ascraster.duplicategrid(nman_eff_ag) nman_ag.add(nh3_spread_man) nman_ag.add(nh3_stor) nman_ag.add(nh3_graz) fileout = os.path.join(params.outputdir,"nman_ag.asc") nman_ag.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nman_ag,"nman_ag =") # 'ara' nman_ara = ascraster.duplicategrid(nman_eff_ara) nman_ara.add(nh3_spread_man_ara) nman_ara.add(nh3_stor_ara) fileout = os.path.join(params.outputdir,"nman_ara.asc") nman_ara.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nman_ara,"nman_ara =") # 'igl' nman_igl = ascraster.duplicategrid(nman_eff_igl) nman_igl.add(nh3_spread_man_igl) nman_igl.add(nh3_stor_igl) nman_igl.add(nh3_graz_igl) fileout = os.path.join(params.outputdir,"nman_igl.asc") nman_igl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nman_igl,"nman_igl =") # 'egl' nman_egl = ascraster.duplicategrid(nman_eff_egl) nman_egl.add(nh3_spread_man_egl) nman_egl.add(nh3_stor_egl) nman_egl.add(nh3_graz_egl) fileout = os.path.join(params.outputdir,"nman_egl.asc") nman_egl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) print_debug(nman_egl,"nman_egl =") # 'araigl' nman_araigl = ascraster.duplicategrid(nman_ara) nman_araigl.add(nman_igl) fileout = os.path.join(params.outputdir,"nman_araigl.asc") nman_araigl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) # Calculate total N inputs from *MANURE AND FERTILIZER* (incl. NH3 emissions) # 'ara' nman_fer_ara = ascraster.duplicategrid(nman_ara) nman_fer_ara.add(nfer_ara) fileout = os.path.join(params.outputdir,"nman_fer_ara.asc") nman_fer_ara.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) # 'igl' nman_fer_igl = ascraster.duplicategrid(nman_igl) nman_fer_igl.add(nfer_igl) fileout = os.path.join(params.outputdir,"nman_fer_igl.asc") nman_fer_igl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) # 'araigl' nman_fer_araigl = ascraster.duplicategrid(nman_fer_ara) nman_fer_araigl.add(nman_fer_igl) fileout = os.path.join(params.outputdir,"nman_fer_araigl.asc") nman_fer_araigl.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) ## calculate *frNfe* # 'ara' fer_man_ara = ascraster.duplicategrid(nman_ara) fer_man_ara.add(nfer_ara) frnfe_ara = ascraster.duplicategrid(nfer_ara) frnfe_ara.divide(fer_man_ara, default_nodata_value = -9999) # replace '0' by 0.0001 in frnfe_ara for icell in range(frnfe_ara.length): val = frnfe_ara.get_data(icell) if (val == None or val > 0): continue if val == 0.0: res = 0.0001 frnfe_ara.set_data(icell,res) # replace '1' by 0.9999 in frnfe_ara for icell in range(frnfe_ara.length): val = frnfe_ara.get_data(icell) if (val == None or val < 1): continue if val == 1.0: res = 0.9999 frnfe_ara.set_data(icell,res) fileout = os.path.join(params.outputdir,"frnfe_ara.asc") frnfe_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(frnfe_ara,"frnfe_ara =") # 'igl' fer_man_igl = ascraster.duplicategrid(nman_igl) fer_man_igl.add(nfer_igl) frnfe_igl = ascraster.duplicategrid(nfer_igl) frnfe_igl.divide(fer_man_igl, default_nodata_value = -9999) # replace '0' by 0.0001 in frnfe_igl for icell in range(frnfe_igl.length): val = frnfe_igl.get_data(icell) if (val == None or val > 0): continue if val == 0.0: res = 0.0001 frnfe_igl.set_data(icell,res) # replace '1' by 0.9999 in frnfe_igl for icell in range(frnfe_igl.length): val = frnfe_igl.get_data(icell) if (val == None or val < 1): continue if val == 1.0: res = 0.9999 frnfe_igl.set_data(icell,res) fileout = os.path.join(params.outputdir,"frnfe_igl.asc") frnfe_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(frnfe_igl,"frnfe_igl =") ## Calculate proportion of N inputs in total (arable + intensive grassland) N inputs # 'ara' frn_ara = ascraster.duplicategrid(nman_ara) frn_ara.add(nfer_ara) denominator_frn_ara = ascraster.duplicategrid(frn_ara) denominator_frn_ara.add(nman_igl) denominator_frn_ara.add(nfer_igl) frn_ara.divide(denominator_frn_ara, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"frn_ara.asc") frn_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(frn_ara,"frn_ara =") # 'igl' frn_igl = ascraster.duplicategrid(nman_igl) frn_igl.add(nfer_igl) denominator_frn_igl = ascraster.duplicategrid(frn_igl) denominator_frn_igl.add(nman_ara) denominator_frn_igl.add(nfer_ara) frn_igl.divide(denominator_frn_igl, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"frn_igl.asc") frn_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(frn_igl,"frn_igl =") ### --------- 3. NH3 EMISSIONS & EMISSION FRACTIONS --------- ### # calculate *TOTAL NH3 EMISSION* # 'ag' nh3_tot_ag = ascraster.duplicategrid(nh3_spread_man) nh3_tot_ag.add(nh3_spread_fer) nh3_tot_ag.add(nh3_stor) nh3_tot_ag.add(nh3_graz) print_debug(nh3_tot_ag,"nh3_tot_ag =") # 'ara' nh3_tot_ara = ascraster.duplicategrid(nh3_spread_man_ara) nh3_tot_ara.add(nh3_spread_fer_ara) nh3_tot_ara.add(nh3_stor_ara) fileout = os.path.join(params.outputdir,"nh3_tot_ara.asc") nh3_tot_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_tot_ara,"nh3_tot_ara =") # 'igl' nh3_tot_igl = ascraster.duplicategrid(nh3_spread_man_igl) nh3_tot_igl.add(nh3_spread_fer_igl) nh3_tot_igl.add(nh3_stor_igl) nh3_tot_igl.add(nh3_graz_igl) fileout = os.path.join(params.outputdir,"nh3_tot_igl.asc") nh3_tot_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_tot_igl,"nh3_tot_igl =") # 'egl' nh3_tot_egl = ascraster.duplicategrid(nh3_spread_man_egl) nh3_tot_egl.add(nh3_spread_fer_egl) nh3_tot_egl.add(nh3_stor_egl) nh3_tot_egl.add(nh3_graz_egl) fileout = os.path.join(params.outputdir,"nh3_tot_egl.asc") nh3_tot_egl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_tot_egl,"nh3_tot_egl =") # calculate *FNH3EM,MAN* # 'ara' nh3_man_tot_ara = ascraster.duplicategrid(nh3_spread_man_ara) nh3_man_tot_ara.add(nh3_stor_ara) nh3_ef_man_ara = griddivide(nh3_man_tot_ara,nman_ara,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"nh3_ef_man_ara.asc") nh3_ef_man_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_man_ara,"nh3_ef_man_ara =") # 'igl' nh3_man_tot_igl = ascraster.duplicategrid(nh3_spread_man_igl) nh3_man_tot_igl.add(nh3_stor_igl) nh3_man_tot_igl.add(nh3_graz_igl) nh3_ef_man_igl = griddivide(nh3_man_tot_igl,nman_igl,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"nh3_ef_man_igl.asc") nh3_ef_man_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_man_igl,"nh3_ef_man_igl =") # calculate *FNH3EM,FER* # 'ara' nh3_ef_fer_ara = griddivide(nh3_spread_fer_ara,nfer_ara,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"nh3_ef_fer_ara.asc") nh3_ef_fer_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_fer_ara,"nh3_ef_fer_ara =") # 'igl' nh3_ef_fer_igl = griddivide(nh3_spread_fer_igl,nfer_igl,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"nh3_ef_fer_igl.asc") nh3_ef_fer_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_fer_igl,"nh3_ef_fer_igl =") # calculate *FNH3EM,MAN,FER* # 'ara' nh3_ef_man_fer_ara = griddivide(nh3_tot_ara,fer_man_ara,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"nh3_ef_man_fer_ara.asc") nh3_ef_man_fer_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_man_fer_ara,"nh3_ef_man_fer_ara =") # 'igl' nh3_ef_man_fer_igl = griddivide(nh3_tot_igl,fer_man_igl,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"nh3_ef_man_fer_igl.asc") nh3_ef_man_fer_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_man_fer_igl,"nh3_ef_man_fer_igl =") ### --------- 4. N DEPOSITION & NOx emission --------- ### # calculate corrected N deposition grid - for all cells where Ndep < NH3em, replace Ndep by NH3em ndep_tot = ascraster.Asciigrid(ascii_file=params.filename_n_deposition,numtype=float,mask=params.mask) ndep_corr_tot = ascraster.duplicategrid(ndep_tot) for icell in range(nh3_tot_ag.length): # Get values from both grids. nh3 = nh3_tot_ag.get_data(icell) dep = ndep_tot.get_data(icell) # If both grids have nodata, keep nodata. if (nh3 == None or dep == None or dep >= nh3): continue if dep < nh3: depcorr = nh3 ndep_corr_tot.set_data(icell,depcorr) fileout = os.path.join(params.outputdir,"ndep_corr_tot.asc") ndep_corr_tot.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_tot,"ndep_tot =") print_debug(ndep_corr_tot,"ndep_corr_tot =") # calculate NOx emissions: NOx = *corrected* Ndep - (NH3,spread,fe+NH3,spread,man+NH3stor+NH3,graz) nox_em = ascraster.duplicategrid(ndep_corr_tot) nox_em.substract(nh3_tot_ag) #factor = 0 #nox_em.multiply(factor) fileout = os.path.join(params.outputdir,"nox_em.asc") nox_em.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nox_em,"nox_em =") ## *N DEPOSITION* # 'ag' ndep_ag = ascraster.duplicategrid(ndep_corr_tot) ndep_ag.multiply(f*g) print_debug(ndep_ag,"ndep_ag =") # 'ara' ndep_ara = ascraster.duplicategrid(ndep_corr_tot) ndep_ara.multiply(fara) print_debug(ndep_ara,"ndep_ara =") # 'igl' ndep_igl = ascraster.duplicategrid(ndep_corr_tot) ndep_igl.multiply(figl) print_debug(ndep_igl,"ndep_igl =") # 'egl' ndep_egl = ascraster.duplicategrid(ndep_corr_tot) ndep_egl.multiply(fegl) print_debug(ndep_egl,"ndep_egl =") # 'nat' ndep_nat = ascraster.duplicategrid(ndep_corr_tot) ndep_nat.multiply(fnat) print_debug(ndep_nat,"ndep_nat =") ### --------- 5. TOTAL INPUTS --------- ### ## Calculate *Total N Inputs* # 'ag' nin_ag = ascraster.duplicategrid(nfer_ag) nin_ag.add(nman_ag) nin_ag.add(nfix_ag) nin_ag.add(ndep_ag) print_debug(nin_ag,"nin_ag =") # 'ara' nin_ara = ascraster.duplicategrid(nfer_ara) nin_ara.add(nman_ara) nin_ara.add(nfix_ara) nin_ara.add(ndep_ara) fileout = os.path.join(params.outputdir,"nin_ara.asc") nin_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nin_ara,"nin_ara =") # 'igl' nin_igl = ascraster.duplicategrid(nfer_igl) nin_igl.add(nman_igl) nin_igl.add(nfix_igl) nin_igl.add(ndep_igl) fileout = os.path.join(params.outputdir,"nin_igl.asc") nin_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nin_igl,"nin_igl =") # 'araigl' nin_araigl = ascraster.duplicategrid(nin_ara) nin_araigl.add(nin_igl) fileout = os.path.join(params.outputdir,"nin_araigl.asc") nin_araigl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) # 'egl' nin_egl = ascraster.duplicategrid(nman_egl) nin_egl.add(nfix_egl) nin_egl.add(ndep_egl) print_debug(nin_egl,"nin_egl =") # 'nat' nin_nat = ascraster.duplicategrid(ndep_nat) nin_nat.add(nfix_nat) print_debug(nin_nat,"nin_nat =") ### --------- 6. SURFACE RUNOFF, UPTAKE, FRNUP, NUE --------- ### # read input files uptake, surface runoff nsro_ag = ascraster.Asciigrid(ascii_file=params.filename_nsro_ag, numtype=float,mask=params.mask) nsro_nat = ascraster.Asciigrid(ascii_file=params.filename_nsro_nat, numtype=float,mask=params.mask) nup_ara = ascraster.Asciigrid(ascii_file=params.filename_uptake_cropland, numtype=float,mask=params.mask) nup_igl = ascraster.Asciigrid(ascii_file=params.filename_uptake_intgl, numtype=float,mask=params.mask) nup_egl = ascraster.Asciigrid(ascii_file=params.filename_uptake_extgl, numtype=float,mask=params.mask) regions = ascraster.Asciigrid(ascii_file=params.filename_regions, numtype=float,mask=params.mask) #$# To manipulate results for 1999 so that I can also get uptake per land-use type (assuming equal NUE) #$#nup_ag = ascraster.Asciigrid(ascii_file=params.filename_uptake_agriculture, numtype=float,mask=params.mask) #$# #$#nue_ag = ascraster.duplicategrid(nup_ag) #$#nue_ag.divide(nin_ag, default_nodata_value = -9999) #$#nup_ara = ascraster.duplicategrid(nin_ara) #$#nup_ara.multiply(nue_ag) #$#fileout = os.path.join(params.inputdir,"n_up_crops.asc") #$#nup_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) #$#nup_igl = ascraster.duplicategrid(nin_igl) #$#nup_igl.multiply(nue_ag) #$#fileout = os.path.join(params.inputdir,"n_up_grass_int.asc") #$#nup_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) #$#nup_egl = ascraster.duplicategrid(nin_egl) #$#nup_egl.multiply(nue_ag) #$#fileout = os.path.join(params.inputdir,"n_up_grass_ext.asc") #$#nup_egl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) ## *N UPTAKE* # 'ag' nup_ag = ascraster.duplicategrid(nup_ara) nup_ag.add(nup_igl) nup_ag.add(nup_egl) print_debug(nup_ag,"nup_ag =") ## *SURFACE RUNOFF FRACTION* # 'ag' fsro_ag = griddivide(nsro_ag,nin_ag,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"fsro_ag.asc") fsro_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fsro_ag,"fsro_ag =") # 'nat' fsro_nat = griddivide(nsro_nat,nin_nat,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"fsro_nat.asc") fsro_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fsro_nat,"fsro_nat =") ## *N LOAD FROM SURFACE RUNOFF* # 'ara' nsro_ara = ascraster.duplicategrid(nin_ara) nsro_ara.multiply(fsro_ag) print_debug(nsro_ara,"nsro_ara =") # 'igl' nsro_igl = ascraster.duplicategrid(nin_igl) nsro_igl.multiply(fsro_ag) print_debug(nsro_igl,"nsro_igl =") ## *N UPTAKE FRACTION* # 'ara' nin_min_nsro_ara = ascraster.duplicategrid(nin_ara) nin_min_nsro_ara.substract(nsro_ara) frnup_ara = griddivide(nup_ara,nin_min_nsro_ara,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"frnup_ara.asc") frnup_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(frnup_ara,"frnup_ara =") # 'igl' nin_min_nsro_igl = ascraster.duplicategrid(nin_igl) nin_min_nsro_igl.substract(nsro_igl) frnup_igl = griddivide(nup_igl,nin_min_nsro_igl,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"frnup_igl.asc") frnup_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(frnup_igl,"frnup_igl =") ## *NUE* # 'ara' nue_ara = ascraster.duplicategrid(nup_ara) nue_ara.divide(nin_ara, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"nue_ara.asc") nue_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_ara,"nue_ara =") # 'igl' nue_igl = ascraster.duplicategrid(nup_igl) nue_igl.divide(nin_igl, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"nue_igl.asc") nue_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_igl,"nue_igl =") ## *MAXIMUM N UPTAKE* # make grid with yield increase per region yieldgap_region = ascraster.duplicategrid(nup_ara) for i in range(yieldgap_region.length): yieldgap_region.set_data(i,-9999) for icell in range(regions.length): val = regions.get_data(icell) # Canada (1) if val == 1: yg = 1.274 # USA (2) elif val == 2: yg = 1.252 # Mexico (3) elif val == 3: yg = 1.566 # Central America (4) elif val == 4: yg = 1.797 # Brazil (5) elif val == 5: yg = 1.343 # Rest of South America (6) elif val == 6: yg = 1.532 # Northern Africa (7) elif val == 7: yg = 2.711 # Western Africa (8) elif val == 8: yg = 2.363 # Eastern Africa (9) elif val == 9: yg = 2.424 # South Africa (10) elif val == 10: yg = 1.848 # Western Europe (11) elif val == 11: yg = 1.177 # Central Europe (12) elif val == 12: yg = 1.982 # Turkey (13) elif val == 13: yg = 1.797 # Ukraine region (14) elif val == 14: yg = 2.633 # Central Asia (15) elif val == 15: yg = 2.928 # Russia region(16) elif val == 16: yg = 2.391 # Middle East (17) elif val == 17: yg = 2.170 # India (18) elif val == 18: yg = 1.508 # Korea region (19) elif val == 19: yg = 1.180 # China region (20) elif val == 20: yg = 1.503 # Southeastern Asia (21) elif val == 21: yg = 1.479 # Indonesia region (22) elif val == 22: yg = 1.267 # Japan (23) elif val == 23: yg = 1.180 # Oceania (24) elif val == 24: yg = 1.487 # Rest of South Asia (25) elif val == 25: yg = 1.870 # Rest of Southern Africa (26) elif val == 26: yg = 2.551 # Greenland (27) elif val == 27: yg = 1.000 # Region can also have value none (-9999) else: continue yieldgap_region.set_data(icell,yg) print_debug(regions,"region_number =") fileout = os.path.join(params.outputdir,"yieldgap_region.asc") yieldgap_region.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(yieldgap_region,"yieldgap =") # calculate Nup(max) = Nup * yieldgap_region # 'ara' nup_max_ara = ascraster.duplicategrid(nup_ara) nup_max_ara.multiply(yieldgap_region) fileout = os.path.join(params.outputdir,"nup_max_ara.asc") nup_max_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nup_max_ara,"nup_max_ara =") # 'igl' nup_max_igl = ascraster.duplicategrid(nup_igl) nup_max_igl.multiply(yieldgap_region) fileout = os.path.join(params.outputdir,"nup_max_igl.asc") nup_max_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nup_max_igl,"nup_max_igl =") ## *CORRECTED NUE* (NUE used to calculate Nin at Nup,max should never be higher than 0.8) # 'ara' nue_corr_ara = ascraster.duplicategrid(nue_ara) for icell in range(nue_corr_ara.length): val = nue_corr_ara.get_data(icell) if (val == None or val <= 0.8): continue if val > 0.8: res = 0.8 nue_corr_ara.set_data(icell,res) fileout = os.path.join(params.outputdir,"nue_corr_ara.asc") nue_corr_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_corr_ara,"nue_corr_ara =") # 'igl' nue_corr_igl = ascraster.duplicategrid(nue_igl) for icell in range(nue_corr_igl.length): val = nue_corr_igl.get_data(icell) if (val == None or val <= 0.8): continue if val > 0.8: res = 0.8 nue_corr_igl.set_data(icell,res) fileout = os.path.join(params.outputdir,"nue_corr_igl.asc") nue_corr_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_corr_igl,"nue_corr_igl =") ## *MAXIMUM N INPUTS* (total N inputs from all sources that correspond to maximum uptake and a max. NUE of 0.8) # 'ara' nin_max_ara = ascraster.duplicategrid(nup_max_ara) nin_max_ara.divide(nue_corr_ara, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"nin_max_ara.asc") nin_max_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nin_max_ara,"nin_max_ara =") # 'igl' nin_max_igl = ascraster.duplicategrid(nup_max_igl) nin_max_igl.divide(nue_corr_igl, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"nin_max_igl.asc") nin_max_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nin_max_igl,"nin_max_igl =") ### --------- 7. BUDGET, LEACHING, DENITRIFICATION --------- ### # read input files ngw_ag = ascraster.Asciigrid(ascii_file=params.filename_groundwaterload_ag, numtype=float,mask=params.mask) ngw_nat = ascraster.Asciigrid(ascii_file=params.filename_groundwaterload_nat, numtype=float,mask=params.mask) fgw_rec_ag = ascraster.Asciigrid(ascii_file=params.filename_fraction_recent_groundwaterload_ag, numtype=float,mask=params.mask) fgw_rec_nat = ascraster.Asciigrid(ascii_file=params.filename_fraction_recent_groundwaterload_nat, numtype=float,mask=params.mask) nle_ag = ascraster.Asciigrid(ascii_file=params.filename_leaching_ag, numtype=float,mask=params.mask) nle_nat = ascraster.Asciigrid(ascii_file=params.filename_leaching_nat, numtype=float,mask=params.mask) # Scenarios 1+2+3 surface water #for i in range(fgw_rec_ag.length): # fgw_rec_ag.set_data(i,1.0) ## *N BUDGET* # 'ag' nbud_ag = ascraster.duplicategrid(nin_ag) nbud_ag.substract(nup_ag) print_debug(nbud_ag,"nbud_ag =") # 'ara' nbud_ara = ascraster.duplicategrid(nin_ara) nbud_ara.substract(nup_ara) print_debug(nbud_ara,"nbud_ara =") # 'igl' nbud_igl = ascraster.duplicategrid(nin_igl) nbud_igl.substract(nup_igl) print_debug(nbud_igl,"nbud_igl =") # 'nat' nbud_nat = ascraster.duplicategrid(nin_nat) print_debug(nbud_nat,"nbud_nat =") ## *N load to surface water via groundwater due to *recent* N inputs* # 'ag' ngw_rec_ag = ascraster.duplicategrid(ngw_ag) ngw_rec_ag.multiply(fgw_rec_ag) print_debug(ngw_rec_ag,"ngw_rec_ag =") # 'nat' ngw_rec_nat = ascraster.duplicategrid(ngw_nat) ngw_rec_nat.multiply(fgw_rec_nat) print_debug(ngw_rec_nat,"ngw_rec_nat =") ## *LEACHING FRACTION* # 'ag' nbud_min_nsro_ag = ascraster.duplicategrid(nbud_ag) nbud_min_nsro_ag.substract(nsro_ag) fle_ag = griddivide(nle_ag,nbud_min_nsro_ag,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"fle_ag.asc") fle_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fle_ag,"fle_ag =") # 'nat' nbud_min_nsro_nat = ascraster.duplicategrid(nbud_nat) nbud_min_nsro_nat.substract(nsro_nat) fle_nat = griddivide(nle_nat,nbud_min_nsro_nat,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"fle_nat.asc") fle_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fle_nat,"fle_nat =") ## *N LEACHING* # 'ara' nle_ara = ascraster.duplicategrid(nbud_ara) nle_ara.substract(nsro_ara) nle_ara.multiply(fle_ag) fileout = os.path.join(params.outputdir,"nle_ara.asc") nle_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nle_ara,"nle_ara =") # 'igl' nle_igl = ascraster.duplicategrid(nbud_igl) nle_igl.substract(nsro_igl) nle_igl.multiply(fle_ag) fileout = os.path.join(params.outputdir,"nle_igl.asc") nle_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nle_igl,"nle_igl =") ## *FRACTION OF RECENT DELIVERY TO LEACHING* (fraction of N leaching that is delivered to surface water via groundwater in first x years) # 'ag' fgw_rec_le_ag = griddivide(ngw_rec_ag,nle_ag,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"fgw_rec_le_ag.asc") fgw_rec_le_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fgw_rec_le_ag,"fgw_rec_le_ag =") # 'nat' fgw_rec_le_nat = griddivide(ngw_rec_nat,nle_nat,default_nodata_value = 0) fileout = os.path.join(params.outputdir,"fgw_rec_le_nat.asc") fgw_rec_le_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fgw_rec_le_nat,"fgw_rec_le_nat =") ## *VARIABLE N LOAD TO SURFACE WATER* # 'ag' nload_var_ag = ascraster.duplicategrid(ngw_rec_ag) nload_var_ag.add(nsro_ag) fileout = os.path.join(params.outputdir,"nload_var_ag.asc") nload_var_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_var_ag,"nload_var_ag =") # 'nat' nload_var_nat = ascraster.duplicategrid(ngw_rec_nat) nload_var_nat.add(nsro_nat) fileout = os.path.join(params.outputdir,"nload_var_nat.asc") nload_var_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_var_nat,"nload_var_nat =") ## *FIXED LOAD TO SURFACE WATER* # 'ag' grid1 = ascraster.duplicategrid(fgw_rec_ag) for i in range(grid1.length): grid1.set_data(i,1.0) grid1.substract(fgw_rec_ag) nload_fixed_ag = ascraster.duplicategrid(ngw_ag) nload_fixed_ag.multiply(grid1) fileout = os.path.join(params.outputdir,"nload_fixed_ag.asc") nload_fixed_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_fixed_ag,"nload_fixed_ag =") # 'nat' grid2 = ascraster.duplicategrid(fgw_rec_nat) for i in range(grid2.length): grid2.set_data(i,1.0) grid2.substract(fgw_rec_nat) nload_fixed_nat = ascraster.duplicategrid(ngw_nat) nload_fixed_nat.multiply(grid2) fileout = os.path.join(params.outputdir,"nload_fixed_nat.asc") nload_fixed_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_fixed_nat,"nload_fixed_nat =") ## *TOTAL N LOAD FROM POINT SOURCES* nallo = ascraster.Asciigrid(ascii_file=params.filename_n_point_alloch_matter,numtype=float,mask=params.mask) nww = ascraster.Asciigrid(ascii_file=params.filename_n_point_wastewater,numtype=float,mask=params.mask) naqua = ascraster.Asciigrid(ascii_file=params.filename_n_point_aquaculture,numtype=float,mask=params.mask) ndep_sw = ascraster.Asciigrid(ascii_file=params.filename_n_point_dep_surfacewater,numtype=float,mask=params.mask) npoint_tot = ascraster.duplicategrid(nallo) npoint_tot.add(nww) npoint_tot.add(naqua) npoint_tot.add(ndep_sw) fileout = os.path.join(params.outputdir,"npoint_tot.asc") npoint_tot.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(npoint_tot,"npoint_tot =") ## *TOTAL N LOAD FROM EROSION* nero_ag = ascraster.Asciigrid(ascii_file=params.filename_n_in_erosion_ag,numtype=float,mask=params.mask) nero_nat = ascraster.Asciigrid(ascii_file=params.filename_n_in_erosion_nat,numtype=float,mask=params.mask) nero_tot = ascraster.duplicategrid(nero_ag) nero_tot.add(nero_nat) fileout = os.path.join(params.outputdir,"nero_tot.asc") nero_tot.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nero_tot,"nero_tot =") ## *TOTAL N LOAD TO SURFACE WATER* (Nload,tot = Nload,var,ag + Nload,var,nat + Ngw,fixed,ag + Ngw,fixed,nat + Npoint + Nero) nload_tot = ascraster.duplicategrid(nload_var_ag) nload_tot.add(nload_var_nat) nload_tot.add(nload_fixed_ag) nload_tot.add(nload_fixed_nat) nload_tot.add(npoint_tot) nload_tot.add(nero_tot) print_debug(nload_tot,"nload_tot =")
def temp_values(params): ### --------- 1. LAND UNSE FRACTIONS --------- ### # read input files land areas a_tot = ascraster.Asciigrid(ascii_file=params.filename_gridcell_area, numtype=float, mask=params.mask) a_ag = ascraster.Asciigrid(ascii_file=params.filename_agri_area, numtype=float, mask=params.mask) a_ara = ascraster.Asciigrid(ascii_file=params.filename_cropland_area, numtype=float, mask=params.mask) a_igl = ascraster.Asciigrid(ascii_file=params.filename_intgl_area, numtype=float, mask=params.mask) a_egl = ascraster.Asciigrid(ascii_file=params.filename_extgl_area, numtype=float, mask=params.mask) a_nat = ascraster.Asciigrid(ascii_file=params.filename_natural_area, numtype=float, mask=params.mask) # calculate f*g f*g = ascraster.duplicategrid(a_ag) f*g.divide(a_tot, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "f*g.asc") f*g.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(f*g, "f*g =") # calculate fara fara = ascraster.duplicategrid(a_ara) fara.divide(a_tot, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fara.asc") fara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fara, "fara =") # calculate figl figl = ascraster.duplicategrid(a_igl) figl.divide(a_tot, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "figl.asc") figl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(figl, "figl =") # calculate fagri fagri = ascraster.duplicategrid(a_ara) fagri.add(a_igl) fagri.divide(a_tot, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fagri.asc") fagri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fagri, "fagri =") # calculate fegl fegl = ascraster.duplicategrid(a_egl) fegl.divide(a_tot, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fegl.asc") fegl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fegl, "fegl =") # calculate fnat fnat = ascraster.duplicategrid(a_nat) fnat.divide(a_tot, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnat.asc") fnat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnat, "fnat =") ### --------- 2. INPUTS FERTILIZER, MANURE, FIXATION --------- ### # read input files N inputs n_fert_ag = ascraster.Asciigrid(ascii_file=params.filename_fert_inp, numtype=float, mask=params.mask) n_fert_ara = ascraster.Asciigrid( ascii_file=params.filename_fert_inp_cropland, numtype=float, mask=params.mask) n_fert_igl = ascraster.Asciigrid( ascii_file=params.filename_fert_inp_grassland, numtype=float, mask=params.mask) n_man_ag = ascraster.Asciigrid(ascii_file=params.filename_manure_inp, numtype=float, mask=params.mask) n_man_ara = ascraster.Asciigrid( ascii_file=params.filename_manure_inp_cropland, numtype=float, mask=params.mask) n_man_igl = ascraster.Asciigrid( ascii_file=params.filename_manure_inp_intgl, numtype=float, mask=params.mask) n_man_egl = ascraster.Asciigrid( ascii_file=params.filename_manure_inp_extgl, numtype=float, mask=params.mask) n_fix_ag = ascraster.Asciigrid(ascii_file=params.filename_nfixation_agri, numtype=float, mask=params.mask) n_fix_ara = ascraster.Asciigrid( ascii_file=params.filename_nfixation_cropland, numtype=float, mask=params.mask) n_fix_igl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_intgl, numtype=float, mask=params.mask) n_fix_egl = ascraster.Asciigrid(ascii_file=params.filename_nfixation_extgl, numtype=float, mask=params.mask) nh3_stor = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_storage, numtype=float, mask=params.mask) #$#V1.4#$# #''' # split nh3 emissions from storage over intensive and extensive grassland #$#V1.4#$# # intensive grassland #$#V1.3#$# nh3_stor_igl = ascraster.duplicategrid(nh3_stor) #$#V1.3#$# for icell in range(nh3_stor_igl.length): #$#V1.3#$# igl = a_igl.get_data(icell) #$#V1.3#$# nh3stor = nh3_stor.get_data(icell) #$#V1.3#$# if (igl == None or igl == 0): #$#V1.3#$# nh3emigl = 0 #$#V1.3#$# elif (igl > 0): #$#V1.3#$# nh3emigl = nh3stor #$#V1.3#$# else: #$#V1.3#$# continue #$#V1.3#$# nh3_stor_igl.set_data(icell, nh3emigl) #$#V1.3#$# fileout = os.path.join(params.outputdir, "nh3_stor_igl.asc") #$#V1.3#$# nh3_stor_igl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) #$#V1.3#$# print_debug(nh3_stor_igl, "nh3_stor_igl =") #$#V1.3#$# # extensive grassland #$#V1.3#$# nh3_stor_egl = ascraster.duplicategrid(nh3_stor) #$#V1.3#$# for icell in range(nh3_stor_egl.length): #$#V1.3#$# egl = a_egl.get_data(icell) #$#V1.3#$# nh3stor = nh3_stor.get_data(icell) #$#V1.3#$# if (egl == None or egl == 0): #$#V1.3#$# nh3emegl = 0 #$#V1.3#$# elif (egl > 0): #$#V1.3#$# nh3emegl = nh3stor #$#V1.3#$# else: #$#V1.3#$# continue #$#V1.3#$# nh3_stor_egl.set_data(icell, nh3emegl) #$#V1.3#$# fileout = os.path.join(params.outputdir, "nh3_stor_egl.asc") #$#V1.3#$# nh3_stor_egl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) #$#V1.3#$# print_debug(nh3_stor_egl, "nh3_stor_egl =") #$#V1.3#$# # arable land #$#V1.3#$# nh3_stor_ara = ascraster.duplicategrid(nh3_stor) #$#V1.3#$# for icell in range(nh3_stor_ara.length): #$#V1.3#$# ara = a_ara.get_data(icell) #$#V1.3#$# igl = a_igl.get_data(icell) #$#V1.3#$# egl = a_egl.get_data(icell) #$#V1.3#$# nh3stor = nh3_stor.get_data(icell) #$#V1.3#$# if (ara == None): #$#V1.3#$# nh3emara = 0 #$#V1.3#$# elif (egl == 0 and igl == 0): #$#V1.3#$# nh3emara = nh3stor #$#V1.3#$# elif (egl > 0 or igl > 0): #$#V1.3#$# nh3emara = 0 #$#V1.3#$# nh3emara = 0 #$#V1.3#$# else: #$#V1.3#$# continue #$#V1.3#$# nh3_stor_ara.set_data(icell, nh3emara) #$#V1.3#$# fileout = os.path.join(params.outputdir, "nh3_stor_ara.asc") #$#V1.3#$# nh3_stor_ara.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) #$#V1.3#$# print_debug(nh3_stor_ara, "nh3_stor_ara =") #$#V1.3#$# #''' # Calculate N inputs to 'agri' - fertilizer n_fert_agri_eff = ascraster.duplicategrid(n_fert_ara) n_fert_agri_eff.add(n_fert_igl) print_debug(n_fert_agri_eff, "n_fert_agri_eff =") # Calculate N inputs to 'agri' - manure n_man_agri_eff = ascraster.duplicategrid(n_man_ara) n_man_agri_eff.add(n_man_igl) print_debug(n_man_agri_eff, "n_man_agri_eff =") #''' #$# Add NH3 emissions to input from FERTILIZER #$#V1.2#$# # ag #$#V1.2#$# nh3_spread_fert = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert, numtype=float, mask=params.mask) #$#V1.2#$# n_fert_ag_nh3 = ascraster.duplicategrid(n_fert_ag) #$#V1.2#$# n_fert_ag_nh3.add(nh3_spread_fert) #$#V1.2#$# print_debug(n_fert_ag_nh3, "n_fert_ag_nh3 =") #$#V1.2#$# # replace original calculations of n_fert_ag #$#V1.2#$# n_fert_ag = ascraster.duplicategrid(n_fert_ag_nh3) #$#V1.2#$# # agri #$#V1.2#$# nh3_spread_fert_ara = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert_cropland, numtype=float, mask=params.mask) #$#V1.2#$# nh3_spread_fert_igl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert_intgl, numtype=float, mask=params.mask) #$#V1.2#$# n_fert_agri_nh3 = ascraster.duplicategrid(n_fert_agri_eff) #$#V1.2#$# n_fert_agri_nh3.add(nh3_spread_fert_ara) #$#V1.2#$# n_fert_agri_nh3.add(nh3_spread_fert_igl) #$#V1.2#$# print_debug(n_fert_agri_nh3, "n_fert_agri_nh3 =") #$#V1.2#$# # replace original calculations of n_fert_agri #$#V1.2#$# n_fert_agri = ascraster.duplicategrid(n_fert_agri_nh3) #$#V1.2#$# fileout = os.path.join(params.outputdir, "n_fert_agri.asc") n_fert_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_fert_agri, "n_fert_agri =") #$# Add NH3 emissions to input from MANURE #$#V1.2#$# # ag #$#V1.2#$# nh3_spread_man = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure, numtype=float, mask=params.mask) #$#V1.2#$# nh3_stor = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_storage, numtype=float, mask=params.mask) #$#V1.2#$# nh3_graz = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_grazing, numtype=float, mask=params.mask) #$#V1.2#$# n_man_ag_nh3 = ascraster.duplicategrid(n_man_ag) #$#V1.2#$# n_man_ag_nh3.add(nh3_spread_man) #$#V1.2#$# n_man_ag_nh3.add(nh3_stor) #$#V1.2#$# n_man_ag_nh3.add(nh3_graz) #$#V1.2#$# print_debug(n_man_ag_nh3, "n_man_ag_nh3 =") #$#V1.2#$# # replace original calculations of n_man_ag #$#V1.2#$# n_man_ag = ascraster.duplicategrid(n_man_ag_nh3) #$#V1.2#$# # agri #$#V1.2#$# nh3_spread_man_ara = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure_cropland, numtype=float, mask=params.mask) #$#V1.2#$# nh3_spread_man_igl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure_intgl, numtype=float, mask=params.mask) #$#V1.2#$# nh3_graz_igl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_grazing_int, numtype=float, mask=params.mask) #$#V1.2#$# n_man_agri_nh3 = ascraster.duplicategrid(n_man_agri_eff) #$#V1.2#$# n_man_agri_nh3.add(nh3_spread_man_ara) #$#V1.2#$# n_man_agri_nh3.add(nh3_spread_man_igl) #$#V1.2#$# #n_man_agri_nh3.add(nh3_stor) #$#V1.2#$# n_man_agri_nh3.add(nh3_stor_ara) #$#V1.4#$# n_man_agri_nh3.add(nh3_stor_igl) #$#V1.4#$# n_man_agri_nh3.add(nh3_graz_igl) #$#V1.2#$# print_debug(n_man_agri_nh3, "n_man_agri_nh3 =") #$#V1.2#$# # replace original calculations of n_man_agri #$#V1.2#$# n_man_agri = ascraster.duplicategrid(n_man_agri_nh3) #$#V1.2#$# fileout = os.path.join(params.outputdir, "n_man_agri.asc") n_man_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_man_agri, "n_man_agri =") # 'egl' nh3_graz_egl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_grazing_ext, numtype=float, mask=params.mask) #$#V1.2#$# nh3_spread_man_egl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure_extgl, numtype=float, mask=params.mask) n_man_egl_nh3 = ascraster.duplicategrid(n_man_egl) n_man_egl_nh3.add(nh3_spread_man_egl) n_man_egl_nh3.add(nh3_stor_egl) n_man_egl_nh3.add(nh3_graz_egl) # replace original calculations of n_man_egl #$#V1.2#$# n_man_egl = ascraster.duplicategrid(n_man_egl_nh3) #$#V1.2#$# fileout = os.path.join(params.outputdir, "nman_egl.asc") n_man_egl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_man_egl, "n_man_egl =") #''' # Calculate N inputs to 'agri' - N fixation n_fix_agri = ascraster.duplicategrid(n_fix_ara) n_fix_agri.add(n_fix_igl) fileout = os.path.join(params.outputdir, "n_fix_agri.asc") n_fix_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_fix_agri, "n_fix_agri =") # calculate frNfe_ag fert_man_ag = ascraster.duplicategrid(n_man_ag) fert_man_ag.add(n_fert_ag) frnfe_ag = griddivide(n_fert_ag, fert_man_ag, default_nodata_value=0) # replace '0' by 0.0001 in frNfe_ag for icell in range(frnfe_ag.length): val = frnfe_ag.get_data(icell) if (val == None or val > 0): continue if val == 0.0: res = 0.0001 frnfe_ag.set_data(icell, res) # replace '1' by 0.9999 in frNfe_ag for icell in range(frnfe_ag.length): val = frnfe_ag.get_data(icell) if (val == None or val < 1): continue if val == 1.0: res = 0.9999 frnfe_ag.set_data(icell, res) print_debug(frnfe_ag, "frNfe_ag =") #fileout = os.path.join(params.outputdir,"frnfe_ag.asc") #frnfe_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) ####CHECK: INDEED OK TO GET NA VALUES FOR DIV ZERO WITH frNfe? # calculate frNfe_agri fert_man_agri = ascraster.duplicategrid(n_fert_agri) fert_man_agri.add(n_man_agri) #fileout = os.path.join(params.outputdir,"fert_man_agri.asc") #fert_man_agri.write_ascii_file(fileout, output_nodata_value=-9999,compress=params.lcompress) frnfe_agri = ascraster.duplicategrid(n_fert_agri) frnfe_agri.divide(fert_man_agri) #frnfe_agri = griddivide(n_fert_agri,fert_man_agri,default_nodata_value = 0) # replace '0' by 0.0001 in frNfe_agri for icell in range(frnfe_agri.length): val = frnfe_agri.get_data(icell) if (val == None or val > 0): continue if val == 0.0: res = 0.0001 frnfe_agri.set_data(icell, res) # replace '1' by 0.9999 in frnfe_agri for icell in range(frnfe_agri.length): val = frnfe_agri.get_data(icell) if (val == None or val < 1): continue if val == 1.0: res = 0.9999 frnfe_agri.set_data(icell, res) print_debug(frnfe_agri, "frnfe_agri =") fileout = os.path.join(params.outputdir, "frnfe_agri.asc") frnfe_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ### --------- 3. NH3 EMISSIONS & EMISSION FRACTIONS --------- ### # read input files NH3 emissions nh3_spread_man = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure, numtype=float, mask=params.mask) nh3_spread_man_ara = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure_cropland, numtype=float, mask=params.mask) nh3_spread_man_igl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure_intgl, numtype=float, mask=params.mask) nh3_spread_man_egl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_manure_extgl, numtype=float, mask=params.mask) nh3_stor = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_storage, numtype=float, mask=params.mask) nh3_graz = ascraster.Asciigrid(ascii_file=params.filename_nh3_em_grazing, numtype=float, mask=params.mask) nh3_graz_igl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_grazing_int, numtype=float, mask=params.mask) nh3_graz_egl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_grazing_ext, numtype=float, mask=params.mask) nh3_spread_fert = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert, numtype=float, mask=params.mask) nh3_spread_fert_ara = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert_cropland, numtype=float, mask=params.mask) nh3_spread_fert_igl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert_intgl, numtype=float, mask=params.mask) nh3_spread_fert_egl = ascraster.Asciigrid( ascii_file=params.filename_nh3_em_spread_fert_extgl, numtype=float, mask=params.mask) # calculate total NH3 emission (all agriculture) nh3_tot = ascraster.duplicategrid(nh3_spread_man) nh3_tot.add(nh3_stor) nh3_tot.add(nh3_graz) nh3_tot.add(nh3_spread_fert) print_debug(nh3_tot, "nh3_tot =") # calculate total NH3 emission (ara + igl) nh3_spread_fert_agri = ascraster.duplicategrid(nh3_spread_fert_ara) nh3_spread_fert_agri.add(nh3_spread_fert_igl) nh3_tot_agri = ascraster.duplicategrid(nh3_spread_fert_agri) nh3_tot_agri.add(nh3_spread_man_ara) nh3_tot_agri.add(nh3_spread_man_igl) nh3_tot_agri.add(nh3_stor_igl) #$#V1.3#$# nh3_tot_agri.add(nh3_stor_ara) #$#V1.3#$# #nh3_tot_agri.add(nh3_stor) #$#V1.1#$# nh3_tot_agri.add(nh3_graz_igl) fileout = os.path.join(params.outputdir, "nh3_tot_agri.asc") nh3_tot_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nh3_tot_agri, "nh3_tot_agri =") # calculate total NH3 emission (egl) nh3_tot_egl = ascraster.duplicategrid(nh3_spread_man_egl) nh3_tot_egl.add(nh3_graz_egl) nh3_tot_egl.add(nh3_spread_fert_egl) nh3_tot_egl.add(nh3_stor_egl) #$#V1.3#$# fileout = os.path.join(params.outputdir, "nh3_tot_egl.asc") nh3_tot_egl.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nh3_tot_egl, "nh3_tot_egl =") # calculate fnh3em,man,ag nh3_man_tot = ascraster.duplicategrid(nh3_tot) nh3_man_tot.substract(nh3_spread_fert) nh3_ef_man = griddivide(nh3_man_tot, n_man_ag, default_nodata_value=0) #fileout = os.path.join(params.outputdir,"nh3_ef_man.asc") #nh3_ef_man.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_man, "nh3_ef_man =") # calculate fnh3em,man,agri nh3_man_tot_agri = ascraster.duplicategrid(nh3_tot_agri) nh3_man_tot_agri.substract(nh3_spread_fert_agri) nh3_ef_man_agri = griddivide(nh3_man_tot_agri, n_man_agri, default_nodata_value=0) fileout = os.path.join(params.outputdir, "nh3_ef_man_agri.asc") nh3_ef_man_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nh3_ef_man_agri, "nh3_ef_man_agri =") # calculate fnh3em,fert nh3_ef_fert = griddivide(nh3_spread_fert, n_fert_ag, default_nodata_value=0) #fileout = os.path.join(params.outputdir,"nh3_ef_fert.asc") #nh3_ef_fert.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nh3_ef_fert, "nh3_ef_fert =") # calculate fnh3em,fert,agri nh3_ef_fert_agri = griddivide(nh3_spread_fert_agri, n_fert_agri, default_nodata_value=0) fileout = os.path.join(params.outputdir, "nh3_ef_fert_agri.asc") nh3_ef_fert_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nh3_ef_fert_agri, "nh3_ef_fert_agri =") ### --------- 4. N DEPOSITION & NOx emission --------- ### # calculate corrected N deposition grid - for all cells where Ndep < NH3em, replace Ndep by NH3em ndep_tot = ascraster.Asciigrid(ascii_file=params.filename_n_deposition, numtype=float, mask=params.mask) ndep_corr_tot = ascraster.duplicategrid(ndep_tot) for icell in range(nh3_tot.length): # Get values from both grids. nh3 = nh3_tot.get_data(icell) dep = ndep_tot.get_data(icell) # If both grids have nodata, keep nodata. if (nh3 == None or dep == None or dep >= nh3): continue if dep < nh3: depcorr = nh3 ndep_corr_tot.set_data(icell, depcorr) fileout = os.path.join(params.outputdir, "ndep_corr_tot.asc") ndep_corr_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(ndep_tot, "ndep_tot =") print_debug(ndep_corr_tot, "ndep_corr_tot =") # calculate NOx emissions: NOx = *corrected* Ndep - (NH3,spread,fe+NH3,spread,man+NH3stor+NH3,graz) nox_em = ascraster.duplicategrid(ndep_corr_tot) nox_em.substract(nh3_tot) #factor = 0 #nox_em.multiply(factor) fileout = os.path.join(params.outputdir, "nox_em.asc") nox_em.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nox_em, "nox_em =") # calculate ndep_ag ndep_ag = ascraster.duplicategrid(ndep_corr_tot) ndep_ag.multiply(f*g) #fileout = os.path.join(params.outputdir,"ndep_ag.asc") #ndep_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_ag, "ndep_ag =") # calculate ndep_ara ndep_ara = ascraster.duplicategrid(ndep_corr_tot) ndep_ara.multiply(fara) #fileout = os.path.join(params.outputdir,"ndep_ara.asc") #ndep_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_ara, "ndep_ara =") # calculate ndep_igl ndep_igl = ascraster.duplicategrid(ndep_corr_tot) ndep_igl.multiply(figl) #fileout = os.path.join(params.outputdir,"ndep_igl.asc") #ndep_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_igl, "ndep_igl =") # calculate ndep_agri ndep_agri = ascraster.duplicategrid(ndep_corr_tot) ndep_agri.multiply(fagri) #fileout = os.path.join(params.outputdir,"ndep_agri.asc") #ndep_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_agri, "ndep_agri =") # calculate ndep_egl ndep_egl = ascraster.duplicategrid(ndep_corr_tot) ndep_egl.multiply(fegl) #fileout = os.path.join(params.outputdir,"ndep_egl.asc") #ndep_egl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_egl, "ndep_egl =") ### --------- 5. TOTAL INPUTS --------- ### # calculate n_in_ag n_in_ag = ascraster.duplicategrid(n_fert_ag) n_in_ag.add(n_man_ag) n_in_ag.add(n_fix_ag) n_in_ag.add(ndep_ag) #fileout = os.path.join(params.outputdir,"n_in_ag.asc") #n_in_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(n_in_ag, "n_in_ag =") # calculate n_in_ara n_in_ara = ascraster.duplicategrid(n_fert_ara) n_in_ara.add(n_man_ara) n_in_ara.add(n_fix_ara) n_in_ara.add(ndep_ara) #fileout = os.path.join(params.outputdir,"n_in_ara.asc") #n_in_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(n_in_ara, "n_in_ara =") # calculate n_in_igl n_in_igl = ascraster.duplicategrid(n_fert_igl) n_in_igl.add(n_man_igl) n_in_igl.add(n_fix_igl) n_in_igl.add(ndep_igl) #fileout = os.path.join(params.outputdir,"n_in_igl.asc") #n_in_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(n_in_igl, "n_in_igl =") # calculate n_in_agri n_in_agri = ascraster.duplicategrid(n_fert_agri) n_in_agri.add(n_man_agri) n_in_agri.add(n_fix_agri) n_in_agri.add(ndep_agri) fileout = os.path.join(params.outputdir, "n_in_agri.asc") n_in_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_in_agri, "n_in_agri =") # calculate n_in_egl n_in_egl = ascraster.duplicategrid(n_man_egl) n_in_egl.add(n_fix_egl) n_in_egl.add(ndep_egl) #fileout = os.path.join(params.outputdir,"n_in_egl.asc") #n_in_egl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(n_in_egl, "n_in_egl =") ### --------- 6. SURFACE RUNOFF, UPTAKE, FRNUP, NUE --------- ### # read input files uptake, surface runoff nsro_ag = ascraster.Asciigrid(ascii_file=params.filename_nsro_ag, numtype=float, mask=params.mask) n_up_ara = ascraster.Asciigrid(ascii_file=params.filename_uptake_cropland, numtype=float, mask=params.mask) n_up_igl = ascraster.Asciigrid(ascii_file=params.filename_uptake_intgl, numtype=float, mask=params.mask) n_up_egl = ascraster.Asciigrid(ascii_file=params.filename_uptake_extgl, numtype=float, mask=params.mask) regions = ascraster.Asciigrid(ascii_file=params.filename_regions, numtype=float, mask=params.mask) #$# To manipulate results for 1999 so that I can also get uptake per land-use type (assuming equal NUE) #$#n_up_ag = ascraster.Asciigrid(ascii_file=params.filename_uptake_agriculture, numtype=float,mask=params.mask) #$# #$#nue_ag = ascraster.duplicategrid(n_up_ag) #$#nue_ag.divide(n_in_ag, default_nodata_value = -9999) #$#n_up_ara = ascraster.duplicategrid(n_in_ara) #$#n_up_ara.multiply(nue_ag) #$#fileout = os.path.join(params.inputdir,"n_up_crops.asc") #$#n_up_ara.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) #$#n_up_igl = ascraster.duplicategrid(n_in_igl) #$#n_up_igl.multiply(nue_ag) #$#fileout = os.path.join(params.inputdir,"n_up_grass_int.asc") #$#n_up_igl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) #$#n_up_egl = ascraster.duplicategrid(n_in_egl) #$#n_up_egl.multiply(nue_ag) #$#fileout = os.path.join(params.inputdir,"n_up_grass_ext.asc") #$#n_up_egl.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) # calculate uptake,agri n_up_agri = ascraster.duplicategrid(n_up_ara) n_up_agri.add(n_up_igl) #fileout = os.path.join(params.outputdir,"n_up_agri.asc") #n_up_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(n_up_agri, "n_up_agri =") # calculate uptake,ag n_up_ag = ascraster.duplicategrid(n_up_ara) n_up_ag.add(n_up_igl) n_up_ag.add(n_up_egl) #fileout = os.path.join(params.outputdir,"n_up_ag.asc") #n_up_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(n_up_ag, "n_up_ag =") # calculate runoff fraction fsro,ag fsro_ag = griddivide(nsro_ag, n_in_ag, default_nodata_value=0) fileout = os.path.join(params.outputdir, "fsro_ag.asc") fsro_ag.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fsro_ag, "fsro_ag =") # calculate nsro,agri nsro_agri = ascraster.duplicategrid(fsro_ag) nsro_agri.multiply(n_in_agri) #fileout = os.path.join(params.outputdir,"nsro_agri.asc") #nsro_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nsro_agri, "nsro_agri =") # calculate frnup_agri n_in_min_nsro_agri = ascraster.duplicategrid(n_in_agri) n_in_min_nsro_agri.substract(nsro_agri) frnup_agri = griddivide(n_up_agri, n_in_min_nsro_agri, default_nodata_value=0) fileout = os.path.join(params.outputdir, "frnup_agri.asc") frnup_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(frnup_agri, "frnup_agri =") # calculate nue_agri nue_agri = ascraster.duplicategrid(n_up_agri) nue_agri.divide(n_in_agri, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "nue_agri.asc") nue_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_agri, "nue_agri =") # maximum N uptake # make grid with yield increase per region yieldgap_region = ascraster.duplicategrid(n_up_ara) for i in range(yieldgap_region.length): yieldgap_region.set_data(i, -9999) for icell in range(regions.length): val = regions.get_data(icell) # Canada (1) if val == 1: yg = 1.274 # USA (2) elif val == 2: yg = 1.252 # Mexico (3) elif val == 3: yg = 1.566 # Central America (4) elif val == 4: yg = 1.797 # Brazil (5) elif val == 5: yg = 1.343 # Rest of South America (6) elif val == 6: yg = 1.532 # Northern Africa (7) elif val == 7: yg = 2.711 # Western Africa (8) elif val == 8: yg = 2.363 # Eastern Africa (9) elif val == 9: yg = 2.424 # South Africa (10) elif val == 10: yg = 1.848 # Western Europe (11) elif val == 11: yg = 1.177 # Central Europe (12) elif val == 12: yg = 1.982 # Turkey (13) elif val == 13: yg = 1.797 # Ukraine region (14) elif val == 14: yg = 2.633 # Central Asia (15) elif val == 15: yg = 2.928 # Russia region(16) elif val == 16: yg = 2.391 # Middle East (17) elif val == 17: yg = 2.170 # India (18) elif val == 18: yg = 1.508 # Korea region (19) elif val == 19: yg = 1.180 # China region (20) elif val == 20: yg = 1.503 # Southeastern Asia (21) elif val == 21: yg = 1.479 # Indonesia region (22) elif val == 22: yg = 1.267 # Japan (23) elif val == 23: yg = 1.180 # Oceania (24) elif val == 24: yg = 1.487 # Rest of South Asia (25) elif val == 25: yg = 1.870 # Rest of Southern Africa (26) elif val == 26: yg = 2.551 # Greenland (27) elif val == 27: yg = 1.000 # Region can also have value none (-9999) else: continue yieldgap_region.set_data(icell, yg) print_debug(regions, "The region number is") fileout = os.path.join(params.outputdir, "yieldgap_region.asc") yieldgap_region.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(yieldgap_region, "The yieldgap for this region is") # calculate Nup(max) = Nup(agri) * yieldgap_region n_up_max = ascraster.duplicategrid(n_up_agri) n_up_max.multiply(yieldgap_region) fileout = os.path.join(params.outputdir, "n_up_max.asc") n_up_max.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_up_max, "The maximum N uptake is") # calculate corrected NUE (NUE used to calculate Nin at Nup,max should never be higher than 0.8) nue_corr_agri = ascraster.duplicategrid(nue_agri) for icell in range(nue_corr_agri.length): val = nue_corr_agri.get_data(icell) if (val == None or val <= 0.8): continue if val > 0.8: res = 0.8 nue_corr_agri.set_data(icell, res) fileout = os.path.join(params.outputdir, "nue_corr_agri.asc") nue_corr_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nue_corr_agri, "The corrected NUE (max=0.8) is") # calculate n_in_max (total N inputs from all sources that correspond to maximum uptake and a max. NUE of 0.8) n_in_max = ascraster.duplicategrid(n_up_max) n_in_max.divide(nue_corr_agri, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "n_in_max.asc") n_in_max.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(n_in_max, "The maximum N input is") ### --------- 7. BUDGET, LEACHING, DENITRIFICATION --------- ### # read input files ngw_ag = ascraster.Asciigrid(ascii_file=params.filename_groundwaterload_ag, numtype=float, mask=params.mask) fgw_rec_ag = ascraster.Asciigrid( ascii_file=params.filename_fraction_recent_groundwaterload_ag, numtype=float, mask=params.mask) nle_ag = ascraster.Asciigrid(ascii_file=params.filename_leaching_ag, numtype=float, mask=params.mask) # calculate N budget agriculture: Nbud,ag = Nin,ag - Nup,ag nbud_ag = ascraster.duplicategrid(n_in_ag) nbud_ag.substract(n_up_ag) fileout = os.path.join(params.outputdir, "nbud_ag.asc") nbud_ag.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nbud_ag, "nbud_ag =") # calculate N load to surface water via groundwater due to *recent* N inputs: agriculture ngw_rec_ag = ascraster.duplicategrid(ngw_ag) ngw_rec_ag.multiply(fgw_rec_ag) #fileout = os.path.join(params.outputdir,"ngw_rec_ag.asc") #ngw_rec_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ngw_rec_ag, "ngw_rec_ag =") # calculate Denitrification in soil: Nde,ag = Nbud,ag - Nsro,ag - Nle,ag nde_ag = ascraster.duplicategrid(nbud_ag) nde_ag.substract(nsro_ag) nde_ag.substract(nle_ag) fileout = os.path.join(params.outputdir, "nde_ag.asc") nde_ag.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nde_ag, "nde_ag =") # calculate leaching fraction fle,ag nbud_min_nsro_ag = ascraster.duplicategrid(nbud_ag) nbud_min_nsro_ag.substract(nsro_ag) fle_ag = griddivide(nle_ag, nbud_min_nsro_ag, default_nodata_value=0) fileout = os.path.join(params.outputdir, "fle_ag.asc") fle_ag.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fle_ag, "fle_ag =") # calculate fraction of N leaching that is delivered to surface water via groundwater in first x years fgw_rec_le_ag = griddivide(ngw_rec_ag, nle_ag, default_nodata_value=0) fileout = os.path.join(params.outputdir, "fgw_rec_le_ag.asc") fgw_rec_le_ag.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fgw_rec_le_ag, "fgw_rec_le_ag =") # calculate ndep_nat ndep_nat = ascraster.duplicategrid(ndep_corr_tot) ndep_nat.multiply(fnat) #fileout = os.path.join(params.outputdir,"ndep_nat.asc") #ndep_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ndep_nat, "ndep_nat =") # calculate N budget nature: Nbud,nat = Ndep,nat + Nfix,nat n_fix_nat = ascraster.Asciigrid(ascii_file=params.filename_nfixation_nat, numtype=float, mask=params.mask) nbud_nat = ascraster.duplicategrid(ndep_nat) nbud_nat.add(n_fix_nat) fileout = os.path.join(params.outputdir, "nbud_nat.asc") nbud_nat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nbud_nat, "nbud_nat =") # calculate N load to surface water via groundwater due to *recent* N inputs: natural areas ngw_nat = ascraster.Asciigrid( ascii_file=params.filename_groundwaterload_nat, numtype=float, mask=params.mask) fgw_rec_nat = ascraster.Asciigrid( ascii_file=params.filename_fraction_recent_groundwaterload_nat, numtype=float, mask=params.mask) ngw_rec_nat = ascraster.duplicategrid(ngw_nat) ngw_rec_nat.multiply(fgw_rec_nat) #fileout = os.path.join(params.outputdir,"ngw_rec_nat.asc") #ngw_rec_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(ngw_rec_nat, "ngw_rec_nat =") # calculate Denitrification in soil: Nde,nat = Nbud,nat - Nsro,nat - Nle,nat nsro_nat = ascraster.Asciigrid(ascii_file=params.filename_nsro_nat, numtype=float, mask=params.mask) nle_nat = ascraster.Asciigrid(ascii_file=params.filename_leaching_nat, numtype=float, mask=params.mask) nde_nat = ascraster.duplicategrid(nbud_nat) nde_nat.substract(nsro_nat) nde_nat.substract(nle_nat) fileout = os.path.join(params.outputdir, "nde_nat.asc") nde_nat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nde_nat, "nde_nat =") # calculate leaching fraction fle,nat nbud_min_nsro_nat = ascraster.duplicategrid(nbud_nat) nbud_min_nsro_nat.substract(nsro_nat) fle_nat = griddivide(nle_nat, nbud_min_nsro_nat, default_nodata_value=0) fileout = os.path.join(params.outputdir, "fle_nat.asc") fle_nat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fle_nat, "fle_nat =") # calculate runoff fraction fsro,nat fsro_nat = griddivide(nsro_nat, nbud_nat, default_nodata_value=0) fileout = os.path.join(params.outputdir, "fsro_nat.asc") fsro_nat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fsro_nat, "fsro_nat =") # calculate fraction of N leaching that is delivered to surface water via groundwater in first x years - natural areas fgw_rec_le_nat = griddivide(ngw_rec_nat, nle_nat, default_nodata_value=0) fileout = os.path.join(params.outputdir, "fgw_rec_le_nat.asc") fgw_rec_le_nat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fgw_rec_le_nat, "fgw_rec_le_nat =") # calculate variable load to surface water from agriculture: Nload,var,ag = Nsro,ag + Ngw,rec,ag nload_var_ag = ascraster.duplicategrid(ngw_rec_ag) nload_var_ag.add(nsro_ag) #fileout = os.path.join(params.outputdir,"nload_var_ag.asc") #nload_var_ag.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_var_ag, "nload_var_ag =") # calculate variable load to surface water from nature: Nload,var,nat = Nsro,nat + Ngw,rec,nat nload_var_nat = ascraster.duplicategrid(ngw_rec_nat) nload_var_nat.add(nsro_nat) #fileout = os.path.join(params.outputdir,"nload_var_nat.asc") #nload_var_nat.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_var_nat, "nload_var_nat =") # calculate fixed load to surface water from agriculture: Ngw,fixed,ag = Ngw,ag * (1-fgw,rec,ag) grid1 = ascraster.duplicategrid(fgw_rec_ag) for i in range(grid1.length): grid1.set_data(i, 1.0) grid1.substract(fgw_rec_ag) nload_fixed_ag = ascraster.duplicategrid(ngw_ag) nload_fixed_ag.multiply(grid1) fileout = os.path.join(params.outputdir, "nload_fixed_ag.asc") nload_fixed_ag.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nload_fixed_ag, "nload_fixed_ag =") # calculate fixed load to surface water from nature: Ngw,fixed,nat = Ngw,nat * (1-fgw,rec,nat) grid2 = ascraster.duplicategrid(fgw_rec_nat) for i in range(grid2.length): grid2.set_data(i, 1.0) grid2.substract(fgw_rec_nat) nload_fixed_nat = ascraster.duplicategrid(ngw_nat) nload_fixed_nat.multiply(grid2) fileout = os.path.join(params.outputdir, "nload_fixed_nat.asc") nload_fixed_nat.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nload_fixed_nat, "nload_fixed_nat =") # calculate total load from point sources nallo = ascraster.Asciigrid( ascii_file=params.filename_n_point_alloch_matter, numtype=float, mask=params.mask) nww = ascraster.Asciigrid(ascii_file=params.filename_n_point_wastewater, numtype=float, mask=params.mask) naqua = ascraster.Asciigrid(ascii_file=params.filename_n_point_aquaculture, numtype=float, mask=params.mask) ndep_sw = ascraster.Asciigrid( ascii_file=params.filename_n_point_dep_surfacewater, numtype=float, mask=params.mask) #factor = 0 #nww.multiply(factor) #naqua.multiply(factor) npoint_tot = ascraster.duplicategrid(nallo) npoint_tot.add(nww) npoint_tot.add(naqua) npoint_tot.add(ndep_sw) fileout = os.path.join(params.outputdir, "npoint_tot.asc") npoint_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(npoint_tot, "npoint_tot =") # calculate total load from erosion nero_ag = ascraster.Asciigrid(ascii_file=params.filename_n_in_erosion_ag, numtype=float, mask=params.mask) nero_nat = ascraster.Asciigrid(ascii_file=params.filename_n_in_erosion_nat, numtype=float, mask=params.mask) nero_tot = ascraster.duplicategrid(nero_ag) nero_tot.add(nero_nat) fileout = os.path.join(params.outputdir, "nero_tot.asc") nero_tot.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nero_tot, "nero_tot =") # calculate total n load to surface water: Nload,tot = Nload,var,ag + Nload,var,nat + Ngw,fixed,ag + Ngw,fixed,nat + Npoint + Nero nload_tot = ascraster.duplicategrid(nload_var_ag) nload_tot.add(nload_var_nat) nload_tot.add(nload_fixed_ag) nload_tot.add(nload_fixed_nat) nload_tot.add(npoint_tot) nload_tot.add(nero_tot) #fileout = os.path.join(params.outputdir,"nload_tot.asc") #nload_tot.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_tot, "nload_tot =")
def calculate(params): print("The critical N conc in gw is", params.crit_gw) # load needed variables for calculations q = ascraster.Asciigrid(ascii_file=os.path.join(params.inputdir, "q.asc") ,numtype=float,mask=params.mask) fsro_ag = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"fsro_ag.asc") ,numtype=float,mask=params.mask) fagri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"fagri.asc") ,numtype=float,mask=params.mask) fle_ag = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"fle_ag.asc") ,numtype=float,mask=params.mask) frnup_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"frnup_agri.asc") ,numtype=float,mask=params.mask) n_fix_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"n_fix_agri.asc") ,numtype=float,mask=params.mask) n_up_max = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"n_up_max.asc") ,numtype=float,mask=params.mask) nox_em = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nox_em.asc") ,numtype=float,mask=params.mask) nh3_tot_egl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nh3_tot_egl.asc") ,numtype=float,mask=params.mask) nh3_ef_man_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nh3_ef_man_agri.asc") ,numtype=float,mask=params.mask) nh3_ef_fert_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"nh3_ef_fert_agri.asc"),numtype=float,mask=params.mask) frnfe_agri = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"frnfe_agri.asc") ,numtype=float,mask=params.mask) n_in_max = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir,"n_in_max.asc") ,numtype=float,mask=params.mask) # calculate nle,ag,crit(gw) Nle,ag(crit)=(1-fsro)*Q*fag_crit*Nconc,le,ag(crit) one_grid = ascraster.duplicategrid(q) for i in range(one_grid.length): one_grid.set_data(i,1.0) one_min_fsro = ascraster.duplicategrid(one_grid) one_min_fsro.substract(fsro_ag) nle_crit_gw_agri = ascraster.duplicategrid(one_min_fsro) nle_crit_gw_agri.multiply(q) nle_crit_gw_agri.multiply(fagri) nle_crit_gw_agri.multiply(params.crit_gw) #fileout = os.path.join(params.outputdir,"nle_crit_gw_agri.asc") #nle_crit_gw_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nle_crit_gw_agri,"The critical leaching is") # calculate critical N input from manure v_part1 = ascraster.duplicategrid(one_grid) v_part1.substract(frnup_agri) v_part2 = ascraster.duplicategrid(fsro_ag) v_part2.multiply(frnup_agri) v = ascraster.duplicategrid(v_part1) v.add(v_part2) v.substract(fsro_ag) v.multiply(fle_ag) num1 = ascraster.duplicategrid(nle_crit_gw_agri) num1.divide(v, default_nodata_value = -9999) num2 = ascraster.duplicategrid(nox_em) num2.multiply(fagri) num3 = ascraster.duplicategrid(nh3_tot_egl) num3.multiply(fagri) num = ascraster.duplicategrid(num1) num.substract(n_fix_agri) num.substract(num2) num.substract(num3) dem1 = ascraster.duplicategrid(fagri) dem1.multiply(nh3_ef_man_agri) dem2 = ascraster.duplicategrid(fagri) dem2.multiply(nh3_ef_fert_agri) dem2.add(one_grid) one_min_frnfe = ascraster.duplicategrid(one_grid) one_min_frnfe.substract(frnfe_agri) frnfe_division = ascraster.duplicategrid(frnfe_agri) frnfe_division.divide(one_min_frnfe, default_nodata_value = -9999) dem2.multiply(frnfe_division) dem = ascraster.duplicategrid(one_grid) dem.add(dem1) dem.add(dem2) nman_crit_gw = ascraster.duplicategrid(num) nman_crit_gw.divide(dem, default_nodata_value = -9999) for icell in range (nman_crit_gw.length): nman = nman_crit_gw.get_data(icell) if (nman is None): continue if (nman < 0): man = 0 else: continue nman_crit_gw.set_data(icell,man) fileout = os.path.join(params.outputdir,"nman_crit_gw.asc") nman_crit_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nman_crit_gw,"The critical N input from manure for the groundwater criterion is") # calculate critical N input from fertilizer nfert_crit_gw = ascraster.duplicategrid(nman_crit_gw) nfert_crit_gw.multiply(frnfe_division) fileout = os.path.join(params.outputdir,"nfert_crit_gw.asc") nfert_crit_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nfert_crit_gw,"The critical N input from fertilizer for the groundwater criterion is") # calculate related N deposition nh3em_man_crit_gw = ascraster.duplicategrid(nman_crit_gw) nh3em_man_crit_gw.multiply(nh3_ef_man_agri) fileout = os.path.join(params.outputdir,"nh3em_man_crit_gw.asc") nh3em_man_crit_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) nh3em_fert_crit_gw = ascraster.duplicategrid(nfert_crit_gw) nh3em_fert_crit_gw.multiply(nh3_ef_fert_agri) fileout = os.path.join(params.outputdir,"nh3em_fert_crit_gw.asc") nh3em_fert_crit_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) nh3em_crit_gw = ascraster.duplicategrid(nh3em_fert_crit_gw) nh3em_crit_gw.add(nh3em_man_crit_gw) fileout = os.path.join(params.outputdir,"nh3em_crit_gw.asc") nh3em_crit_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) ndep_crit_gw_tot = ascraster.duplicategrid(nh3em_crit_gw) ndep_crit_gw_tot.add(nox_em) ndep_crit_gw_tot.add(nh3_tot_egl) ndep_crit_gw_agri = ascraster.duplicategrid(ndep_crit_gw_tot) ndep_crit_gw_agri.multiply(fagri) print_debug(ndep_crit_gw_agri,"The critical N deposition on ag. land for the groundwater criterion is") # calculate total critical N inputs groundwater nin_crit_gw_agri = ascraster.duplicategrid(nman_crit_gw) nin_crit_gw_agri.add(nfert_crit_gw) nin_crit_gw_agri.add(ndep_crit_gw_agri) nin_crit_gw_agri.add(n_fix_agri) fileout = os.path.join(params.outputdir,"nin_crit_gw_agri.asc") nin_crit_gw_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nin_crit_gw_agri,"The total critical input for the groundwater criterion is") # calculate N surface runoff at critical N inputs groundwater nsro_crit_gw_agri = ascraster.duplicategrid(nin_crit_gw_agri) nsro_crit_gw_agri.multiply(fsro_ag) print_debug(nsro_crit_gw_agri,"The critical N surface runoff for the groundwater criterion is") # calculate N uptake at critical N inputs nup_crit_gw_agri = ascraster.duplicategrid(nin_crit_gw_agri) nup_crit_gw_agri.substract(nsro_crit_gw_agri) nup_crit_gw_agri.multiply(frnup_agri) fileout = os.path.join(params.outputdir,"nup_crit_gw_agri.asc") nup_crit_gw_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nup_crit_gw_agri,"The N uptake for the groundwater criterion is") # calculate NUE nue_crit_gw_agri = ascraster.duplicategrid(nup_crit_gw_agri) nue_crit_gw_agri.divide(nin_crit_gw_agri, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"nue_crit_gw_agri.asc") nue_crit_gw_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_crit_gw_agri,"The NUE for the groundwater criterion is") # calculate maximum uptake fraction fnup_max_gw = ascraster.duplicategrid(n_up_max) fnup_max_gw.divide(nup_crit_gw_agri) fileout = os.path.join(params.outputdir,"fnup_max_gw.asc") fnup_max_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fnup_max_gw,"The fraction maximum uptake / critical uptake for groundwater is") # calculate correction factor for those cases where critical N uptake exceeds max. N uptake fnup_corr_gw = ascraster.duplicategrid(n_in_max) fnup_corr_gw.substract(n_fix_agri) temp2 = ascraster.duplicategrid(nh3_tot_egl) temp2.add(nox_em) temp2.multiply(fagri) fnup_corr_gw.substract(temp2) temp3 = ascraster.duplicategrid(nh3em_crit_gw) temp3.multiply(fagri) temp3.add(nman_crit_gw) temp3.add(nfert_crit_gw) fnup_corr_gw.divide(temp3, default_nodata_value = -9999) fileout = os.path.join(params.outputdir,"fnup_corr_gw.asc") fnup_corr_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(fnup_corr_gw,"The correction factor for cases where Nup,crit>Nup,max is") ########### Checking degree of exceedance of critical N leaching by FIXED N inputs ############ # Calculate N leaching caused by N fixation alone nle_nfix_gw = ascraster.duplicategrid(n_fix_agri) nle_nfix_gw.multiply(v) #fileout = os.path.join(params.outputdir,"nle_nfix_gw.asc") #nle_nfix_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nle_nfix_gw,"The N leaching caused by N fixation alone is") # Calculate N leaching caused by NOx emissions alone nle_nox_gw = ascraster.duplicategrid(nox_em) nle_nox_gw.multiply(fagri) nle_nox_gw.multiply(v) #fileout = os.path.join(params.outputdir,"nle_nox_gw.asc") #nle_nox_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nle_nox_gw,"The N leaching caused by NOx emissions alone is") # Calculate N leaching caused by NH3,egl emissions alone nle_nh3egl_gw = ascraster.duplicategrid(nh3_tot_egl) nle_nh3egl_gw.multiply(fagri) nle_nh3egl_gw.multiply(v) #fileout = os.path.join(params.outputdir,"nle_nh3egl_gw.asc") #nle_nh3egl_gw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nle_nh3egl_gw,"The N leaching caused by NH3 emissions from ext grassland alone is") ############################################################################################# ########### FORWARD CALCULATIONS TO CHECK ########### # Critical N budget nbud_crit_gw_agri = ascraster.duplicategrid(nin_crit_gw_agri) nbud_crit_gw_agri.substract(nup_crit_gw_agri) print_debug(nbud_crit_gw_agri,"The critical N budget for the groundwater criterion is") # Critical leaching nle_crit_gw_agri_test = ascraster.duplicategrid(nbud_crit_gw_agri) nle_crit_gw_agri_test.substract(nsro_crit_gw_agri) nle_crit_gw_agri_test.multiply(fle_ag) print_debug(nle_crit_gw_agri_test,"The critical N leaching for the groundwater criterion is") # TEST IF FORWARD CALCULATIONS EQUAL BACKWARD CALLCULATION if icell_debug<0: pass else: fw = nle_crit_gw_agri_test.get_data(icell_debug) bw = nle_crit_gw_agri.get_data(icell_debug) if fw is None: print("FW / BW TEST: Forward calculation not possible (Nin,crit=None)") else: fw = round(fw,4) bw = round(bw,4) if fw == bw: print("FW / BW TEST: SUCCESFUL") else: print("FW / BW TEST: NOT SUCCESFUL") ############################################################################################
def calculate(params,isocode,regiondata_dict,PopNum,Nemiss,Pemiss,EmPldet,EmPddet,PopUrbNum,PopConNum): ''' Calculate the N and P emission from industry ''' # Multiply urban emission with factor_industry to obtain output industry [kg/yr] # Assumption is that only urban areas have industry and # industry depends on urban emission only and also detergents for P factor_industry = data_class.get_data(params.filefactor_industry,year=params.year,sep=params.sep,isocode=isocode,method=1) Nemiss_industry_tot = {} Pemiss_industry_tot = {} Nemiss_industry = {} Pemiss_industry = {} Nindustry_other = {} Pindustry_other = {} for key in isocode: pop = max(PopUrbNum[key],PopConNum[key]) Nemiss_industry_tot[key] = Nemiss[key] * factor_industry[key] * pop Pemiss_industry_tot[key] = ((Pemiss[key] * pop) + (EmPldet[key] + EmPddet[key])*PopNum[key]) * \ factor_industry[key] Nemiss_industry[key] = Nemiss_industry_tot[key] *\ (1.0-params.industry_loss_fraction_N) Pemiss_industry[key] = Pemiss_industry_tot[key] * (1.0-params.industry_loss_fraction_P) Nindustry_other[key] = Nemiss_industry_tot[key] * params.industry_loss_fraction_N Pindustry_other[key] = Pemiss_industry_tot[key] * params.industry_loss_fraction_P regiondata.put2regiondata(Nemiss_industry_tot,regiondata_dict,"Nemiss_industry") regiondata.put2regiondata(Pemiss_industry_tot,regiondata_dict,"Pemiss_industry") regiondata.put2regiondata(Nindustry_other,regiondata_dict,"Nindustry_other") regiondata.put2regiondata(Pindustry_other,regiondata_dict,"Pindustry_other") print_debug("Total Nemiss of industry",Nemiss_industry_tot) print_debug("Total Pemiss of industry",Pemiss_industry_tot) print_debug("Nemiss of industry",Nemiss_industry) print_debug("Pemiss of industry",Pemiss_industry) print_debug("factor_industry",factor_industry) print_debug("Nindustry_other",Nindustry_other) print_debug("Pindustry_other",Pindustry_other) return Nemiss_industry,Pemiss_industry
def calculate(params): print("The critical N concentration in surface water is", params.crit_sw) # load needed variables for calculations n_fix_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "nfix_grass_ext.asc"), numtype=float, mask=params.mask) n_fix_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "nfix_nat.asc"), numtype=float, mask=params.mask) nup_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.inputdir, "n_up_grass_ext.asc"), numtype=float, mask=params.mask) q = ascraster.Asciigrid(ascii_file=os.path.join(params.inputdir, "q.asc"), numtype=float, mask=params.mask) nman_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nman_egl.asc"), numtype=float, mask=params.mask) npoint_tot = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "npoint_tot.asc"), numtype=float, mask=params.mask) nero_tot = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nero_tot.asc"), numtype=float, mask=params.mask) nload_fixed_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nload_fixed_ag.asc"), numtype=float, mask=params.mask) nload_fixed_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nload_fixed_nat.asc"), numtype=float, mask=params.mask) fle_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fle_ag.asc"), numtype=float, mask=params.mask) fle_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fle_nat.asc"), numtype=float, mask=params.mask) fsro_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fsro_ag.asc"), numtype=float, mask=params.mask) fsro_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fsro_nat.asc"), numtype=float, mask=params.mask) frnup_agri = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnup_agri.asc"), numtype=float, mask=params.mask) fgw_rec_le_ag = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fgw_rec_le_ag.asc"), numtype=float, mask=params.mask) fgw_rec_le_nat = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fgw_rec_le_nat.asc"), numtype=float, mask=params.mask) n_fix_agri = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "n_fix_agri.asc"), numtype=float, mask=params.mask) nox_em = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nox_em.asc"), numtype=float, mask=params.mask) nh3_tot_egl = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_tot_egl.asc"), numtype=float, mask=params.mask) nh3_ef_man_agri = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_man_agri.asc"), numtype=float, mask=params.mask) nh3_ef_fert_agri = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "nh3_ef_fert_agri.asc"), numtype=float, mask=params.mask) frnfe_agri = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "frnfe_agri.asc"), numtype=float, mask=params.mask) fagri = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "fagri.asc"), numtype=float, mask=params.mask) fegl = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fegl.asc"), numtype=float, mask=params.mask) fnat = ascraster.Asciigrid(ascii_file=os.path.join(params.outputdir, "fnat.asc"), numtype=float, mask=params.mask) n_up_max = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "n_up_max.asc"), numtype=float, mask=params.mask) n_in_max = ascraster.Asciigrid(ascii_file=os.path.join( params.outputdir, "n_in_max.asc"), numtype=float, mask=params.mask) # calculate Nload,crit,sw =Q*Nconc,sw(crit) nload_crit_sw = ascraster.duplicategrid(q) nload_crit_sw.multiply(params.crit_sw) #fileout = os.path.join(params.outputdir,"nload_crit_sw.asc") #nload_crit_sw.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nload_crit_sw, "The critical N load to surface water is") # calculate fixed N load to surface water nload_fixed_tot = ascraster.duplicategrid(npoint_tot) nload_fixed_tot.add(nero_tot) nload_fixed_tot.add(nload_fixed_ag) nload_fixed_tot.add(nload_fixed_nat) print_debug(nload_fixed_tot, "The fixed N load to surface water is") # calculate parameter 'v' v_part1 = ascraster.duplicategrid(fgw_rec_le_ag) v_part1.multiply(fle_ag) v_part2 = ascraster.duplicategrid(v_part1) v_part2.multiply(frnup_agri) v_part3 = ascraster.duplicategrid(v_part2) v_part3.multiply(fsro_ag) v_part4 = ascraster.duplicategrid(fgw_rec_le_ag) v_part4.multiply(fle_ag) v_part4.multiply(fsro_ag) v = ascraster.duplicategrid(v_part1) v.substract(v_part2) v.add(v_part3) v.substract(v_part4) v.add(fsro_ag) print_debug(v, "The value for parameter v is") # calculate parameter 'w' w_part1 = ascraster.duplicategrid(fgw_rec_le_nat) w_part1.multiply(fle_nat) w_part2 = ascraster.duplicategrid(w_part1) w_part2.multiply(fsro_nat) w = ascraster.duplicategrid(w_part1) w.substract(w_part2) w.add(fsro_nat) print_debug(w, "The value for parameter w is") # calculate parameter 'x' x_part1 = ascraster.duplicategrid(fle_ag) x_part1.multiply(fgw_rec_le_ag) one_grid = ascraster.duplicategrid(fsro_ag) for i in range(one_grid.length): one_grid.set_data(i, 1.0) one_min_fsro_ag = ascraster.duplicategrid(one_grid) one_min_fsro_ag.substract(fsro_ag) x_part1.multiply(one_min_fsro_ag) x = ascraster.duplicategrid(fsro_ag) x.add(x_part1) print_debug(x, "The value for parameter x is") # calculate critical N input from manure #numerator numerator = ascraster.duplicategrid(nload_crit_sw) n1 = ascraster.duplicategrid(fle_ag) n1.multiply(fgw_rec_le_ag) n1.multiply(nup_egl) n2 = ascraster.duplicategrid(nox_em) n2.add(nh3_tot_egl) n2.multiply(fagri) n2.add(n_fix_agri) n2.multiply(v) n3 = ascraster.duplicategrid(nox_em) n3.add(nh3_tot_egl) n3.multiply(fnat) n3.add(n_fix_nat) n3.multiply(w) n4 = ascraster.duplicategrid(nox_em) n4.add(nh3_tot_egl) n4.multiply(fegl) n4.add(n_fix_egl) n4.add(nman_egl) n4.add(nh3_tot_egl) #$#V1.2#$# n4.multiply(x) numerator.substract(nload_fixed_tot) numerator.add(n1) numerator.substract(n2) numerator.substract(n3) numerator.substract(n4) #denominator d1 = ascraster.duplicategrid(v) d1.multiply(fagri) d2 = ascraster.duplicategrid(w) d2.multiply(fnat) d3 = ascraster.duplicategrid(x) d3.multiply(fegl) d3.add(d2) d3.add(d1) d4 = ascraster.duplicategrid(d3) d4.multiply(nh3_ef_man_agri) d4.add(v) denominator = ascraster.duplicategrid(d3) denominator.multiply(nh3_ef_fert_agri) denominator.add(v) one_grid = ascraster.duplicategrid(fsro_ag) for i in range(one_grid.length): one_grid.set_data(i, 1.0) one_min_frnfe_agri = ascraster.duplicategrid(one_grid) one_min_frnfe_agri.substract(frnfe_agri) frnfe_division = ascraster.duplicategrid(frnfe_agri) frnfe_division.divide(one_min_frnfe_agri, default_nodata_value=-9999) denominator.multiply(frnfe_division) denominator.add(d4) nman_crit_sw = ascraster.duplicategrid(numerator) nman_crit_sw.divide(denominator, default_nodata_value=-9999) for icell in range(nman_crit_sw.length): nman = nman_crit_sw.get_data(icell) if (nman is None): continue if (nman < 0): man = 0 else: continue nman_crit_sw.set_data(icell, man) fileout = os.path.join(params.outputdir, "nman_crit_sw.asc") nman_crit_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug( nman_crit_sw, "The critical N input from manure for the surface water criterion is") # calculate critical N input from fertilizer nfert_crit_sw = ascraster.duplicategrid(nman_crit_sw) nfert_crit_sw.multiply(frnfe_division) fileout = os.path.join(params.outputdir, "nfert_crit_sw.asc") nfert_crit_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug( nfert_crit_sw, "The critical N input from fertilizer for the surface water criterion is" ) # calculate related N deposition nh3em_man_crit_sw = ascraster.duplicategrid(nman_crit_sw) nh3em_man_crit_sw.multiply(nh3_ef_man_agri) fileout = os.path.join(params.outputdir, "nh3em_man_crit_sw.asc") nh3em_man_crit_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) nh3em_fert_crit_sw = ascraster.duplicategrid(nfert_crit_sw) nh3em_fert_crit_sw.multiply(nh3_ef_fert_agri) fileout = os.path.join(params.outputdir, "nh3em_fert_crit_sw.asc") nh3em_fert_crit_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) nh3em_crit_sw = ascraster.duplicategrid(nh3em_fert_crit_sw) nh3em_crit_sw.add(nh3em_man_crit_sw) fileout = os.path.join(params.outputdir, "nh3em_crit_sw.asc") nh3em_crit_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) ndep_crit_sw_tot = ascraster.duplicategrid(nh3em_crit_sw) ndep_crit_sw_tot.add(nox_em) ndep_crit_sw_tot.add(nh3_tot_egl) ndep_crit_sw_agri = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_agri.multiply(fagri) print_debug( ndep_crit_sw_agri, "The critical N deposition for the surface water criterion is") # calculate total critical N inputs surface water nin_crit_sw_agri = ascraster.duplicategrid(nman_crit_sw) nin_crit_sw_agri.add(nfert_crit_sw) nin_crit_sw_agri.add(ndep_crit_sw_agri) nin_crit_sw_agri.add(n_fix_agri) fileout = os.path.join(params.outputdir, "nin_crit_sw_agri.asc") nin_crit_sw_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nin_crit_sw_agri, "The total critical input for the surface water criterion is") # calculate N surface runoff at critical N inputs surface water nsro_crit_sw_agri = ascraster.duplicategrid(nin_crit_sw_agri) nsro_crit_sw_agri.multiply(fsro_ag) print_debug( nsro_crit_sw_agri, "The critical N surface runoff for the surface water criterion is") # calculate N uptake at critical N inputs nup_crit_sw_agri = ascraster.duplicategrid(nin_crit_sw_agri) nup_crit_sw_agri.substract(nsro_crit_sw_agri) nup_crit_sw_agri.multiply(frnup_agri) fileout = os.path.join(params.outputdir, "nup_crit_sw_agri.asc") nup_crit_sw_agri.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(nup_crit_sw_agri, "The N uptake for the surface criterion is") # calculate NUE nue_crit_sw_agri = ascraster.duplicategrid(nup_crit_sw_agri) nue_crit_sw_agri.divide(nin_crit_sw_agri, default_nodata_value=-9999) #fileout = os.path.join(params.outputdir,"nue_crit_sw_agri.asc") #nue_crit_sw_agri.write_ascii_file(fileout,output_nodata_value=-9999,compress=params.lcompress) print_debug(nue_crit_sw_agri, "The NUE for the surface water criterion is") # calculate maximum uptake fraction fnup_max_sw = ascraster.duplicategrid(n_up_max) fnup_max_sw.divide(nup_crit_sw_agri) fileout = os.path.join(params.outputdir, "fnup_max_sw.asc") fnup_max_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug( fnup_max_sw, "The fraction maximum uptake / critical uptake for surface water is") # calculate correction factor for those cases where critical N uptake exceeds max. N uptake fnup_corr_sw = ascraster.duplicategrid(n_in_max) fnup_corr_sw.substract(n_fix_agri) temp2 = ascraster.duplicategrid(nh3_tot_egl) temp2.add(nox_em) temp2.multiply(fagri) fnup_corr_sw.substract(temp2) temp3 = ascraster.duplicategrid(nh3em_crit_sw) temp3.multiply(fagri) temp3.add(nman_crit_sw) temp3.add(nfert_crit_sw) fnup_corr_sw.divide(temp3, default_nodata_value=-9999) fileout = os.path.join(params.outputdir, "fnup_corr_sw.asc") fnup_corr_sw.write_ascii_file(fileout, output_nodata_value=-9999, compress=params.lcompress) print_debug(fnup_corr_sw, "The correction factor for cases where Nup,crit>Nup,max is") # FORWARD CALCULATIONS TO CHECK # 1: N load from agricultural land # Critical N budget nbud_crit_sw_agri = ascraster.duplicategrid(nin_crit_sw_agri) nbud_crit_sw_agri.substract(nup_crit_sw_agri) print_debug(nbud_crit_sw_agri, "The critical N budget for the surface water criterion is") # nle ag crit sw nle_crit_sw_agri = ascraster.duplicategrid(nbud_crit_sw_agri) nle_crit_sw_agri.substract(nsro_crit_sw_agri) nle_crit_sw_agri.multiply(fle_ag) # ,minimum = 0.0 print_debug(nle_crit_sw_agri, "The critical N leaching for the surface water criterion is") # ngw_rec_ag crit sw ngw_rec_crit_sw_agri = ascraster.duplicategrid(nle_crit_sw_agri) ngw_rec_crit_sw_agri.multiply(fgw_rec_le_ag) print_debug( ngw_rec_crit_sw_agri, "The critical groundwater N load to surface water from agriculture due to RECENT N inputs for the surface water criterion is" ) # nload var ag crit sw nload_var_crit_sw_agri = ascraster.duplicategrid(nsro_crit_sw_agri) nload_var_crit_sw_agri.add(ngw_rec_crit_sw_agri) print_debug( nload_var_crit_sw_agri, "The variable critial N load to surface water from ag. areas for the surface water criterion is" ) # 2: N load from natural land # ndep nat crit sw ndep_crit_sw_nat = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_nat.multiply(fnat) print_debug( ndep_crit_sw_nat, "The critical N deposition on natural areas for the surface water criterion is" ) # nbud nat crit sw nbud_crit_sw_nat = ascraster.duplicategrid(ndep_crit_sw_nat) nbud_crit_sw_nat.add(n_fix_nat) print_debug( nbud_crit_sw_nat, "The critical N budget for natural areas for the surface water criterion is" ) # nsro nat crit sw nsro_crit_sw_nat = ascraster.duplicategrid(nbud_crit_sw_nat) nsro_crit_sw_nat.multiply(fsro_nat) print_debug( nsro_crit_sw_nat, "The critical N surface runoff for natural areas for the surface water criterion is" ) # nle nat crit sw nle_crit_sw_nat = ascraster.duplicategrid(nbud_crit_sw_nat) nle_crit_sw_nat.substract(nsro_crit_sw_nat) nle_crit_sw_nat.multiply(fle_nat) print_debug( nle_crit_sw_nat, "The critical N leaching for natural areas for the surface water criterion is" ) # ngw_rec_nat crit sw ngw_rec_crit_sw_nat = ascraster.duplicategrid(nle_crit_sw_nat) ngw_rec_crit_sw_nat.multiply(fgw_rec_le_nat) print_debug( ngw_rec_crit_sw_nat, "The critical groundwater N load to surface water from natural areas due to RECENT N inputs for the surface water criterion is" ) # nload var nat crit sw nload_var_crit_sw_nat = ascraster.duplicategrid(nsro_crit_sw_nat) nload_var_crit_sw_nat.add(ngw_rec_crit_sw_nat) print_debug( nload_var_crit_sw_nat, "The variable critical N load to surface water from natural areas for the surface water criterion is" ) # 3: N load from extensive grassland # ndep egl crit sw ndep_crit_sw_egl = ascraster.duplicategrid(ndep_crit_sw_tot) ndep_crit_sw_egl.multiply(fegl) print_debug( ndep_crit_sw_egl, "The critical N deposition on extensive grasslands for the surface water criterion is" ) # nin egl crit sw nin_crit_sw_egl = ascraster.duplicategrid(ndep_crit_sw_egl) nin_crit_sw_egl.add(n_fix_egl) nin_crit_sw_egl.add(nman_egl) nin_crit_sw_egl.add(nh3_tot_egl) #$#V1.2#$# print_debug( nin_crit_sw_egl, "The critical N input to extensive grasslands for the surface water criterion is" ) # nsro egl crit sw nsro_crit_sw_egl = ascraster.duplicategrid(nin_crit_sw_egl) nsro_crit_sw_egl.multiply(fsro_ag) print_debug( nsro_crit_sw_egl, "The critical N surface runoff for extensive grasslands for the surface water criterion is" ) # nbud egl crit sw nbud_crit_sw_egl = ascraster.duplicategrid(nin_crit_sw_egl) nbud_crit_sw_egl.substract(nup_egl) print_debug( nbud_crit_sw_egl, "The critical N budget for extensive grasslands for the surface water criterion is" ) # nle egl crit sw nle_crit_sw_egl = ascraster.duplicategrid(nbud_crit_sw_egl) nle_crit_sw_egl.substract(nsro_crit_sw_egl) nle_crit_sw_egl.multiply(fle_ag) print_debug( nle_crit_sw_egl, "The critical N leaching for extensive grasslands for the surface water criterion is" ) # ngw_rec_egl crit sw ngw_rec_crit_sw_egl = ascraster.duplicategrid(nle_crit_sw_egl) ngw_rec_crit_sw_egl.multiply(fgw_rec_le_ag) print_debug( ngw_rec_crit_sw_egl, "The critical groundwater N load to surface water from extensive grassland due to RECENT N inputs for the surface water criterion is" ) # nload var egl crit sw nload_var_crit_sw_egl = ascraster.duplicategrid(nsro_crit_sw_egl) nload_var_crit_sw_egl.add(ngw_rec_crit_sw_egl) print_debug( nload_var_crit_sw_egl, "The variable critial N load to surface water from extensive grassland for the surface water criterion is" ) # calculate n load tot crit sw TEST nload_crit_sw_test = ascraster.duplicategrid(nload_var_crit_sw_agri) nload_crit_sw_test.add(nload_var_crit_sw_nat) nload_crit_sw_test.add(nload_var_crit_sw_egl) nload_crit_sw_test.add(nload_fixed_tot) ########### FORWARD CALCULATIONS TO CHECK ########### if icell_debug < 0: pass else: fw = nload_crit_sw_test.get_data(icell_debug) bw = nload_crit_sw.get_data(icell_debug) #print(fw) #print(bw) if fw is None: print( "FW / BW TEST: Forward calculation not possible (Nin,crit=None)" ) else: fw = round(fw, 4) bw = round(bw, 4) if fw == bw: print("FW / BW TEST: SUCCESFUL") else: print("FW / BW TEST: NOT SUCCESFUL")