Straßenverkehr (1A3b)

Bemerkung

This project and docupage is under active development!

Für den Straßenverkehr in TREMOD werden die Fahrzeugbestände, Fahr- und Verkehrsleistungen, sowie der Energiebedarf und die Emissionen aller in Deutschland betriebenen motorisierten Verkehrsmittel des Straßenverkehrs jährlich erfasst. Die Ergebnisse liegen für den Zeitraum ab 1950 bis 2050 für Deutschland insgesamt (bzw. bis 1993 unterteilt für Ost- und Westdeutschland) vor. TREMOD bildet das Inlandsprinzip (Verkehre auf deutschem Territorium) und das Energiebilanzprinzip (in Deutschland für den Straßenverkehr abgesetzte Energiemengen) ab.

Hinweis: Die nachfolgende Dokumentation fokussiert auf die Modelllogik von TREMOD. Weitere Informationen zu den Datenquellen, Annahmen und Ergebnissen und Berechnungsmethoden werden in den veröffentlichen TREMOD-Berichten für das UBA dokumentiert.

Aktuelle Version: 7.01 (Arbeitsversion)

1. Methodik

Der Energieverbrauch und die Emissionen pro Jahr werden bottom berechnet und können anschließend differenziert oder in aggregierter Form in TREMOD abgefragt werden. Die Berechnung erfolgt in den Modulen stock (Bestände), mileage (Fahr- und Verkehrsleistung) und emissions (Energieverbrauchs- und Emissionsfaktoren) statt, siehe Abbildung.

Schema Emissionsberechnung Straßenverkehr

TREMOD verwendet verschiedene Definitionen für Fahrzeugmerkmale, von der Fahrzeugkategorie (oberste Ebende) bis hin zur Fahrzeugschicht (differenzierteste Ebene). Dazwischen existieren weitere Ebenen, z.B. Segment ( Fahrzeugkategorie + Größenklasse + Antrieb) oder Konzept (Fahrzeugkategorie + Antrieb + Emissionsstandard). Folgende Tabelle stellt diese am Beispiel Lkw dar.

Fahrzeugdefinitionen

Defintion	Abkürzung	Beispiel
Fahrzeugkategorie	Fzkat	Lkw
Größenklasse	GK	12–14t (zGG)
Antrieb	Antr	Diesel
Segment	Segm	RigidTruck >12-14t (Diesel)
Baujahr	BJ	2010
Emissionsstandards	ES	Euro-V
Attribut	Attr	SCR, DPF
Fahrzeugschicht	FS	RT >12-14t Euro-V SCR
Konzept	Konz	HDV diesel Euro-5 SCR (DPF)

Abkürzungen: SCR: Selektive Catalytic Reduktion, EGR: Exhaust Gas Recirculation, zGG: zulässiges Gesamtgewicht

TREMOD verwendet eine Vielzahl an verschiedenen Eingangsdaten. Ein Teil der Eingangsdaten wird standardmäßig für die Fortschreibung des Inventars und des Trendszenarios aktualisiert, andere Eingangsdaten können bei Bedarf, z.B. im Fall von methodischen Weiterentwicklungen aktualisiert werden. Folgende Tabelle gibt hierzu eine Übersicht.

Übersicht Eingangsdaten Straße und Aktualisierungsturnus

Modul	Jährlich (Inventar + Trendszenario)	Bei Bedarf
Allgemein	Energiebilanzdaten, Anteil Biokraftstoffe	Heizwerte, Dichten
Bestand	Realbestände KBA, Bestände Mopeds und Pedelces, Neuzulassungen (NZL), NZL-Anteil Segment, NZL-Anteil Emissionsstandard	Anteil EGR/SCR, Anteil Partikelfilter, Anteil High-Emitter, Anteil Softwareupdates
Fahrleistung	Fahrleistungen pro Fahrzeugkategorie, Anteil Straßenkategorie	Fahrleistungsgewichtung Segment, Fahrleistungsgewichtung Alter
Verkehrsleistung	Verkehrsleistungen pro Verkehrsart	Auslastungsgrade Segment
Emissionen	CO2-Intensität Kraftstoffe, jährliche Effizienzverbesserung	Emissionsfaktoren HBEFA

In den folgenden Abschnitten zur Berechnung wird auf die jeweiligen Eingangsdaten vertieft eingegangen.

1.1 Bestände

Im Bestands-Modul werden die Realbestände des KBA um zusätzliche Merkmale der Emissionsberechnung (z.B. Abgasnachbehandlung) erweitert und auf Basis von jährlichen Neuzulassungen und Überlebenskurven für das Trendszenarios bis 2050 fortgeschrieben. Ergebnis ist der Fahrzeugbestand nach Fahrzeugschicht für die Bezugsjahre 1950 bis 2050.

Der Realbestand wird aus einer Sonderauswertung des Kraftfahrtbundesamtes (KBA) ermittelt. Diese umfasst den Bestand zum 1.1. des Jahres für Deutschland insgesamt nach verschiedenen Merkmalen, z.B. Fahrzeugkategorie, Antrieb, Größenklasse (z.B. zul. Gesamtgewicht) Erstzulassungsjahr, Emissionsklasse.

Die Anfrage wird per E-Mail an fahrzeugstatistik@kba.de gestellt und erfolgt im Rahmen der Amtshilfe. Die Daten müssen vor der Verwendung in TREMOD aufbereitet werden:

• Berechnung des Bestandes zur Jahresmitte aus dem Bestand zum 1.1. des Bezugsjahres und dem 1.1. des Folgejahres zur Ableitung eines repräsentativen Fahrzeugbestandes für das ganze Bezugsjahr (Im Gegensatz zu einem Bestand zu einem Stichtag, z.B. 1.7. werden somit auch ungleiche Änderungen innerhalb der 1. und 2. Jahreshälfte erfasst. Beispielsweise wurden Elektro-Pkw bisher stärker gegen Jahresende zugelassen)

• Neuzuordnung der Fahrzeugkategorien, z.B. „Lastkraftwagen“ in LNF (3,5 t zGG) und LKW (>= 3,5 t zGG)

• Neuzuordnung nicht verwendeter Antriebsarten, z.B. „Vielstoff“ zu „Diesel“

• Zusammenfassung von Fahrzeugen mit einem Alter von mehr als 60 Jahren zu 60 Jahren.

• Zuordnung der Emissionsstandards über die Emissionsklasse und das Erstzulassungsjahr inklusive Neuzuordnung unplausibler Emissionsstandards, z.B. Euro 1 Baujahr 2010 zu Euro 5.

Anschließend wird in TREMOD der Bestand nach Fahrzeugkategorie, Antrieb, Erstzulassungsjahr und Emissionsstandard um weitere Attribute ergänzt:

• Anteil Partikelfilter Diesel-Pkw und Busse je Baujahr

• Anteil EGR und SCR bei Bussen und schweren Nutzfahrzeugen mit Euro IV und V

• Anteil Euro 5- und Euro 6 Diesel-Pkw mit Softwareupdates je Bezugsjahr

• Anteil High-Emitters für Busse und schweren Nutzfahrzeuge mit Euro V, VI und 7

Die Berechnung erfolgt multiplikativ mit den jeweiligen Anteilen zum Fahrzeugbestand.

Für das Trendszenario werden jährlichen Neuzulassungen nach Fahrzeugschicht und die Überlebenskurven benötigt. Die jährlichen Neuzulassungen berechnen sich aus aus dem Produkt folgender Werte:

• AbsolutenNeuzulassungen je Fahrzeugkategorie

• Anteil Segmente je Fahrzeugkategorie

• Anteil Emissionsstandards je Segment und Zulassungsjahr

Die Neuzulassungen und Neuzulassungsanteile werden auf Basis von Annahmen, z.B. Erfüllung der CO2-Flottenzielwerte und Schadstoffemissionsgrenzwerte festgelegt.

Die Überlebenskurven beschreiben das Verhältnis der neuzugelassenen Fahrzeuge zum verbleibenden Bestand für das Fahrzeugalter von 0-60 Jahre. Für die Fortschreibung wird das Verhältnis des verbleibenden Bestands des jeweiligen Bezugsjahres zum Vorjahr berechnet, damit auch der Bestand der Fahrzeuge im Realbestand fortschrieben werden kann.

