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")
