Emissions

Classes for calculating GHG emissions from reservoirs.

The net GHG emission is meant to represent the actual emission exclusively attributable to the reservoir impoundment and are calculated as follows:

Net GHG emission = (

Post-ipmoundment balance from the catchment - Pre-impoundment balance from the catchment - Emissions from the reservoir due to unrelated anthropogenic sources)

The emissions are calculated for the complete life time of reservoirs that is assumed = 100 years.

Contains:

• Emission base class from which all other emission classes are derived.

• CarbonDioxideEmission for calculating CO\(_2\) emissions.

• MethaneEmission for calculating CH\(_4\) emissions.

• NitrousOxideEmission for calculating N\(_2\)O emissions.

Note

Equations implemented in the methods in the below classes are the same equations introduded by Praire et al. 2021 (Praire2021) and share the same equation references.

The paper of Praire et al. Praire2021 is given below:

@article{Praire2021,
title = {A new modelling framework to assess biogenic GHG emissions from reservoirs: The G-res tool},
journal = {Environmental Modelling & Software},
volume = {143},
pages = {105117},
year = {2021},
issn = {1364-8152},
doi = {https://doi.org/10.1016/j.envsoft.2021.105117},
url = {https://www.sciencedirect.com/science/article/pii/S1364815221001602},
author = {Yves T. Prairie and Sara Mercier-Blais and John A. Harrison and Cynthia Soued and Paul del Giorgio and Atle Harby and Jukka Alm and Vincent Chanudet and Roy Nahas}}

class reemission.emissions.CarbonDioxideEmission(catchment: Catchment, reservoir: Reservoir, eff_temp: float, p_calc_method: str, preinund_area: float | None = None, config_file: Path = PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini'))

Bases: Emission

Class for calculating CO\(_2\) emissions.

eff_temp

Effective temperature for CO\(_2\).

Type:

float

p_calc_method

Method used for calculating annual discharge of P from catchment to the reservoir.

Type:

str

par

Indexable structure of equation parameters for emission calculations.

Type:

SimpleNamespace

pre_impoundment_table

Dictionary of pre-impoundment emission factors.

Type:

Dict

use_red_area

If True, P exports are calculated using the area surface and composition calculated as a difference between the catchment area and the reservoir area.

Type:

bool

Note

Total CO\(_2\) emission =

Diffusive CO\(_2\) emission (gross total post-impoundment) + - Pre-impoundment emission + - Unrelated non-anthropogenic emission

__abstractmethods__ = frozenset({})

__annotations__ = {'catchment': 'Catchment', 'config': 'configparser.ConfigParser', 'eff_temp': <class 'float'>, 'p_calc_method': <class 'str'>, 'par': <class 'types.SimpleNamespace'>, 'pre_impoundment_table': typing.Dict, 'preinund_area': 'float', 'reservoir': 'Reservoir', 'use_red_area': <class 'bool'>}

__dataclass_fields__ = {'catchment': Field(name='catchment',type=<class 'reemission.catchment.Catchment'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'config': Field(name='config',type=<class 'configparser.ConfigParser'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'eff_temp': Field(name='eff_temp',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'p_calc_method': Field(name='p_calc_method',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'par': Field(name='par',type=<class 'types.SimpleNamespace'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'pre_impoundment_table': Field(name='pre_impoundment_table',type=typing.Dict,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'preinund_area': Field(name='preinund_area',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'reservoir': Field(name='reservoir',type=<class 'reemission.reservoir.Reservoir'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'use_red_area': Field(name='use_red_area',type=<class 'bool'>,default=True,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}

__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False)

__eq__(other)

Return self==value.

__hash__ = None

__init__(catchment: Catchment, reservoir: Reservoir, eff_temp: float, p_calc_method: str, preinund_area: float | None = None, config_file: Path = PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini')) → None

Initializes the CarbonDioxideEmission object.

Parameters:

• catchment (Catchment) – Catchment object containing catchment data and methods.

• reservoir (Reservoir) – Reservoir object containing reservoir data and methods.

• eff_temp (float) – Effective temperature for CO\(_2\).

• p_calc_method (str) – Method used for calculating annual discharge of P from the catchment to the reservoir.

• preinund_area (Optional[float]) – Pre-inundation area of the reservoir in hectares. Defaults to None.

• config_file (pathlib.Path) – Path to the configuration file. Defaults to INI_FILE.

__match_args__ = ('catchment', 'reservoir', 'preinund_area', 'config', 'eff_temp', 'p_calc_method', 'par', 'pre_impoundment_table', 'use_red_area')

__module__ = 'reemission.emissions'

__repr__()

Return repr(self).

_abc_impl = <_abc._abc_data object>

_diffusion_flux_profile(years: Tuple[int, ...] = (1, 5, 10, 20, 30, 40, 50, 100)) → list

Calculate CO\(_2\) fluxes for a given tuple of years.

Parameters:

years (Tuple[int, ...]) – A tuple of years for which to calculate the CO\(_2\) fluxes.

Returns:

List of CO\(_2\) fluxes for each year in the tuple.

Return type:

List[float]

diffusion_flux(year: int, time_horizon: int = 100) → float

Calculates CO\(_2\) diffusive flux for a given year/age in years.

Parameters:

• year (int) – The year for which to calculate the diffusive flux.

• time_horizon (int) – The time horizon for calculating GWP value. Defaults to 100.

Returns:

The diffusive flux value in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

CO\(_2\) diffusion flux equation:

\[\begin{split}\begin{eqnarray} q_{CO_2, diffusion} (t, n) & = & 10^\left( k_1^{diff} + k_2^{diff} \, \log_{10} (t) + k_3^{diff} \, T_{eff,CO_2} + k_4^{diff} \, \log_{10} (A_{res}) + k_5^{diff} \, m_{sc} + k_6^{diff} \, \log_{10} (C_{TP}) \right) \\ & & \times \left(1 - \frac{A_{pre}}{A_{res}}\right) \times \frac{44}{12} \times \frac{1}{1000} \times 365 \times \textrm{gwp}_{CO_2}^{n} \end{eqnarray}\end{split}\]

where: * \(t\) is the reservoir age, years * \(n\) is the time horizon for calculating GWP value, years * \(T_{eff,CO_2}\) is the effective temperature for CO\(_2\), degC * \(A_{res}\) is the reservoir area, km\(^2\) * \(m_{sc}\) is the mass of C in inundated area, kg/m\(^2\) * \(C_{TP}\) is the reservoir Total P conc., \(\mu\)g/L * \(A_{pre}\) is the preinundation (river) area, km\(^2\) * 44/12 is a molecular weight ratio between CO\(_2\) and C * 365 is used to convert emissions from d\(^{-1}\) to yr\(^{-1}\) * 1/1000 is used to convert the unit from mg to g * \(\textrm{gwp}_{CO_2}^{n}\) is the global warming potential for CO\(_2\) over n years (deafault n = 100)

Note

Eq. 7 in Praire2021 n=169, R2=0.36, RMSE=0.39, Outliers=3

diffusion_flux_int(number_of_years: int = 100) → float

Calculate gross total CO\(_2\) emissions in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) from a reservoir integrated over a number of years (n = 100 years by default).

Parameters:

number_of_years (int) – The number of years over which to integrate the emissions. Defaults to 100.

Returns:

Gross total CO\(_2\) emissions in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

Gross total (integrated) CO\(_2\) emission (via diffusion):

\[\begin{split}\begin{eqnarray} q_{CO_2, gross} (n) & = & q_{CO_2, diffusion} (t=1, n) \times \textrm{gwp}_{CO_2}^{n} \times \\ & & \frac{n^{k_2^{diff}+1} - 0.5^{k_2^{diff}+1}}{(k_2^{diff}+1)*(n-0.5)} \end{eqnarray}\end{split}\]

where:

• \(n\) is the number of years the emission is sumed up for

• \(\textrm{gwp}_{CO_2}^{n}\) is the global warming potential of CO\(_2\) over n years

Note

Eq. 8 in Praire2021 Currently, integration over 100 years is supported by the tool and n=100 years is the default value.

diffusion_flux_nonanthro() → float

Calculate nonanthropogenic CO\(_2\) flux as CO\(_2\) (diffusive) flux after 100 years.

Note

It is assumed that all anthropogenic effects become null after 100 years and the flux that remains after 100 years is due to non-anthropogenic sources.

Returns:

Nonanthropogenic CO\(_2\) flux in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

eff_temp: float

factor(number_of_years: int = 100) → float

Calculates overall integrated emissions for lifetime.

Parameters:

number_of_years (int, optional) – Number of years to integrate emissions over. Defaults to 100.

Returns:

Overall integrated emissions in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\)

Return type:

float

net_total(number_of_years: int = 100) → float

Calculates net total CO\(_2\) emissions, i.e. gross - non anthropogenic (in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\)) from a reservoir over a number of years.

Parameters:

number_of_years (int, optional) – Number of years to calculate net emissions for. Defaults to 100.

Returns:

Net total CO\(_2\) emissions in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

p_calc_method: str

par: SimpleNamespace

pre_impoundment() → float

Calculates CO\(_2\) emissions from the inundated area prior to impoundment.

Uses a table of pre-impoundment emissions per land cover category and soil type, in tCO\(_2\)-C/ha/yr.

Returns:

Unit pre-impoundment emission in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

pre_impoundment_table: Dict

profile(years: Tuple[int, ...] = (1, 5, 10, 20, 30, 40, 50, 100)) → List[float]

Calculates CO\(_2\) emissions for a number of years.

Note

Flux at year x age - pre-impoundment emissions - non-anthropogenic

emissions, unit: gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\)

Parameters:

years (Tuple[int, ...], optional) – Tuple of years to calculate CO\(_2\) emissions for. Defaults to (1, 5, 10, 20, 30, 40, 50, 100).

Returns:

List of CO\(_2\) emission values in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

List[float]

property reservoir_tn: float

Returns the reservoir total nitrogen concentration in \(\mu\)g/L.

Returns:

Reservoir total nitrogen concentration in \(\mu\)g/L.

Return type:

float

property reservoir_tp: float

Returns the reservoir total phosphorus concentration in \(\mu\)g/L.

Returns:

Reservoir total phosphorus concentration in \(\mu\)g/L.

Return type:

float

total_emission_per_year(number_of_years: int = 100) → float

Calculates total reservoir emission per year in tCO\(_{2e}\) / year.

Parameters:

number_of_years (int, optional) – Number of years to calculate emissions for. Defaults to 100.

Returns:

Total reservoir emission per year in tCO\(_{2e}\) / year.

Return type:

float

total_lifetime_emission(number_of_years: int = 100) → float

Calculates total reservoir emission per lifetime in ktCO\(_{2e}\).

Parameters:

number_of_years (int, optional) – Number of years to calculate emissions for. Defaults to 100.

Returns:

Total reservoir emission per lifetime in ktCO\(_{2e}\).

Return type:

float

use_red_area: bool = True

class reemission.emissions.Emission(catchment, reservoir, preinund_area=None, config_file=PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini'))

Bases: ABC

Abstract base class for all emissions.

catchment

Catchment object with catchment data and methods.

Type:

Catchment

reservoir

Reservoir object with reservoir data and methods.

Type:

Reservoir

preinund_area

Pre-inundation area of a reservoir, in hectares.

Type:

float

config

ConfigParser object containing configuration from an .ini file with equation constants.

Type:

configparser.ConfigParser

Note

This class defines two generic methods that must be implemented in all emission subclasses: - profile: Calculates emission decay over a set of years. - factor: Calculates total emission over the lifespan of the reservoir.

__abstractmethods__ = frozenset({'factor', 'profile', 'total_emission_per_year', 'total_lifetime_emission'})

__annotations__ = {'catchment': <class 'reemission.catchment.Catchment'>, 'config': <class 'configparser.ConfigParser'>, 'preinund_area': <class 'float'>, 'reservoir': <class 'reemission.reservoir.Reservoir'>}

__dataclass_fields__ = {'catchment': Field(name='catchment',type=<class 'reemission.catchment.Catchment'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'config': Field(name='config',type=<class 'configparser.ConfigParser'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'preinund_area': Field(name='preinund_area',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'reservoir': Field(name='reservoir',type=<class 'reemission.reservoir.Reservoir'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}

__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False)

__dict__ = mappingproxy({'__module__': 'reemission.emissions', '__annotations__': {'catchment': <class 'reemission.catchment.Catchment'>, 'reservoir': <class 'reemission.reservoir.Reservoir'>, 'preinund_area': <class 'float'>, 'config': <class 'configparser.ConfigParser'>}, '__doc__': 'Abstract base class for all emissions.\n\n    Attributes:\n        catchment (Catchment): Catchment object with catchment data and methods.\n        reservoir (Reservoir): Reservoir object with reservoir data and methods.\n        preinund_area (float): Pre-inundation area of a reservoir, in hectares.\n        config (configparser.ConfigParser): ConfigParser object containing configuration from an .ini file with equation constants.\n\n    Note:\n        This class defines two generic methods that must be implemented in all emission subclasses:\n        - ``profile``: Calculates emission decay over a set of years.\n        - ``factor``: Calculates total emission over the lifespan of the reservoir.\n    ', '__init__': <function Emission.__init__>, '_par_from_config': <function Emission._par_from_config>, 'profile': <function Emission.profile>, 'factor': <function Emission.factor>, 'total_emission_per_year': <function Emission.total_emission_per_year>, 'total_lifetime_emission': <function Emission.total_lifetime_emission>, '__dict__': <attribute '__dict__' of 'Emission' objects>, '__weakref__': <attribute '__weakref__' of 'Emission' objects>, '__abstractmethods__': frozenset({'total_emission_per_year', 'factor', 'total_lifetime_emission', 'profile'}), '_abc_impl': <_abc._abc_data object>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False), '__dataclass_fields__': {'catchment': Field(name='catchment',type=<class 'reemission.catchment.Catchment'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'reservoir': Field(name='reservoir',type=<class 'reemission.reservoir.Reservoir'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'preinund_area': Field(name='preinund_area',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'config': Field(name='config',type=<class 'configparser.ConfigParser'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__repr__': <function Emission.__repr__>, '__eq__': <function Emission.__eq__>, '__hash__': None, '__match_args__': ('catchment', 'reservoir', 'preinund_area', 'config')})

__eq__(other)

Return self==value.

__hash__ = None

__init__(catchment, reservoir, preinund_area=None, config_file=PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini'))

Initializes the Emission object.

Parameters:

• catchment (Catchment) – Catchment object containing catchment data and methods.

• reservoir (Reservoir) – Reservoir object containing reservoir data and methods.

• preinund_area (float, optional) – Pre-inundation area of the reservoir in hectares. Defaults to None.

• config_file (str) – Path to the configuration file. Defaults to INI_FILE.

__match_args__ = ('catchment', 'reservoir', 'preinund_area', 'config')

__module__ = 'reemission.emissions'

__repr__()

Return repr(self).

__weakref__

list of weak references to the object

_abc_impl = <_abc._abc_data object>

_par_from_config(list_of_constants: list, section_name: str) → SimpleNamespace

Reads constants (parameters) from the configuration file.

Parameters:

• list_of_constants (list) – List of parameter names to read from the config file.

• section_name (str) – The section in the config file to read the parameters from.

Returns:

A namespace containing the parameters read from the config file.

Return type:

SimpleNamespace

catchment: Catchment

config: ConfigParser

abstract factor(number_of_years: int) → float

Calculates total emission (factor).

Parameters:

number_of_years (int) – The number of years over which to calculate the total emission.

Returns:

Total emission per m\(^2\) of the reservoir per year over the lifespan of the reservoir, in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

preinund_area: float

abstract profile(years: Tuple[int, ...]) → List[float]

Calculates emission profile in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) over a number of years years.

Parameters:

years (Tuple[int, ...]) – A tuple containing the years over which to calculate the emission profile.

Returns:

A list of emission values for each year.

Return type:

List[float]

reservoir: Reservoir

abstract total_emission_per_year(number_of_years: int) → float

Calculates total reservoir emission per year over the lifespan of the reservoir.

Parameters:

number_of_years (int) – The number of years over which to calculate the total emission per year.

Returns:

Total reservoir emission per year, in tCO\(_{2e}\)/year.

Return type:

float

abstract total_lifetime_emission(number_of_years: int) → float

Calculates total reservoir emission over its lifetime.

Parameters:

number_of_years (int) – The number of years over which to calculate the total lifetime emission.

Returns:

Total reservoir emission over its lifetime, in tCO\(_{2e}\).

Return type:

float

class reemission.emissions.MethaneEmission(catchment: Catchment, reservoir: Reservoir, monthly_temp: MonthlyTemperature, preinund_area: float | None = None, config_file: Path = PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini'))

Bases: Emission

Class for calculating methane emissions from reservoirs.

monthly_temp

A vector of averaged monthly temperatures.

Type:

MonthlyTemperature

mean_ir

mean infrared radiation in kWh/m\(^2\)/d.

Type:

float

pre_impoundment_table

Parameters for calculating pre-impoundment CH\(_4\) emissions. None, if table could not be loaded.

Type:

dict

par

subset of parameters relate to CH\(_4\) emissions found in config.ini

Note

Gross total CH\(_4\) emission (in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) is calculated as a sum of the

following pathways/processes: * CH\(_4\) diffusive emissions. * CH\(_4\) bubbling emission (ebullition). * CH\(_4\) degassing emissions.

All of the three above processes are integrated over 100 years.

Total CH\(_4\) emission = Gross total CH\(_4\) emission (post-impoundment)+

• Pre-impoundment emission +

• Unrelated non-anthropogenic emission

__abstractmethods__ = frozenset({})

__annotations__ = {'catchment': 'Catchment', 'config': 'configparser.ConfigParser', 'monthly_temp': <class 'reemission.temperature.MonthlyTemperature'>, 'pre_impoundment_table': 'dict', 'preinund_area': 'float', 'reservoir': 'Reservoir'}

__dataclass_fields__ = {'catchment': Field(name='catchment',type=<class 'reemission.catchment.Catchment'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'config': Field(name='config',type=<class 'configparser.ConfigParser'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'monthly_temp': Field(name='monthly_temp',type=<class 'reemission.temperature.MonthlyTemperature'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'preinund_area': Field(name='preinund_area',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'reservoir': Field(name='reservoir',type=<class 'reemission.reservoir.Reservoir'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}

__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False)

__eq__(other)

Return self==value.

__hash__ = None

__init__(catchment: Catchment, reservoir: Reservoir, monthly_temp: MonthlyTemperature, preinund_area: float | None = None, config_file: Path = PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini'))

Initialize MethaneEmission instance.

Parameters:

• catchment (Catchment) – Catchment object representing the catchment area.

• reservoir (Reservoir) – Reservoir object representing the reservoir.

• monthly_temp (MonthlyTemperature) – MonthlyTemperature object for monthly temperature data.

• preinund_area (float, optional) – Pre-inundation area in hectares.

• config_file (pathlib.Path, optional) – Path to the configuration file (default: INI_FILE).

__match_args__ = ('catchment', 'reservoir', 'preinund_area', 'config', 'monthly_temp')

__module__ = 'reemission.emissions'

__repr__()

Return repr(self).

_abc_impl = <_abc._abc_data object>

_degassing_flux_profile(years: Tuple[int, ...] = (1, 5, 10, 20, 30, 40, 50, 100)) → List[float]

Calculate degassing profile for a vector of years.

Parameters:

years (Tuple[int, ...], optional) – Vector of years for emission profile (default: (1, 5, 10, 20, 30, 40, 50, 100)).

Returns:

List of degassing flux values in gCO\(_{2e} m\)^{-2}$ yr\(^{-1}\) corresponding to the input years.

Return type:

List[float]

_diffusion_flux_profile(years: Tuple[int, ...] = (1, 5, 10, 20, 30, 40, 50, 100)) → List[float]

Calculate CH\(_4\) emission profile for a vector of years.

Parameters:

years (Tuple[int, ...], optional) – Vector of years for emission profile (default: (1, 5, 10, 20, 30, 40, 50, 100)).

Returns:

List of diffusion flux values in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) corresponding to the input years.

Return type:

List[float]

_ebullition_flux_profile(years: Tuple[int, ...] = (1, 5, 10, 20, 30, 40, 50, 100)) → List[float]

Converts ebullition emission into a profile with points (emission values) defined in the argument years.

Attention

Since ebullition is not time-dependent, the output will be a list with values all equal to the ebullition value (scalar).

Parameters:

years (Tuple[int, ...], optional) – Vector of years for emission profile (default: (1, 5, 10, 20, 30, 40, 50, 100)).

Returns:

List of ebullition flux values in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) corresponding to the input years.

Return type:

List[float]

degassing_flux(year: float, time_horizon: int = 100) → float

Calculate CH\(_4\) emission flux via degassing for a given year and time horizon. Time horizon is used to select the appropriate GWP value for methane.

Note

The degassing emission flux is back-calculated from the gross (integrated) degassing flux and is given in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Parameters:

• year (float) – Reservoir age in years (after impoundment).

• time_horizon (int, optional) – Time horizon in years (default: 100).

Returns:

Degassing flux in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

\[\begin{equation} q_{CH_4, degassing}(t, n) = q_{CH_4, degassing}^{init}(n) \; \exp(-k_4^{degas} \ln(10) \, t) \end{equation}\]

where \(q_{CH_4, degassing}^{init}(n)\) equals:

\[\begin{equation} q_{CH_4, degassing}^{init}(n) = q_{CH_4, degassing}^{gross}(n) * \frac{-k_4^{degas}\,\ln(10)\,n}{1-10^{k_4^{degas}\,n}} \end{equation}\]

where:

• \(q_{CH_4, degassing}(t, n)\) is the unit (per time) CH\(_4\) emission via degassing at time t (years), (g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\))

• \(q_{CH_4, degassing}^{init}(n)\) is the unit (per time) CH\(_4\) emission via degassing at time t=0 years, (g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\))

• \(q_{CH_4, degassing}^{gross}(n)\) is the unit (per time) gross CH\(_4\) emission via degassing integrated over n=100 years, (g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\))

• \(k_4^{degas}\ln(10)\) is the emission decay time-constant, yr\(^{-1}\).

degassing_flux_int(time_horizon: int = 100) → float

Calculate CH\(_4\) emission per year via degassing, integrated over time horizon given in argument time_horizon in years.

Note

Degassing emissions are computed when the hydroleclectric facility has a deep water draw off point & when this deep water draw off takes water from below the thermocline of a stratified system. For this reason, deep water draw off depth and thermocline depth are required for formal assesment of whether a degassing flux should be estimated. In general, neither of these two data can be reliably measured/estimated. However, we can assume that most new hydroelectric facilities will operate deep water draw offs, and at least in the tropics in deeper systems (>10m mean depth), stratification will occur.

If water intake depth < thermocline depth: \(q_{CH_4, degassing}^{gross} = 0\), else:

\[\begin{split}\begin{eqnarray} q_{CH_4, degassing}^{gross} (n)& = & 10^{\left(k_1^{degas} + k_2^{degas}\,\log10(WRT) + k_3^{degas}\,\log10\left(q_{CH_4, diffusion}^{gross} (n)\right)\right)} \\ & & \times q_{dis} \, A_{res} \, gwp_{CH_4}^{n} \, 16/12 \times 0.9 \times 10^{-6} \end{eqnarray}\end{split}\]

where:

• \(q_{CH_4, degassing}^{gross}\) is the unit (per time) gross CH\(_4\) emission via degassing integrated over n=100 years, (g CO\(_{2eq}\) m\(^{-2}\) yr\(^{-1}\))

• \(q_{CH_4, diffusion}^{gross}\) is the unit (per time) gross CH\(_4\) emission via diffusion integrated over n=100 years, (g CO\(_{2eq}\) m\(^{-2}\) yr\(^{-1}\))

• \(k_1^{degas}, k_2^{degas}, k_3^{degas}\) are regression coefficients.

• \(WRT\) is the water residence time in the reservoir, years.

• \(\textrm{gwp}_{CH_4}^{n}\) is methane’s Global Warming Potential over a n year horizon.

• \(16/12\) is a molecular weight ratio between CH\(_4\) and C.

• \(q_{dis}\) is the reservoir discharge flow in m\(^3\)/year.

• \(A_{res}\) is the reservoir surface area in km\(^2\).

Note

Equation 6 in Praire2021, R2=0.68, RMSE=0.81, N=38

Parameters:

time_horizon (int, optional) – Time horizon in years (default: 100).

Returns:

Integrated degassing flux in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

diffusion_flux(year: float, time_horizon: int = 100) → float

Calculate CH\(_4\) emission via diffusion in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) for a given year.

Note

Returns diffusion flux in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) for a given year. Time horizon is used to select the appropriate GWP value. Currently, only the time horizon of 100 years is supported.

Parameters:

• year (float) – Reservoir age in years (after impoundment).

• time_horizon (int, optional) – Time horizon in years (default: 100).

Returns:

Diffusion flux in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

CH\(_4\) diffusion flux equation:

\[\begin{split}\begin{eqnarray} q_{CH_4, diffusion} (t, n)& = & 10^\left( k_1^{diff} + k_2^{diff} \, t + k_3^{diff} \log10\left(\frac{f_{littoral}}{100}\right) + k_4^{diff} T_{eff}^{CH_4} \right) \\ & & \times (365/1000) \, (16/12) \, \textrm{gwp}_{CH_4}^{n} \end{eqnarray}\end{split}\]

where:

• \(q_{CH_4, diffusion}\) is CH\(_4\) emission via diffusion, (g CO\(_{2eq}\) m\(^{-2}\) yr\(^{-1}\))

• \(f_{littoral}\) is a littoral fraction, (\%)

• \(n\) is the time horizon in years use to set GWP value

• \(t\) is the reservoir age (after impoundment) in years

• \(k_1^{diff}, k_2^{diff}, k_3^{diff}, k_4^{diff}\) are regression coefficients.

• \(gwp_{CH_4}^{n}\) is methane’s Global Warming Potential over a n year horizon.

• \(16/12\) is a molecular weight ratio between CH\(_4\) and C.

• \(T_{eff}^{CH_4}\) is the effective temperature for CH\(_4\) in degC.

The value is divided by 1000 in order to convert from mg CO\(_{2e}\) to g CO\(_{2e}\).

Note

Eq. 3 in Praire2021, R2=0.51, RMSE=0.52, N=160

diffusion_flux_int(time_horizon: int = 100) → float

Calculate integrated unit (per year) CH\(_4\) emission via diffusion.

Note

The emission is given in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\). Default time horizon of 100 years is used. The time horizon is required for finding the global warming potential which itself depends on the number of years it’s calculated for.

Parameters:

time_horizon (int, optional) – Time horizon in years (default: 100).

Returns:

Integrated diffusion flux in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

Gross (integrated) unit CH\(_4\) emission via diffusion:

\[\begin{equation} q_{CH_4, diffusion}^{gross} (n) = q_{CH_4, diffusion}(t=1, n) \, \frac{1-10^{(100 \, k_2^{diff})}}{-100\,\ln(10)\,k_2^{diff}} \end{equation}\]

where:

• \(q_{CH_4, diffusion}\) is CH\(_4\) emission via diffusion, (g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\))

• \(q_{CH_4, diffusion}^{gross}\) is the unit (per time) gross CH\(_4\) emission via diffusion integrated over n=100 years, (g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\))

• \(t\) is the reservoir age (after impoundment) in years

• \(k_2^{diff}\) is a regression coefficients.

Note

Eq. 4 in Praire2021.

ebullition_flux(year: int | None = None, time_horizon: int = 100) → float

Calculate CH\(_4\) emission in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) through ebullition (bubbling).

Uses G-Res CH\(_4\) Bubbling Emissions equation to calculate emission for a life-span of n years defined in argument time_horizon.

Note

Currently, assumes life-span of 100 years. Eq. 5 in Praire2021.

Parameters:

• year (int, optional) – Year for which to calculate the emission.

• time_horizon (int, optional) – Time horizon in years (default: 100).

Returns:

CH\(_4\) emission via bubbling in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

CH\(_4\) ebullition flux equation:

\[\begin{split}\begin{eqnarray} q_{CH_4, bubbling} (n) & = & 10^\left( k_1^{ebull} + k_2^{ebull} \, \log_{10} (f_{littoral}/100) + k_3^{ebull} \, irr_{mean} \right) \\ & & \times (365/1000) \, (16/12) \, \textrm{gwp}_{CH_4}^{n} \end{eqnarray}\end{split}\]

where:

• \(q_{CH_4, bubbling}\) is CH\(_4\) emission via bubbling, (g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\))

• \(f_{littoral}\) is a littoral fraction, (\%)

• \(k_1^{ebull}, k_2^{ebull}, k_3^{ebull}\) are regression coefficients.

• \(\textrm{gwp}_{CH_4}^{n}\) is methane’s Global Warming Potential over a 100 year period.

• \(16/12\) is a molecular weight ratio between CH\(_4\) and C.

• \(irr_{mean}\) is reservoir’s cumulative mean horizontal radiance in kWh/m\(^2\)/d.

The value is divided by 1000 in order to convert from mg CO\(_{2e}\) to g CO\(_{2e}\).

Note

Ebullition fluxes are not time-dependent, hence no emission profile is calculated. Regression statistics: n = 46, R2 = 0.26, RMSE = 0.8, Outlier = 3 In case other life-spans are to be investigated, the global warming potential of CH\(_4\) needs to be adjusted to a differnet number of years.

ebullition_flux_int(time_horizon: int = 100) → float

Calculate integrated ebullition flux in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Calls ebullition flux. Since ebullition flux is not time-dependent, average ebullition flux per year is equal to ebullition flux (at any given time).

Parameters:

time_horizon (int, optional) – Time horizon in years (default: 100).

Gross (integrated) CH\(_4\) ebullition flux equation:

\[\begin{equation} q_{CH_4, bubbling}^{gross} (n) = q_{CH_4, bubbling} (t=1, n) \end{equation}\]

Attention

\(q_{CH_4, bubbling}\) is not time-dependent

Returns:

Integrated ebullition flux in g CO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

emission_factor() → float

Calculate CH\(_4\) Emission Factor for Water Bodies in kg CH\(_4\)/ha/yr

factor(number_of_years: int = 100) → float

Return integrated per area CH\(_4\) emission in gCO\(_{2e} m\)^{-2}$ yr\(^{-1}\).

Parameters:

number_of_years (int, optional) – Number of years for integration (default: 100).

Returns:

Integrated CH\(_4\) emission factor in gCO\(_{2e} m\)^{-2}$ yr\(^{-1}\).

Return type:

float

monthly_temp: MonthlyTemperature

pre_impoundment(add_preemission: bool = False) → float

Calculate CH\(_4\) emissions from the inundated area prior to impoundment.

Uses a table of pre-impoundment emissions per land cover category and soil type, in kgCH\(_4\)/ha/yr.

Adds pre-impoundment emission from water bodies prior to impoundment.

Note

Pre-impoundment emissions are subtracted from the total CH\(_4\) emission, comprised of the sum of degassing, ebullition and diffusion emission estimates (as CO\(_2\) equivalents).

Parameters:

add_preemission (bool, optional) – Flag to add pre-impoundment emission from water bodies (default: False).

Returns:

Unit pre-impoundment emission in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

profile(years: Tuple[int, ...] = (1, 5, 10, 20, 30, 40, 50, 100)) → List[float]

Return emission profile of CH\(_4\) in gCO\(_{2e} m\)^{-2}$ yr\(^{-1}\).

Parameters:

years (Tuple[int, ...], optional) – Vector of years for emission profile (default: (1, 5, 10, 20, 30, 40, 50, 100)).

Returns:

List of total CH\(_4\) flux values in gCO\(_{2e} m\)^{-2}$ yr\(^{-1}\) corresponding to the input years.

Return type:

List[float]

total_emission_per_year(number_of_years: int = 100) → float

Calculate total reservoir emission per year in tCO\(_{2e}\) / year.

Parameters:

number_of_years (int, optional) – Number of years for integration (default: 100).

Returns:

Total CH\(_4\) emission per year in tCO\(_{2e}\) / year.

Return type:

float

total_lifetime_emission(number_of_years: int = 100) → float

Calculate total reservoir emission over lifetime in ktCO\(_{2e}\).

Parameters:

number_of_years (int, optional) – Number of years for integration (default: 100).

Returns:

Total CH\(_4\) emission per lifetime in ktCO\(_{2e}\).

Return type:

float

class reemission.emissions.NitrousOxideEmission(catchment: Catchment, reservoir: Reservoir, model: str, p_export_model: str, preinund_area: float | None = None, config_file: Path = PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini'))

Bases: Emission

Class for calculating N\(_2\)0 emissions from reservoirs.

available_models

Tuple of supported N2O emission models.

Type:

ClassVar[Tuple[str, …]]

model

Selected N\(_2\)O emission model (‘model_1’, ‘model_2’).

Type:

str

p_export_model

Model for calculating P export from catchments.

Type:

str

__abstractmethods__ = frozenset({})

__annotations__ = {'available_models': typing.ClassVar[typing.Tuple[str, ...]], 'catchment': 'Catchment', 'config': 'configparser.ConfigParser', 'model': <class 'str'>, 'p_export_model': <class 'str'>, 'preinund_area': 'float', 'reservoir': 'Reservoir'}

__dataclass_fields__ = {'available_models': Field(name='available_models',type=typing.ClassVar[typing.Tuple[str, ...]],default=('model_1', 'model_2'),default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=<dataclasses._MISSING_TYPE object>,_field_type=_FIELD_CLASSVAR), 'catchment': Field(name='catchment',type=<class 'reemission.catchment.Catchment'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'config': Field(name='config',type=<class 'configparser.ConfigParser'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'model': Field(name='model',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'p_export_model': Field(name='p_export_model',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'preinund_area': Field(name='preinund_area',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'reservoir': Field(name='reservoir',type=<class 'reemission.reservoir.Reservoir'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}

__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False)

__eq__(other)

Return self==value.

__hash__ = None

__init__(catchment: Catchment, reservoir: Reservoir, model: str, p_export_model: str, preinund_area: float | None = None, config_file: Path = PosixPath('/home/runner/work/reemission/reemission/src/reemission/config/config.ini')) → None

Initializes a NitrousOxideEmission instance.

Parameters:

• catchment (Catchment) – The catchment area.

• reservoir (Reservoir) – The reservoir.

• model (str) – Selected N\(_2\)O emission model (‘model_1’, ‘model_2’).

• p_export_model (str) – Model for calculating P export from catchments.

• preinund_area (Optional[float], optional) – Pre-inundation area. Defaults to None.

• config_file (pathlib.Path, optional) – Path to configuration file. Defaults to INI_FILE.

__match_args__ = ('catchment', 'reservoir', 'preinund_area', 'config', 'model', 'p_export_model')

__module__ = 'reemission.emissions'

__repr__()

Return repr(self).

_abc_impl = <_abc._abc_data object>

_n2o_denitrification_m1() → float

Calculate N\(_2\)O emission (kgN yr\(^{-1}\)) from denitrification using Model 1

Model 1 formula:

\[\begin{equation} 0.009 * ( \textrm{tn_catchment_load} + \textrm{tn_fixation_load} ) * [0.3833 * \textrm{erf}(0.4723 * \textrm{WRT(yrs)})] \end{equation}\]

Returns:

N\(_2\)O emission from denitrification in kgN yr\(^{-1}\).

Return type:

float

_n2o_denitrification_m2() → float

Calculate N\(_2\)O emission from denitrification in kgN/yr using Model 2.

Returns:

N\(_2\)O emission from denitrification in kgN/yr.

Return type:

float

_n2o_emission_m1_co2() → float

Calculate N\(_2\)O emission in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) according to model 1.

Returns:

N\(_2\)O emission in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

_n2o_emission_m2_co2() → float

Calculate N\(_2\)O emission in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\) according to model 2.

Returns:

N\(_2\)O emission in gCO\(_{2e}\) m\(^{-2}\) yr\(^{-1}\).

Return type:

float

_n2o_emission_m2_n() → float

Calculate total N\(_2\)O emission (kgN yr\(^{-1}\)) using Model 2.

This method calculates the overall N\(_2\)O emissions using an equation that includes mechanisms to account for N\(_2\)O saturation.

Returns:

Total N\(_2\)O emission in kgN yr\(^{-1}\).

Return type:

float

Note

From an overall relation derived from N2O emissions computed as the sum of two EF terms: N2O derived from denitrification, and N2O derived from Nitrification. This approach differs from N2OA above in that the derivation of the equation below included mechanisms to account for N2O saturation state with respect to gaseous emissions (effectively not all N2O produced is assumed to be evaded), and for internal consumption of N2O produced by denitrification, which increases as a function of water residence time.

_n2o_nitrification_m1() → float

Calculate N\(_2\)O emission (kgN yr\(^{-1}\)) from nitrification using Model 1

Model 1 formula:

\[\begin{equation} 0.009 * ( \textrm{tn_catchment_load} + \textrm{tn_fixation_load} ) * [0.5144 * \textrm{erf}(0.3692 * \textrm{WRT(yrs)})] \end{equation}\]

Returns:

N\(_2\)O emission from nitrification in kgN yr\(^{-1}\).

Return type:

float

_n2o_nitrification_m2() → float

Calculate N\(_2\)O emission from nitrification in kgN/yr using Model 2.

Returns:

N\(_2\)O emission from nitrification in kgN/yr.

Return type:

float

_total_to_unit(emission: float) → float

Convert emission from kgN yr\(^{-1}\) to mmolN/m\(^2\)/yr.

Parameters:

emission (float) – Emission in kgN yr\(^{-1}\).

Returns:

Emission in mmolN/m\(^2\)/yr.

Return type:

float

_unit_n2o_emission_m2() → float

Calculate unit total N\(_2\)O emission in mmolN/m\(^2\)/yr using Model 2.

Returns:

Unit N\(_2\)O/yr.

Return type:

float

_unit_to_total(unit_emission: float) → float

Convert emission from mmolN/m\(^2\)/yr to kgN yr\(^{-1}\).

Parameters:

unit_emission (float) – Emission in mmolN/m\(^2\)/yr.

Returns:

Emission in kgN yr\(^{-1}\).

Return type:

float

available_models: ClassVar[Tuple[str, ...]] = ('model_1', 'model_2')

factor(number_of_years: int = 100, mean: bool = False, model: str | None = None) → float

Return N\(_2\)O emission in gCO\(_{2e}\)/m\(^2\)/yr.

N\(_2\)O emissions are not calculated over a defined time horizon as e.g. CO2. Thus, the time horizon for N\(_2\)O is given the number of the beast.

Parameters:

• number_of_years (int, optional) – Number of years for emission calculation. Defaults to 666.

• mean (bool, optional) – Whether to calculate the mean emission. Defaults to False.

• model (Optional[str], optional) – Specific model to use. Defaults to None.

Returns:

N\(_2\)O emission in gCO\(_{2e}\)/m\(^2\)/yr.

Return type:

float

model: str

nitrogen_downstream_conc() → float

Calculate downstream TN concentration in mgN/L (gN/m\(^3\)).

Returns:

Downstream TN concentration in mgN/L (gN/m\(^3\)).

Return type:

float

nitrogen_downstream_load() → float

Calculate downstream TN load in kgN/yr.

Returns:

Downstream TN load in kgN/yr.

Return type:

float

p_export_model: str

profile(years: Tuple[int] = (1, 5, 10, 20, 30, 40, 50, 100)) → List[float]

Return N\(_2\)O emission profile for the years defined in parameter years.

Note

Only done for the purpose of keeping consistency with other emissions, since N\(_2\)O does not have an emission profile. Thus, the returned profile is a straight line with values equal to the N\(_2\)O emission factor.

Parameters:

years (Tuple[int], optional) – Years for the emission profile. Defaults to (1, 5, 10, 20, 30, 40, 50, 100).

Returns:

N\(_2\)O emission profile for the specified years.

Return type:

List[float]

tn_fixation_load() → float

Total N internal fixation load following the method in Maarva et al (2018).

Total N fixation depends on water residence time in the reservoir and molar TN:TP stoichiometry. It is formulated as the % of the riverine inflow TN load using the following formula:

Total N fixation load [%]:

\[\begin{equation} L_{TN,fix} = \mu \, \left[ \frac{37.2}{1 + \exp(0.5 * {TN/TP} \, - 6.877)} \right] \end{equation}\]

where:

\[\begin{equation} \mu = \textrm{erf} ((WRT - 0.028) / 0.04) \end{equation}\]

with residence_time (WRT) given in years

Note

To account for uncertainties in the total N fixation load estimates, a normal distribution with standard deviation of +/-10% was assumed around the predicted total N fixation load values (Akbarzahdeh 2019)

total_emission_per_year(number_of_years: int = 100) → float

Calculate total reservoir emission per year in tCO\(_{2e}\)/year.

Parameters:

number_of_years (int, optional) – Number of years for emission calculation. Defaults to 100.

Returns:

Total reservoir emission per year in tCO\(_{2e}\)/year.

Return type:

float

total_lifetime_emission(number_of_years: int = 100) → float

Calculate total reservoir emission per lifetime in ktCO\(_{2e}\).

Parameters:

number_of_years (int, optional) – Number of years for emission calculation. Defaults to 100.

Returns:

Total reservoir emission per lifetime in ktCO\(_{2e}\).

Return type:

float

reemission.emissions.check_preimpoundment_area(preimp_area: float, reservoir_area: float, reservoir_name: str) → None

Checks if the pre-impoundment area is larger than the reservoir area and logs a warning if it is.

Parameters:

• preimp_area (float) – The pre-impoundment area of the reservoir in square units.

• reservoir_area (float) – The current area of the reservoir in square units.

• reservoir_name (str) – The name of the reservoir.

Returns:

None

Logs:

Warning message if the pre-impoundment area is larger than the reservoir area.