Ablaufdiagramm Bestandsberechnung

Abkürzungen: Fzkat: Fahrzeugkategorie, Segm: Segment, ES: Emissionsstandard, BJ: Baujahr, FS: Fahrzeugschicht, SCR: Selektive Catalytic Reduktion, EGR: Exhaust Gas Recirculation, DPF: Diesel Particle Filter, Trend: Trendszenario

1.2 Fahrleistungen

Im Fahrleistungsmodul werden jährliche Fahr- und Verkehrsleistungen je nach Fahrzeugschicht, Baujahr, Energie und Straßenkategorie sowie die mittlere kumulierte (Lebens-)Fahrleistung je Fahrzeugsegment (Größenklasse und Antrieb) berechnet.

Für die Fahrleistungen werden zunächst die Gesamtfahrleistungen je Fahrzeugkategorie und Bezugsjahr auf die Straßenkategorien aufgeteilt. Die Eingangsdaten für Realjahre werden aus verschiedenen Erhebungen, z.B. der Bundesanstalt für Straßenwesen (BASt), dem Kraftfahrtbundesamt (KBA), dem Bundesamt für Logistik und Mobilität (BALM) oder dem statistischen Bundesamt (DESTATIS) zusammengestellt und für TREMOD aufbereitet. Die Ergebnisse werden soweit möglich mit der Erhebung Verkehr in Zahlen (VIZ) des Bundesministeriums für Verkehr (BMV) abgeglichen. Hierbei ist jedoch zu erwähnen, dass TREMOD die Inlandsfahrleistungen und VIZ die Inländerfahrleistungen ausweist.

Anschließend erfolgt auf Basis der Bestandsanteile und von Gewichtungsfaktoren nach Segment und Alter die Berechnung der Fahrleistung pro Straßenkategorie, Fahrzeugschicht, Baujahr und Energieart. Die Eingangsdaten für die Gewichtungsfaktoren stammen aus verschiedenen Quellen, z.B. der Fahrleistungserhebung der BASt. Weitere Informationen sind in den jeweils aktuellen TREMOD-Berichten dokumentiert.

Ablaufdiagramm Fahrleistungsberechnung

Abkürzungen: Fzkat: Fahrzeugkategorie, Segm: Segment, ES: Emissionsstandard, BJ: Baujahr, FS: Fahrzeugschicht, SK: Straßenkategorie, En: Energieart)

Die kumulierten Fahrleistungen werden in zwei Schritten berechnet:

• Berechnung der mittlere Jahresfahrleistungen je Fahrzeugsegment und Baujahr (Fahrleistung dividiert durch Bestand)

• Aufkumulierung der mittleren Jahresfahrleistungen seit der Erstzulassung

Die Verkehrsleistungen werden mithilfe der spezifischen Kapazität je Segment (z.B. Zuladung in Tonnen oder Sitzplätze) und mittleren Auslastungsgraden zunächst bottom-up berechnet. Anschließend werden die Auslastungsgrade so kalibriert, dass die vorgegebene Verkehrsleistung je Verkehrsart getroffen wird und die Berechnung erneut durchgeführt.

1.3 Energieverbrauch und Emissionen

Die Berechnung des Energieverbrauchs und der Emissionen basiert auf der Methodik des Handbuch Emissionsfaktoren für den Straßenverkehr (HBEFA). Es wird zwischen Warm (hot)-, Kaltstart (coldstart)- und Verdungstungs(Evaporation)-Emissionen unterschieden, welche unterschiedliche Aktivitätsdaten und Emissionsfaktoren verwenden. Detaillierte Informationen zum HBEFA finden sich unter www.hbefa.net.

Die Warmemissionen (warm emissions) werden pro Fahrzeugschicht, Baujahr, Energieart und Straßenkategorie berechnet. Hierbei werden die Emissionsfaktoren pro Kilometer mit der Fahrleistung verknüpft. Die Einheit der Emissionen wird in den folgenden Formeln beispielhaft in g angegeben, kann aber je nach Schadstoff variieren, z.B. MJ für Energieverbrauch, # für Partikelanzahl.

Warmemissionen (g/km) = Fahrleistung (km) x Basisemissionsfaktor (g/km)

Differenzierung: Fahrzeugschicht, Energieart, Straßenkategorie, Schadstoff. Anmerkung: mit Basisemissionsfaktor sind hier die ungewichteten Emissionsfaktoren je Fahrzeugschicht (im HBEFA „Subsegment“) gemeint. Diese beziehen sich z.B. auf eine kumulierte Fahrleistung von 50.000 km.

Anschließend werden auf die Basisemissionsfaktoren je nach Fahrzeugkategorie und Schadstoff verschiedene Korrekturfaktoren angewendet. Folgende Tabelle gibt hierzu einen Überblick:

Einflussfaktoren und Parameter

Faktor	Abhängige Parameter	Schadstoffe	Fahrzeugkategorie	Anwendung zum Basisemissionsfaktor
Energieeffizienz	Baujahr	EC	alle	multiplikativ
Verschlechterungsfaktor	kumulierte Fahrleistung	HC, CO, NOx, PM10-ex, CH4, N2O, NH3, N2O	Pkw, LNF, Lkw, LZ, SZ, LBus, ÜeKfzl, Üekfzs, FlBus, SRbus	additiv
Auslastungskorrektur	mittlere Beladung	alle	Lkw, LZ, SZ, LBus, Üekfzs, FlBus, SRbus	lineare interpolation (0%,50%,100% Beladung)
Kraftstoffqualität	Bezugsjahr	HC, CO, NOx, PM10-ex	alle	multiplikativ

Die Berechnung der N2O und NH3 Emissionen wird wie im HBEFA gemäß der Methode des COPERT-Modells nachgebildet und berücksichtigt zusätzlich den Schwefelgehalt im Kraftstoff.

Die Kaltstartemissionen berechnen sich aus der Anzahl der Kaltstarts und den mittleren Emissionsfaktoren pro Start je Fahrzeugschicht. Die Anzahl der Starts wird aus der Fahrleistung und der mittleren Wegelänge je Fahrzeugkategorie/-Segment berechnet.

Kaltstartemissionen/Energieverbrauch (g) = Anzahl starts (-) x Emissionsfaktor (g/Start)

Differenzierung: Fahrzeugschicht, Energieart, Schadstoff

Die Verdunstungsemissionen berechnen sich je nach Art der Verdunstung aus dem Bestand (soak emissions), der Fahrleistung (running losses) und der Anzahl Starts (diurnal). Anm: Verdunstungsemissionen treten nur für Nicht-Methan-Kohlenwasserstoffe (NMHC) und deren Komponenten auf. Der Energieverbrauch und sonstige Schadstoffe sind nicht betroffen.

Abstellemissionen (g) = Anzahl stopps (-) x Emissionsfaktor (g/Stopp)

Differenzierung: Fahrzeugschicht, Energieart, Schadstoff

(Die Anzahl der Stops wird gleich der Anzahl der Starts angenommen, siehe Kaltstartemissionen).

Tankatmung (g) = Anzahl Fahrzeuge (-) x 365 (d) x Emissionsfaktor (g/Fahrzeug/d)

Differenzierung: Fahrzeugschicht, Energieart, Schadstoff

Running Losses (g) = Fahrleistung (km) x Emissionsfaktor (g/km)

Differenzierung: Fahrzeugschicht, Energieart, Straßenkategorie, Schadstoff

Zusätzlich finden folgende Schritte für abgeleitete Emissionen statt:

• die Aufteilung aller Emissionen nach fossilen und Biokraftstoffen

• die Berechnung der kraftstoffverbrauchsabhängigen Emissionen (CO2, SO2, Pb)

• Berechnung der Emissionen von HC-Komponenten (z.B. CH4, NMHC)

• Berechnung von NO2-Emissionen aus den NOx-Emissionen

• Berechnung von CO2-Äquivalenten

• Berechnung von Black-Carbon Emissionen

Die Aufteilung in fossile und Biokraftstoffe erfolgt über die Anteilsfaktoren je Energieart und Bezugsjahr. Sie wird für alle Größen (Fahrleistungen, Energieverbrauch, Emissionen) durchgeführt. Die Eingangsdaten für die Biokraftstoffanteile stammen aus der amtlichen Mineralölstatistik (AMS) des BAFA. Im Trendszenario werden Annahmen zum Biokraftstoffeinsatz, z.B. zur Einhaltung gesetzlicher Quoten, getroffen.

Emissionen_Energie (g) = Emissionen_Energie_Bezug (g) x Anteil_Energie/Energie_Bezug (%)

Differenzierung: Bezugsjahr, Energieart, Verkehrsträger

Die CO2-Emissionen werden mithilfe des Energieverbrauchs und spezifischer CO2-Emissionsfaktoren (kg/TJ) je Energieart berechnet. Die Emissionsfaktoren werden jährlich vom Umweltbundesamt aktualisiert und für TREMOD zur Verfügung gestellt. Die Werte für SO2 und Pb sind in den TREMOD-Berichten beschrieben. Die folgende Formel veranschaulicht die Berechnung am Beispiel CO2.

CO2-Emissionen (kg) = Energieverbrauch (TJ) x Emissionsfaktor (kg/TJ)

Differenzierung: Bezugsjahr, Energieart, Verkehrsträger

Die Schadstoffe CH4, NMHC, Benzol, Toluol, Xylol werden als Anteile von HC, welche mit den HC-Emissionen multipliziert werden berechnet. Die HC-Anteile stammen aus dem HBEFA. Die folgende Formel veranschaulicht die Berechnung am Beispiel CH4.

CH4-Emissionen (g) = HC-Emissionen (g) x Anteil CH4/HC (%)

Differenzierung: Konzept, Emissionsart

Die NO2-Emissionen werden als Anteile von NOx, welche mit den NOx-Emissionen multipliziert werden, berechnet. Die NO2-Anteile stammen aus dem HBEFA.

NO2-Emissionen (g) = NOx-Emissionen (g) x Anteil NO2/NOx (%)

Differenzierung: Konzept, kumulierte Fahrleistung, Straßenkategorie

1.4 Energiebilanzkorrektur und ZSE-Ausgabe

TREMOD berechnet die Energieverbräuche des Verkehrs bottom-up auf Grundlage von Beständen, Fahrleistungen und spezifischen Emissionsfaktoren. Für die Berichterstattung des Umweltbundesamtes sind jedoch die offiziell gemeldeten Kraftstoffabsätze im Verkehr relevant, welche jährlich von der Arbeitsgemeinschaft Energiebilanzen (AGEB) erstellt werden. Daher wird in TREMOD eine Energiebilanzkorrektur durchgeführt. Diese erfolgt in Form von Korrekturfaktoren, welche auf den Energieverbrauch und die Emissionen angewendet werden. Bestände und Fahrleistungen werden nicht korrigiert. Folgende Formel veranschaulicht die Berechnung am Beispiel des Benzinverbrauchs.

Benzinverbrauch_korrigiert (MJ) = Benzinverbrauch (MJ) x Korrekturfaktor (-)

Differenzierung: Verkehrsträger, Fahrzeugkategorie, Energieart, Bezugsjahr

Für die Unterscheidung nach Fahrzeugkategorie und Energieart wird wie folgt vorgegangen:

• Die Korrekturfaktoren für Benzin-Pkw, Benzin-LNF und MZR werden direkt aus dem Verhältnis des Benzinabsatzes laut Energiebilanz zum berechneten Benzinverbrauch für alle Fahrzeugkategorien in TREMOD berechnet.

• Die Korrekturfaktoren für Diesel-Pkw und Diesel-LNF werden von Benzin-Pkw und Benzin-LNF übernommen.

• Die Korrekturfaktoren für SNF und Busse werden aus der Restmenge des Dieselabsatzes (Dieselabsatz ingesamt - Dieselabsatz Pkw+LNF) im Verhältnis zum berechneten Dieselverbrauch der SNF und Busse berechnet.

• Für alle sonstigen Energiearten werden die Korrekturfaktoren über das Verhältnis von Absatz zu Verbrauch ermittelt, unabhängig von der Fahrzeugkategorie.

• Falls keine Energiebilanzdaten für eine Energieart vorliegen oder diese für die Berichterstattung nicht relevant sind, wird als Korrekturfaktor 1 verwendet

Die hierbei berechneten Korrekturfaktoren werden auch für die Emissionen angewendet.

Die korrigierten Energieverbrauchsdaten bilden auch die Grundlage für die nationale Berichterstattung im zentralen System Emissionen (ZSE). TREMOD verfügt hierzu über eine eigene ZSE-Schnittstelle für den Verkehr.

Das ZSE unterscheidet im Straßenverkehr nach Fahrzeugkategorie, Kraftstoffart, Emissionsstandard, Emissionsart, Straßenkategorie und Bezugsjahr. Dabei wird jedoch eine aggregierte Datenform und eine eigene Nomenklatur verwendet, welche in entsprechenden Zuordnungstabellen hinterlegt ist. Auch wird nur ein Teil der in TREMOD verfügbaren Schadstoffe für das ZSE berichtet.

Das ZSE beinhaltet folgende Kenngrößen:

• Aktivitätsrate: für direkte Emissionen in Terajoule (TJ), für Verdunstungsemissionen in Tonnen (t) Kraftstoff

• Emissionsfaktoren: für direkte Emissionen in kg/TJ, für Verdunstungsemissionen in kg/t Kraftstoff

Die Emissionsfaktoren berechnen sich aus dem Quotient aus den Emissionen und dem Endenergieverbrauch je Bezugsjahr und ZSE-Kategorie.

2. Implementierung

Der Quellcode für sämtliche Abfragen und Berechnungen von TREMOD erfolgt in Python und die Datenhaltung in mehreren PostgreSQL-Datenbanken. Im folgenden werden die Datenschnittstellen, Eingangsdatenformate und Berechnungschritte skizziert.

2.1 Datenschnittstellen

Alle Eingangsdaten und Definitionen sind als Tabellen in der SQL-Datenbank gespeichert und können dort verändert werden, z.B. für jährliche Updates. Sie werden über das Modul tableoperations aufgerufen und in die Berechnungen für TREMOD-Road integriert. Der Name der Datenbank setzt sich aus „tremod_road“ + „Versionsnummer“ zusammen.

Alle verwendeten Tabellen werden im Modul tableoperations.py und der Klasse PersistanceLayer aufgelistet. Sie beinhaltet folgende Methoden, welche im folgenden genauer beschrieben werden:

get_common

get_definitions

get_stock_data

get_milage_data

get_emission_factors

Die Methoden get_results und write_to_db dienen dem Lesen und Schreiben der Ergebnisse zu Bestand, Fahr- und Verkehrsleistung und Emissionen in die Datenbank.

2.2 Eingangsdaten

Die aktuellen Datenquellen sind in den UBA-Berichten zur TREMODD-Aktualisierung dokumentiert. Daher wird nur auf die wichtigsten Tabellen eingegangen, welche im Rahmen der jährlichen Updates angepasst werden.

Common data

Tabellen:

Energiebilanz

Spaltenname	Datentyp	Beschreibung
idland	integer	siehe tg_land
bezugsjahr	integer	Bezugsjahr
idenergy	integer	siehe tg_energie
idvtr	integer	siehe tg_vtraeger
menge	double precision	Energieabsatz in t
tj	double precision	Energieabsatz in TJ
com_enbil	text	Kommentar/Quelle
heizwert	double precision	Heizwert in MJ/kg
dichte	double precision	Dichte in kg/l bzw. kg/m³

Kraftstoffbezogene Emissionsfaktoren, tank-to-wheel

Spaltenname	Datentyp	Beschreibung
idland	integer	siehe tg_land
idvtr	integer	siehe tg_vtraeger
idss	integer	Schadstoff
jahr	bigint	Bezugsjahr
idenergy	integer	siehe tg_energie
efaspez	double precision	Emissionsfaktor g/kg
efaspez_tj	double precision	Emissionsfaktor kg/TJ
ppm	double precision	Schwefelanteil Kraftstoff in ppm
com	text	Kommentar

Biokraftstoffanteile

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
bezugsjahr	integer	Bezugsjahr
idenergy	integer	siehe tg_energie
idenergy_bezug	integer	siehe tg_energie
anteil	real	Anteil in % (energetisch)
idvtr	integer	Verkehrsträger (Straße, Schiene, Binnenschiff, Luft)

Defintions

Tabellen:

Schadstoffe (tg_ss)

Spaltenname	Datentyp	Beschreibung
idss	integer
ss	text
com_ss	text
ss_en	text
com_ss_en	text
res_unit	text

Verkehrsarten (tg_verkehrsart)

Spaltenname	Datentyp	Beschreibung
idverkehrsart	integer
verkehrsart	text
com_verkehrsart	text

Energiearten (tg_energie)

Spaltenname	Datentyp	Beschreibung
idenergy	integer	ID Energieart
energie	text	Energieart kurz
dichte	double precision	Dichte in kg/m³
com_energie	text	Energieart lang_en
corinair_encode	text	aktuell nicht benötigt
heizwert	double precision	aktuell nicht benötigt
aktivenbil	boolean	aktuell nicht benötigt
energie_elcd	text	Energieart kurz_dt
energie_ges	text	Energieart Bezug (Biokrafstoffe inkl.)
idenergy_bezug	integer	ID Energieart_Bezug

Straßenkategorien (tg_sk)

Spaltenname	Datentyp	Beschreibung
idsk	integer	ID Straßenkategorie
sk	text	Straßenkategorie_kurz_dt
com_sk	text	Straßenkategorie_lang_dt
aktiv_segment	boolean	aktuell nicht benötigt
sk_dtch	text	aktuell nicht benötigt
com_sk_dtch	text	aktuell nicht benötigt
sk_dtbrd	double precision	aktuell nicht benötigt
com_sk_dtbrd	double precision	aktuell nicht benötigt
sk_en	text	Straßenkategorie_kurz_en
com_sk_en	double precision	aktuell nicht benötigt
sk_fr	double precision	aktuell nicht benötigt
com_sk_fr	double precision	aktuell nicht benötigt
sk_it	double precision	aktuell nicht benötigt
com_sk_it	double precision	aktuell nicht benötigt

Straßentypen (tg_strtyp)

Spaltenname	Datentyp	Beschreibung
idstrtyp	integer	ID Straßentyp
strtyp	text	Straßentyp_kurz_dt
com_strtyp	text	Straßentyp_lang_dt
sk_elcd	text	aktuell nicht benötigt
idvsav	integer	aktuell nicht benötigt

Fahrzeugkategorien (tg_fzkat)

Spaltenname	Datentyp	Beschreibung
idfzkat	integer	ID Fahrzeugkategorie
fzkat	text	Fahrzeugkategorie_kurz_dt
com_fzkat	text	Fahrzeugkategorie_lang_dt
realstock	boolean	Vorkommen in Realbestand ja/nein
modelstock	boolean	Vorkommen in Modelbestand ja/nein
selected	boolean	aktuell nicht benötigt
aktiviert	boolean	aktuell nicht benötigt
aktiv_fs	boolean	aktuell nicht benötigt
idfzkat_hb	integer	Zuordnung Fahrzeugkategorie HBEFA
idftyp	integer	ID Fahrzeugtyp (1 leichte Motorwagen, 2 schwere Motorwagen, 3 mot. Zweiräder)
idfzklasse	integer	aktuell nicht benötigt
idfzkat_buwal/emis	integer	aktuell nicht benötigt
idpg	integer	aktuell nicht benötigt
idvtr	integer	siehe tg_vtraeger
idpriöff	integer	aktuell nicht benötigt
idverkehrsart	integer	siehe tg_verkehrsart
fzkat_dtch	text	aktuell nicht benötigt
com_fzkat_dtch	text	aktuell nicht benötigt
fzkat_dtbrd	double precision	aktuell nicht benötigt
com_fzkat_dtbrd	text	aktuell nicht benötigt
fzkat_en	text	Fahrzeugkategorie_kurz_en
com_fzkat_en	double precision	Fahrzeugkategorie_lang_en
fzkat_fr	double precision	aktuell nicht benötigt
com_fzkat_fr	double precision	aktuell nicht benötigt
fzkat_it	double precision	aktuell nicht benötigt
com_fzkat_it	double precision	aktuell nicht benötigt
aktiviert_ch	boolean	aktuell nicht benötigt
aktiviert_brd	boolean	aktuell nicht benötigt
aktiviert_a	boolean	aktuell nicht benötigt
fzkat_elcd	text	aktuell nicht benötigt

Segmente (tb_fzkat_segm)

Spaltenname	Datentyp	Beschreibung
idfzkat	integer	siehe tg_fzkat
segment	bigint	ID Segment
idgk	integer	siehe tg_gk
idantrieb	integer	siehe tg_antrieb
segmentname	text	Segment_en
idfzkat_hb	integer	ID Fahrzeugkategorie HBEFA
idsegment_hb	integer	ID Segment HBEFA aktuell
idsegment_hb3	integer	ID Segment HBEFA 3
idsegment_hb4	integer	ID Segment HBEFA 4
aktiv	boolean	aktuell nicht benötigt
aktivbezugsjahr	boolean	aktuell nicht benötigt
idaufbau	integer	aktuell nicht benötigt
segmentgruppe	bigint	aktuell nicht benötigt
idenergy	integer	siehe tg_energie
idgk_vav	integer	aktuell nicht benötigt
idantrieb_vav	integer	aktuell nicht benötigt

Emissionsstandards (tg_es)

Spaltenname	Datentyp	Beschreibung
ides	integer	ID Emissionsstandard
es	text	Emissionsstandard_kurz_en
com_es	text	Emissionsstandard_lang_en
aktiv	boolean	Verwendet ja/nein
ides_alt	integer	aktuell nicht benötigt
idemconc	integer	aktuell nicht benötigt
idvehcat	integer	aktuell nicht benötigt
ides_vav	integer	aktuell nicht benötigt

Stock

Tabellen:

btb_bestand_real

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
idfzkat	integer	siehe tg_fzkat
bezugsjahr	bigint	Bezugsjahr
baujahr	integer	Baujahr
segment	bigint	siehe tb_fzkat_segm
ides	integer	siehe tg_es
bestand	double precision	Bestand (Mittelwert 1.1. Bezusjahr und 1.1. Folgejahr)

btb_neuzulassungen

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
idfzkat	integer	siehe tg_fzkat
baujahr	integer	Baujahr
neuzulassungen	integer	Anzahl Neuzulassungen bis Jahresende
recordowner	character varying	aktuell nicht benötigt

btb_neuzul_anteile

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
idfzkat	integer	siehe tg_fzkat
segment	integer	siehe tb_fzkat_segm
baujahr	integer	Baujahr
anteil	real	Neuzulassungsanteil der Segmente pro Fahrzeugkategorie und Baujahr
idue_kurve	integer	siehe btg_ue_kurven
recordowner	character varying	aktuell nicht benötigt

Mileage

Tabellen:

Verkehrsleistungen

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
bezugsjahr	integer	Bezugsjahr
idverkehrsart	integer	siehe tg_verkehrsart
wert	real	Jährliche Verkehrsleistung in Pkm oder tkm

Gesamtfahrleistungen

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
bezugsjahr	integer	Bezugsjahr
idfzkat	integer	siehe tg_fzkat
fl	real	Jährliche Inlandsfahrleistung in km
com_fl	character varying	Kommentar

Fahrleistungsanteile Straßentyp

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
idstrtyp	integer	siehe tg_strtyp
bezugsjahr	integer	Bezugsjahr
idfzkat	integer	siehe tg_fzkat
flant	real	Fahrleistungsanteil der Straßentypen pro Fahrzeugkategorie und Jahr
idvs_kurve	integer	siehe tg_vs_kurve

Emissions

Tabellen:

Hinweis: Erläuterungen zu den Spalten sind im HBEFA bzw. inder HBEFA-Dokumentation zu finden

Emissionsfaktoren warm

Spaltenname	Datentyp	Beschreibung
reference_year	bigint
country	text
emission_category	text
pollutant	text
traffic_scenario	text
ambient_cond._pattern	text
vehicle_category	text
subsegment	text
idsubsegment	integer
energy	text
aggr._traffic_situation	text
road_category	text
ef_unit	text
v	double precision
v_0%	double precision
v_100%	double precision
efa	double precision
efa_0%	double precision
efa_100%	double precision
cum._mileage	double precision

Emissionsfaktoren Kaltstart

Spaltenname	Datentyp	Beschreibung
reference_year	bigint
country	text
emission_category	text
pollutant	text
traffic_scenario	text
ambient_cond._pattern	text
vehicle_category	text
subsegment	text
idsubsegment	integer
energy	text
road_category	text
ef_unit	text
efa	double precision

Emissionsfaktoren soak

Spaltenname	Datentyp	Beschreibung
reference_year	bigint
country	text
emission_category	text
pollutant	text
traffic_scenario	text
ambient_cond._pattern	text
vehicle_category	text
subsegment	text
idsubsegment	integer
energy	text
road_category	text
ef_unit	text
efa	double precision

Emissionsfaktoren Running losses

Spaltenname	Datentyp	Beschreibung
reference_year	bigint
country	text
emission_category	text
pollutant	text
traffic_scenario	text
ambient_cond._pattern	text
vehicle_category	text
subsegment	text
idsubsegment	integer
energy	text
road_category	text
ef_unit	text
v	bigint
v_0%	text
v_100%	text
efa	double precision
efa_0%	text
efa_100%	text
cum._mileage	bigint

Emissionsfaktoren diurnal

Spaltenname	Datentyp	Beschreibung
reference_year	bigint
country	text
emission_category	text
pollutant	text
traffic_scenario	text
ambient_cond._pattern	text
vehicle_category	text
subsegment	text
idsubsegment	integer
energy	text
road_category	text
ef_unit	text
efa	double precision

Energieeffizienzentwicklung

Spaltenname	Datentyp	Beschreibung
idszenario	integer	siehe btg_szenario
segment	integer	siehe tg_fzkat_segm
baujahr	integer	Baujahr
idss	integer	siehe tg_ss
idsk	integer	siehe tg_sk
fs	integer	siehe tb_fzkat_fs
idfzkat	integer	siehe tg_fzkat
kf	real	Relativer Korrekturfaktor Energieverbrauch bezogen auf den Energieverbrauch pro Baujahr je Fahrzeugschicht im HBEFA
idenergy	integer	siehe tg_energie

2.3 Berechnungen

Im folgenden werden die Berechnungsschritte der Module stock, mileage, emissions und results vereinfacht dargestellt.

Die Module verfügen über verschiedene Klassen (class), welche wiederum verschiedene Methoden beinhalten. Jede Klasse und Methode verfügt über eine Kurzbeschreibung sowie ein Liste der Variablen und Ausgabeparameter.

stock

Code-Beschreibung:

class road.src.stock.Stock(local=False, legacy=True)

Bases: object

Represents a class to handle stock data transformations, merging, and calculations in the context of vehicles.

This class is designed to work with stock data and its associated definitions. It provides methods to prepare and extend stock data by adding extra layers (e.g., vehicles like articulated and solo trucks) and to work with detailed technical attributes such as particulate filters and SCR shares. It ensures data consistency and performs operations necessary for scenario-based stock modeling.

Variablen:

• legacy – Indicates whether the stock data is handled in a legacy format.

• stock_data – Contains the stock data loaded from the persistence layer.

• definitions – Contains the definitions (like subsegments) used in stock-related computations.

• total_stock – Holds the transformed and prepared stock data.

• stock_scen – Represents scenario-specific stock data used for further transformations.

calculate_scenario(base_year=None, end_year=2050)

Analyzes and calculates scenario projections for stock and new registrations. The function uses various datasets including stock data, survival functions, emission standards, and new registrations to compute predicted scenarios for the specified range of years. It operates on base and end years and makes use of survival functions to adjust stock calculations over time. This function assumes behavior as per defined scenarios and integrates new registration shares into yearly stock updates.

Parameter:

• base_year – Integer representing the starting year for calculations. Defaults to the latest year in the stock dataset if not provided.

• end_year – Integer representing the last year for scenario analysis. Defaults to 2050.

Rückgabe:

A DataFrame summarizing computed scenarios that include stock and new registrations adjusted for specified constraints and survival probabilities.

extend_stock_data(idscn_sel=[4], calc_scenario=True, start_year=None, end_year=None)

Prepares and processes technical attributes and stock data to calculate production year and technology-specific shares such as particulate filter, SCR shares, and software-update shares.

The function extends input data, filters by technical attributes, merges with various definitions data, and calculates specific shares affecting stock distribution. It prepares and manipulates stock data for further analysis of production year-specific and technology-specific distributions.

Parameter:

• idscn_sel – select scenario IDs, which have to be calculated. Defaults to None, which means all.

• tbl_tec_attr – DataFrame containing technical attributes including technology types and other identification fields.

• g_subsegment – DataFrame holding segment-specific information with fields for traffic modes and other subsegment details.

• b_particlefilter – DataFrame containing details relevant to particulate filter technologies, production years, and specific segment information.

• start_year – Integer representing the starting year for calculations. Defaults to the latest

• end_year – Integer representing the last year for scenario analysis. Defaults to 2050 or last Scenaario Year in the Dataset.

Rückgabe:

A tuple containing: - DataFrame with updated attributes and particulate filter information. - DataFrame capturing the remaining SCR share attributes missing from the particulate filter dataset.

Verursacht:

KeyError – If any required column(s) are missing in the DataFrames during join or filtering operations.

prepare_stock_data(idscn_sel=None, calc_scenario=True, start_year=None, end_year=None)

Prepare the stock data by adding extra vehicle layer for articulated and solo trucks.

Parameter:

• idscn_sel – select scenario IDs, which have to be calculated. Defaults to None, which means all.

• calc_scenario – whether to calculate scenario-specific stock data. Defaults to True.

• start_year – Integer representing the starting year for calculations. Defaults to the latest

• end_year – Integer representing the last year for scenario analysis. Defaults to 2050 or last Scenario Year in the Dataset.

Rückgabe:

stock with extra vehicle layer

Flow-Chart Module Stock

Mileage

Code-Beschreibung:

class road.src.milage.Milage(local=False, legacy=True)

Bases: object

Handles mileage data processing, providing cumulative statistics, time-series data extraction, and segment-specific mileage calculations.

This class operates on vehicle mileage datasets and associated statistics, leveraging various hierarchical joins and aggregations to derive insights like mileage time-series or cumulative data at different granularity levels.

Variablen:

• legacy – Indicates whether legacy configurations are used.

• local – Determines the locality of the persistence layer storage.

• milage_data – Contains raw mileage data fetched from the persistence layer.

• definitions – Stores definitions used for mileage calculations.

• milage_ts – Stores calculated mileage time-series data.

• milage_segm – Contains segment-level mileage data aggregates.

• milage_cum – Stores cumulative computed mileage statistics.

• milage_fs_ts_en – Enables mileage full-segment time-series calculations.

get_milage_cum(total_stock=None, start_year=None, end_year=None, calc_scenario=True)

Computes cumulative mileage and prepares a table for emission calculations.

This function calculates cumulative mileage data by performing various data aggregation and transformation tasks on raw input datasets. It integrates mileage segment data at temporal and sub-segmental levels, combines them with several derived metrics, aggregates data to compute statistics (e.g., sum, mean, etc.), and sorts it for further analysis. Additionally, it preprocesses data to generate a detailed table for mileage-based emission calculations by incorporating energy shares and default energy subsets.

The function handles missing data, uses default fallback values for some missing attributes, and ensures alignment across various scenarios and years.

Verursacht:

• ValueError – Raised if any unexpected discrepancies occur in the input data/processing.

• KeyError – Raised if required columns or keys are missing from the input datasets.

Rückgabe:

A Pandas DataFrame containing the processed mileage and energy-related data for subsequent emission calculations.

Rückgabetyp:

pandas.DataFrame

get_milage_fs(total_stock=None, start_year=None, end_year=None, calc_scenario=True)

Calculate weighted mileage shares for different scenarios, vehicle categories, segments, and origins based on stock data. The function performs data processing and joins multiple tables to compute the mileage shares, along with age-dependent weights.

This function begins by preparing total stock data, if not provided, and loads several necessary data tables. It calculates weighted mileage shares by combining segment-specific data, origin-specific data, as well as age dependency. Grouped aggregations are applied to calculate mileage shares, validating that the sum of shares per key grouping equals 1. The outcome is stored and returned in milage_segm.

Parameter:

• calc_scenario

• end_year

• start_year

• total_stock (pandas.DataFrame, optional) – Optional. A DataFrame representing stock data to be used in calculations. If None, stock data is prepared internally.

Rückgabe:

A DataFrame containing calculated mileage shares (milage_shares_fs) for various scenarios, vehicle categories, sources, curves, years, and segments, along with associated intermediary calculations.

Rückgabetyp:

pandas.DataFrame

get_milage_ts()

Compiles and returns a time series of milage data by joining multiple datasets.

This function constructs a time series dataset combining various milage-related data sets, including road categories. A sequence of join operations is used to associate key attributes from the datasets, ensuring alignment between scenarios, reference years, and vehicle categories. The processed dataset is stored as an instance variable and returned by the function.

Rückgabe:

The completed time series dataset with combined milage data, including road category information.

Rückgabetyp:

pandas.DataFrame

get_transport_alg(total_stock=None, start_year=None, end_year=None, calc_scenario=True)

Compiles and returns a time series of transport performance data by joining multiple datasets.

This function uses previously calculated mileage data and adds definitions and values. It calculates transport performances (pass-km and ton-km) and checks/updates the load factor (alg). It constructs a time series dataset combining various transport-related data sets. A sequence of join operations is used to associate key attributes from the datasets, ensuring alignment between scenarios, reference years, and vehicle categories. The processed dataset is stored as an instance variable and returned by the function.

Rückgabe:

The completed time series dataset with transport performance and load factor data information.

Rückgabetyp:

pandas.DataFrame

Flow-Chart Module Mileage

emissions

Code-Beschreibung:

class road.src.emissions.RoadEmissions(local=False, legacy=True)

Bases: object

This class calculates emissions of road transport based on input data from the module stock, milage and the emission factors loaded in this module. The calculation steps are largely based on the HBEFA (Handbook Emission Factors for Road Transport) methodology, but have been partially adapted to meet additional TREMOD requirements. The calculation is performed at a disaggregated level, e.g., pollutant, emission type, reference year, vehicle category, sub-segments, year of manufacture, road type, etc. The class is divided into several different methods, the results of which are summarized in merged_results. The methods are described in the following sections. The caclulation is The methodology is based on the HBEFA:

Variablen:

• legacy – Indicates the use of legacy datasets.

• stock_data – Vehicle stock dataset.

• mileage_data – Vehicle mileage dataset.

• em_efac – Emission factors dataset.

• definitions – Supporting definitions for emission modeling.

• num_cores – Number of cores for parallel computation.

• milage – Milage object for calculations.

• efa_akt – Harmonized emission factors for TREMOD use.

bc_emissions()

Calculates black carbon emissions based on predefined shares and

applies necessary transformations to generate updated emission data.

Verursacht:

• KeyError – If expected keys are missing in the self.definitions or bc_shares data structures.

• ValueError – If data alignment issues occur during table join operations.

Rückgabe:

DataFrame containing the black carbon emissions, updated with weighted values based on specific shares and segments.

Rückgabetyp:

pd.DataFrame

biofuelshares()

Calculates and integrates the share of biofuels in the energy mix based on given parameters stored in the instance’s attributes. Filters only relevant biofuels data, performs merging, and adjusts energy values proportional to the biofuel shares.

Verursacht:

KeyError – If required keys are missing during filtering, joining, or renaming operations.

Rückgabe:

Updated DataFrame where the energy values are adjusted to include biofuel shares, and unnecessary intermediate columns are dropped.

Rückgabetyp:

pandas.DataFrame

coldstart_emissions(start_year=None, end_year=None, calc_scenario=True)

Calculate cold start emissions for vehicles based on provided datasets. This method processes emission factors, mileage and trip length data, performs the necessary joins and aggregations, and computes emissions for cold starts.

It uses predefined datasets such as emission factors, subsegment definitions, energy categories, and vehicle categories for the computation. Cold start emissions are calculated for the applicable vehicle categories and scenarios.

The resulting emissions data is stored in the class instance’s result attribute.

Parameter:

• start_year – The starting year for the analysis.

• end_year – The ending year for the analysis.

• calc_scenario – A boolean indicating whether to calculate scenario emissions.

Rückgabe:

A DataFrame containing the calculated cold start emissions for all scenarios, categories, and applicable or available pollutants.

static compare_dtypes(df1, df2)

Compare the data types of two DataFrame objects.

This static method compares the data types of columns in two given DataFrame objects. It returns a dictionary indicating whether each column has matching data types across both DataFrames.

Parameter:

• df1 (DataFrame) – The first DataFrame object to compare.

• df2 (DataFrame) – The second DataFrame object to compare.

Rückgabe:

A dictionary where keys are column names and values are boolean flags indicating if the columns have different data type in both DataFrames.

Rückgabetyp:

dict

convert_input_to_polars()

Converts input data to Polars DataFrame types.

This method iterates over various attributes of the class and converts them into appropriate Polars DataFrame types using the convert_pol_dtypes method. It handles different datasets such as efa_akt, milage.res_transport_alg, milage.milage_fs_ts_en, milage.milage_cum, elements in em_efac, definitions, and common. The conversion process may include specifying target data types and string identifiers for certain segments.

Rückgabe:

None

static convert_pol_dtypes(df_pol: DataFrame, target_dtype: Type[DataType] = UInt32, string_id: str = 'id') → DataFrame

Converts specified columns in a Polars DataFrame to the target data type.

Parameter:

• df_pol (pol.DataFrame) – The input Polars DataFrame.

• target_dtype (Type[pol.DataType]) – The target data type to which the columns should be converted.

• string_id (str) – The prefix of the column names that should be converted. Defaults to „id“.

Rückgabe:

A new Polars DataFrame with specified columns converted to the target data type.

Rückgabetyp:

pol.DataFrame

evap_emissions(start_year=None, end_year=None, calc_scenario=True)

Calculates evaporation emissions including diurnal, soak, and running losses. This method processes vehicle stock, start and milage data and applies emission factors to estimate the emissions generated over specified years.

:param : :type : param start_year: The starting year for the analysis. :param : :type : param end_year: The ending year for the analysis. :param : :type : param calc_scenario: A boolean indicating whether to calculate scenario emissions. :param : and applicable or available pollutants. :type : return: A DataFrame containing the calculated warm emissions for all scenarios, categories,

static fill_missing_cols(df, columns, default_value=0.0, casting=Float64)

Fills missing columns in a Polars DataFrame with a specified default value.

Parameter:

• df (DataFrame) – The input DataFrame to process.

• columns (List[str]) – A list of column names to check and potentially add to the DataFrame.

• default_value (Any) – The default value to assign to newly added columns. Defaults to 0.

Rückgabe:

A new DataFrame with the specified missing columns filled with the default value.

Rückgabetyp:

Polars DataFrame

fuel_derived_emissions()

Calculates and retrieves fuel-derived emissions by applying specific emission factors to the corresponding fuel amounts. This function processes data by merging it with definitions, specific emission factors, and then calculates the resulting emission values. It updates the merged results with the processed data.

Parameter:

self – The instance of the class, used to access its attributes and other methods.

Rückgabe:

DataFrame containing the fuel-derived emissions after processing.

Rückgabetyp:

pandas.DataFrame

get_merged_results(append_tbl=None, biosplit=False, start_year=None, end_year=None, calc_scenario=True)

Merges and processes various emission result tables into a single dataset. This method consolidates warm emissions, cold start emissions, evaporative emissions, and other relevant data based either on initial structures or supplemental tables provided. It ensures correct unit attribution and organizes the data in a predefined structure, enabling compatibility for export and processing in other applications and several dissaminations.

Parameter:

• append_tbl – Additional data in a tabular format to append to the existing merged results. Optional.

• biosplit – Indicator to include biosplit functionality during calculations. Defaults to False.

• start_year – The starting year for the analysis.

• end_year – The ending year for the analysis.

• calc_scenario – A boolean indicating whether to calculate scenario emissions.

Rückgabe:

A DataFrame containing the calculated warm emissions for all scenarios, categories, and applicable or available pollutants.

ghg_emissions()

Calculates CO2-equivalents from CO2 and other greenhouse gases. This function processes data by merging it with definitions, specific emission factors, and then calculates the resulting emission values.

Parameter:

self – The instance of the class, used to access its attributes and other methods.

Rückgabe:

DataFrame containing the ghg emissions after processing.

Rückgabetyp:

pandas.DataFrame

hbefa_prep_warm_em()

Prepares the emission factor data used for warm emissions calculation. This method handles the merging of HBEFA data with relevant definitions, as well as transformations and renaming operations required for further processing in the TREMOD model, e.g. vehicle category, road category, pollutant IDs.

Verursacht:

• KeyError – If expected columns or definitions are missing from the input DataFrame.

• AttributeError – If required instance variables such as self.em_efac or self.definitions are not properly initialized.

Rückgabe:

A DataFrame containing aggregated and processed emission factors, including attributes such as subsegment IDs, traffic situations, technologies, gradients, and velocities, prepared for use in warm emissions calculations.

Rückgabetyp:

pandas.DataFrame

hc_split()

Recalculates HC (Hydrocarbon) emissions components for various vehicle types based on HC shares, differentiating cold, hot, and evaporative emissions. Components for hot emissions and vehicles from Euro 6-d on remain in retained results. The recalculations are conducted based on specific filters and joins applied to the provided datasets.

Rückgabe:

A dataframe containing recalculated HC emissions components.

Rückgabetyp:

pandas.DataFrame

static load_corrections(df: DataFrame) → DataFrame

Processes the input dataframe to calculate a corrected value for „efak_corr_lf“ based on specific conditions applied to the „alg“ column. Required to adjust the hot emission factors from the HBEFA to the average load of the vehicles.

The method divides the dataframe into two subsets based on the value of „alg“. Correction coefficients ‚m‘ and ‚a‘ are computed separately for each subset and are then applied to derive the „efak_corr_lf“ column. Finally, the computed values are combined and the intermediate columns used in the calculation are dropped before returning the dataframe.

Parameter:

df – A DataFrame with required columns: - „alg“ - „efa“ - „efa_0%“ - „efa_100%“

Rückgabe:

A DataFrame with the calculated „efak_corr_lf“ column and the intermediate columns removed.

static milage_det_hdv(mileage, base_kkm, k, v_cycle, d, we_pos, cf_tech, valid_to_milage)

Calculates the correction factor (cf_det) based on input parameters related to mileage, base kilometers (kkm), average cycle velocity, and positive work. This method ensures the correction factor does not exceed an upper limit determined by valid mileage. Needed to adjust the hot emission factors from the HBEFA to the cumulative mileage of the vehicles.

Parameter:

• mileage – Current mileage of the vehicle

• base_kkm – Base distance in kilometers (kkm) used as reference

• k – Scalar factor

• v_cycle – Average cycle velocity

• d – Constant factor

• we_pos – Positive work energy

• cf_tech – Correction factor specific to vehicle technology

• valid_to_milage – Maximum mileage to validate the correction factor calculations

Rückgabe:

Deterioration correction factor (cf_det) considering input parameters

no2_emissions()

Calculate NO2 emissions based on the provided emission factors and mileage data. This method processes emission factors, filters and calculates NO2 emissions for specific vehicle segments and conditions, and then updates the merged results with the generated data.

Verursacht:

KeyError – If required keys are missing in the dataframes being processed.

Rückgabe:

A DataFrame containing NO2 emissions data filtered and calculated according to mileage-based conditions.

Rückgabetyp:

pandas.DataFrame

warm_emissions(start_year=None, end_year=None, calc_scenario=True)

Calculates warm emissions, including correction factors for cumulative mileage, load, fuel quality, and energy consumption efficiency corrections by year of manufacture. This function involves several intermediate calculations and steps to ensure the robustness and accuracy of the final emissions data output. The method begins by ensuring that the required emission factors are loaded or prepared from the HBEFA. It then collects and processes cumulative mileage data, calculates raw emissions, and makes various adjustments based on heavy and light vehicle types. Corrections are made to account for the effects of mileage, fuel quality, and load. Several links to emission factors and definition frameworks are made to supplement, correct, and complete the data set for emission calculation. For N2O and NH3 emissions, as well as HC-diff, hot emissions are taken directly from the HBEFA for vehicles with Euro 6 or newer. For older vehicles, the calculations are replicated in the method.

Parameter:

• start_year – The starting year for the analysis.

• end_year – The ending year for the analysis.

• calc_scenario – A boolean indicating whether to calculate scenario emissions.

Rückgabe:

A DataFrame containing the calculated warm emissions for all scenarios, categories, and applicable or available pollutants.

Flow-Chart Module Emissions

results

Code-Beschreibung:

class road.src.results.TremodDevelVariant(local=False, legacy=False, resultpath=None)

Bases: object

Diese Klasse stellt Methoden zur Berechnung aller Ergebnisse bereit und schreibt diese in die Datenbank u.a. zur Weiterverwendung in der Nutzungsvariante. Zusätzlich sind weitere Ergebnisse oder Auswertungen implementiert.

calc_cse(start_year=None, end_year=None, calc_scenario=True)

Berechnet die Ergebnisse im ZSE-Format indem die ZSE-Nomenklatur hinzugefügt wird, die Daten entsprechend aggregiert werden. Ergebnisse sind Aktivitätraten und Emissionsfaktoren pro Aktvitätsrate.

Parameter:

• start_year – The starting year for the calculation.

• end_year – The ending year for the calculation.

• calc_scenario – A boolean flag indicating whether to calculate the scenario.

Rückgabe:

None

calc_energy_correction(start_year=None, end_year=None, calc_scenario=True)

Berechnet die Korrekturfaktoren zur Umrechnung aller Ergebnisse vom Inlands- auf das Energiebilanzprinzip.

Parameter:

• start_year (int or None) – The starting year for the calculation.

• end_year (int or None) – The ending year for the calculation.

• calc_scenario (bool) – A boolean flag indicating whether to calculate the scenario.

calc_road_emissions(start_year=None, end_year=None, calc_scenario=True, write_to_db=True)

Dient dem Berechnen aller Ergebnisse und schreiben in die Ergebnistabelle. Die Methoden der Klasse RoadEmissions des Moduls emissions.py werden hierfür verwendet.

Parameter:

• start_year (Int, optional) – The starting year for the emission calculation.

• end_year (Int, optional) – The ending year for the emission calculation.

• calc_scenario (Bool, optional) – A flag to determine whether to calculate the scenario or not.

• write_to_db (Bool, optional) – A flag to determine whether to write the results to the database.

calc_wtt_emissions(start_year=None, end_year=None, calc_scenario=True)

Berechnet die Vorkettenemissionen auf Basis der jährlichen Endenergiebedarfe und Vorkettenemissionsfaktoren je Energieart.

Parameter:

• start_year (Optional[int]) – The starting year for the emission calculations.

• end_year (Optional[int]) – The ending year for the emission calculations.

• calc_scenario (bool) – A boolean indicating whether to calculate the emission scenario.

Rückgabe:

None

run_tests(start_year=None, end_year=None, calc_scenario=True)

Executes a series of tests based on the provided parameters. The function calculates energy correction for the specified year range and scenario, reads the emission data from a file, and then performs value tests by comparing the modeled data against a reference dataset.

Parameter:

• start_year (int or None) – The starting year for the energy correction calculation. Defaults to None.

• end_year (int or None) – The ending year for the energy correction calculation. Defaults to None.

• calc_scenario (bool) – A flag to determine whether to apply the calculation scenario. Defaults to True.

Rückgabe:

A ValueTests object containing the results of the comparison between the modeled data and the reference emissions dataset.

Rückgabetyp:

ValueTests

view_agg_results(start_year=None, end_year=None, calc_scenario=True)

returns aggregated results for checking.

Parameter:

• start_year (int or None) – The starting year for the energy correction calculation. Defaults to None.

• end_year (int or None) – The ending year for the energy correction calculation. Defaults to None.

• calc_scenario (bool) – A flag to determine whether to apply the calculation scenario. Defaults to True.

Rückgabe:

A ValueTests object containing the results of the comparison between the modeled data and the reference emissions dataset.

Rückgabetyp:

ValueTests

Flow-Chart Module Results

2.4 HBEFA-API

Das Modul hbefa_api dient der automatisierten Abfrage von Emissionsfaktoren über die offizielle HBEFA-Schnittstelle (API). Es ermöglicht den Abruf strukturierter Datensätze mit Emissionsfaktoren des Straßenverkehrs und deren Integration in den TREMOD-Road-Workflow.

Es werden fünf Abfragen konfiguriert und durchgeführt, um die Tabellen mit Emissionsfaktoren (hot, cold, soak, diurnal, running losses) zu erzeugen (siehe Tabellen bei Emissions). Hierzu müssen Nutzername und Passwort für eine gültige HBEFA-Lizenz daten vorliegen. Diese Daten dürfen im Rahmen einer einfachen Lizenz für das UBA verwendet werden.

Die wichtigsten zu definierenden Abfrageparameter für die Tabellen der Emissionskategorien hot, coldstart , dirunal, soak und running losses sind:

• weighting (Flottengewichtete oder -ungewichtete Emissionsfaktoren)

• country (Land. Wichtig für Länderspezifische Daten)

• emcat (Emissionskategorie, z.B. „hot“, „cold“)

• pollutant (Schadstoff)

• agglevel_fleet (Differenzierung nach Fahrzeugeigenschaft. IdR. nach Fahrzeugschicht, d.h. „subsegment“)

• agglevel_ts (Individuelle oder aggregierte Verkehrssituationen)

• idvehcat (Fahrzeugkategorie)

• lang (Sprache)

• idtraffic_scen (Länderspezifisches Szenario, z.B. für Flottenzusammensetzung)

• idtsgrad (Auswahl Verkehrssituationen)

• idpatternambientcond (Auswahl Umgebungsbedingungen, z.B. Temperaturverteilungen)

• nocorr (Verwendung Basis-Emissionsfaktoren aus PHEM oder korrigierte Emissionsfaktoren, z.B. um Temperatur)

• hbversion_int (Nummer HBEFA-Version)

Die Abfrage der Emissionsfaktorentabellen erforlgt nicht bei jedem Rechenlauf zur Bestimmung der Emissionen des Straßenverkehrs, sondern muss bei Bedarf beispielsweise wegen folgender Gründe aktiv ausgeführt werden:

• Update der TREMOD-Version und sich zwischenzeitlicher veränderter HBEFA-Version

• Aktualisierungen des HBEFA, die in eine bestehende TREMOD-Version einfließen sollen

• Erweiterung der TREMOD-Berechnungen (z.B. weitere Schadstoffe)

Wichtigste Dateien und Funktionen:

• hbefapi.py: Enthält die Klasse HBEFapi, welche die technische Kommunikation mit der API übernimmt (Login-Management, CSRF-Token-Extraktion, asynchrone Abfragen und Status-Polling).

• dataset.py: Beinhaltet die Klasse HBEFADatasetManager. Dies ist die zentrale Steuerungseinheit, welche die API initialisiert, Abfragen orchestriert und die Ergebnisse persistiert. Sie bietet zudem eine CLI-Schnittstelle via typer.

• config.py: Zentrale Konfigurationsdatei für Abfrageparameter (z. B. HBEFA-Version, Land, Schadstoffe) und Dateipfade.

• write2postgres.py: Skript zur Übertragung der lokal in SQLite-Datenbanken zwischengespeicherten Ergebnisse in die PostgreSQL-Datenbank von TREMOD.

• credentials.py: Speichert die API-Zugangsdaten (URL, Benutzername, Passwort). Diese Datei ist lokal zu pflegen und sollte nicht in das Repository eingehen.

Konfiguration und Durchführung der Abfragen:

Die Abfragen werden primär über die config.py gesteuert. Hier werden in der Dictionary HBEFA2TREMOD_TABLES die gewünschten Tabellen (z. B. hot, coldstart, evap) und deren Parameter (Schadstoffe, Fahrzeugkategorien, Aggregationslevel) definiert.

Die Durchführung erfolgt durch Ausführen der dataset.py des Moduls, beispielsweise über die Befehlszeile:

python dataset.py --run-hbefa2tremod-tables --write-to-db

Dabei werden asynchrone Tasks am HBEFA-Server gestartet, deren Status regelmäßig abgefragt wird. Nach Abschluss werden die Ergebnisse standardmäßig in einer SQLite-Datenbank unter road/data/hbefa/raw/ abgelegt.

Abruf von Definitionstabellen:

Zusätzlich zu den Emissionsfaktoren können auch die Definitions- bzw. Parametertabellen der API (z. B. Listen der verfügbaren Schadstoffe, Fahrzeugkategorien, Verkehrssituationen) abgerufen werden. Dies ist hilfreich, um die gültigen Parameterwerte für die Konfiguration in config.py zu ermitteln. Der Abruf erfolgt durch Setzen des Flags –get-definition-tables True:

python dataset.py --get-definition-tables --write-to-db

Diese Tabellen werden in einer separaten SQLite-Datenbank namens dataset_param_tables_[ZEITSTEMPEL].db im Verzeichnis road/data/hbefa/raw/ gespeichert.

Datenhaltung und Transfer:

Die Ergebnisse der Emissionsfaktor-Abfragen werden zunächst lokal in SQLite-Datenbanken unter road/data/hbefa/raw/ gespeichert (Dateiname: dataset_[QUERY]_[ZEITSTEMPEL].db). Dies dient der Entkopplung von der API und den Hauptdatenbanken.

Für die Verwendung in TREMOD-Road müssen diese Daten mit dem Skript write2postgres.py in die PostgreSQL-Datenbank übertragen werden. Nach einem erfolgreichen API-Abruf sind im Skript write2postgres.py folgende Einstellungen zu prüfen bzw. anzupassen:

• DATE_OF_CALL: Zur Bestimmung des Pfad zur lokalen SQLite-Datenbank, die die gewünschten abgerufenen Daten enthält.

• SUFFIX_4_POSTGRES: Ein optionales Suffix für die Tabellennamen (z. B. _hb501006 oder _hb521111_test), um verschiedene HBEFA-Stände in der Datenbank parallel vorhalten zu können.

Das Skript liest die Tabellen aus den SQLite-Datenbanken und schreibt in die entsprechenden Postgres-Tabellen (z. B. für Emissionsfaktoren warm oder Kaltstart). Hierbei wird die in der TableOperations.py definierte Datenbank als Zieldatenbank verwendet.

Logging:

Das Modul unterstützt ein detailliertes Logging. Die Log-Dateien werden unter road/data/hbefa/logs/ mit Zeitstempel abgelegt (z. B. dataset_2026-06-26_09-52-00.log). Geloggt werden:

• Erfolg oder Fehler beim Login.

• Start von asynchronen Tasks inkl. Task-IDs.

• Status-Updates während des Pollings.

• Detaillierte Fehlermeldungen der API im Falle von ungültigen Parametern.

• Erfolgreiche Schreibvorgänge in Dateien oder Datenbanken.

Ablaufschéma einer Abfrage: