---
title: "ADA Bayern"
subtitle: "Modul 2: Die Daten verstehen"
format:
  html:
    toc: true
    number-sections: true
    highlight-style: github
    embed-resources: true
    df-print: paged
editor: visual
---

## Ziel des Notebooks

In diesem Notebook lernen wir zunächst Quarto und R kennen. Anschließend führen wir erste Analysen mit den forumSTAR Daten durch. Das Ziel dabei ist es, insbesondere, die Daten gut zu verstehen.

**Zur Anonymisierung wurde dieses File nachträglich verändert!**

## Quarto und R

Dieses Dokument ist ein sogennantes Quarto Dokument. Wir können Quarto Dokumente an der Dateiendung `.qmd` erkennen und direkt in RStudio öffnen.

Jedes Quarto Dokument besteht im Wesentlichen aus vier Bausteinen. Header, Text, Code Eingabe und Code Ausgabe.

### Header

Der Header steht immer am Anfang eines Quarto Dokuments. Hier definieren wir den Titel und Untertitel unseres Dokuments. Außerdem können wir hier einstellen wie aus dem vorliegenden `.qmd` Dokument zum Beispiel ein pdf oder docx Dokument generiert werden soll. Mehr dazu lernen wir in Modul 3.

### Text

Das hier ist ganz normaler Text. Wie in anderen Editoren (zum Beispiel Word), können wir den Text nach unserem Geschmack formatieren.

### Code Eingabe

Mit einem Klick auf den grünen Button (C mit kleinem `+`-Symbol) oben in der Leiste erstellen wir eine R Code Zelle. In dieser können wir ausführbaren R Code schreiben. Mit einem Klick auf das grüne Dreieck rechts an der Code Zelle führen wir den Code aus[^1].

[^1]: Das {r} definiert, das die Code Eingabe R Code erwartet. Im Code addieren wir dann 1 und 1.

```{r}
1 + 1
```

Dabei ist Quarto nicht auf die Programmiersprache R beschränkt. Wir könnten, zum Beispiel, auch ausführbaren Python Code in ein Quarto Dokument integrieren.

### Code Ausgabe

Sobald wir Code ausführen, erscheint das Ergebnis (wie oben nach einem Klick auf das grüne Dreieck) ebenfalls direkt im Quarto Dokument.

## Software-Pakete laden

Zunächst laden wir einige R-Pakete, die uns bei der Datenanalyse helfen.

R-Pakete sind Erweiterungen, Sammlungen von nützlichem Code die im CRAN (Comprehensive R Archive Network) zur Verfügung gestellt werden.

In diesem Modul nutzen wir das sogenannte `tidyverse`[^2], das viele nützliche und einfach verständliche (tidy!) Funktionen zum Arbeiten mit Datensätzen bereitstellt.

[^2]: Wickham H, Bryan J (2022). *readxl: Read Excel Files*. R package version 1.4.0, https://CRAN.R-project.org/package=readxl.

Außerdem nutzen wir das Paket `sf`[^3] Paket um die Daten auf Karten zu visualisieren[^4].

[^3]: Pebesma, E., & Bivand, R. (2023). Spatial Data Science: With Applications in R. Chapman and Hall/CRC. https://doi.org/10.1201/9780429459016

[^4]: Im Code rufen wir zunächst mit der Funktion `install.packages()`, ein R Paket zu installieren, bedeutet, dass wir die Funktionen im Paket auf unserem Computer verfügbar machen. `install.packages()` müssen wir nur ausführen, wenn wir ein R Paket erstmalig installieren oder updaten möchten. Anschließend müssen wir die Funktionen noch für unser spezifisches Dokument verfügbar machen. Dazu rufen wir die Funktion `library()` für jedes Paket auf. `library()` führen wir immer aus, wenn wir eine neue R Session starten.

```{r}
library("tidyverse")
library("sf")
```

## Daten einlesen

Um unsere Daten in R nutzen zu können, müssen wir diese zunächst einlesen[^5].

[^5]: Die Forumstar Daten liegen uns in einer `.csv` Datei vor. Diese können wir mit der Funktion `read_csv` einlesen. Zunächst definieren wir den Pfad zum Ordner mit den Daten im Objekt `pfad`, dafür nutzen wir die Funktion `file.path()`, dort geben wir Schritt für Schritt den Weg zum Ordner mit den Daten an. Dann definieren wir dafür die verschiedenen Datentypen in jeder Spalte. Ein `c` steht für character, also Textdaten, wie zum Beispiel in Namensfeldern. `n` steht für numerische Werte, `T` steht für eine Datumsangabe mit Uhrzeit (von "Time"). Diese Informationen speichern wir im Objekt `col_types`. Anschließend lesen wir den Datensatz mit der Funktion `read_csv()` direkt aus dem Ordner in unserer sicheren Datenumgebung ein. Wir können die Daten dann später über das Objekt `forumstar_daten` aufrufen.

```{r}
pfad <- file.path(".")
col_types <- c("ccccnccccccccccccccccccTTcnTccnTcTcccc")

forumstar_daten <- read_csv(file.path(pfad, "230817_Abfrage_Januar-Dezember.csv"), col_types = col_types)
```

Zusätzlich laden wir eine Datei mit einer Karte der Amtsgerichtsbezirke. Diese verwenden wir später für erste Analysen.

```{r}
karte_amtsgerichte <- readRDS(file.path(pfad, "230911_Karte_Amtsgerichtsbezirke.RDS"))
```

## Überblick über die Daten

Um die Daten besser zu verstehen, macht es Sinn diese zu betrachten. Aber wie machen wir das in R? Es gibt viele Möglichkeiten, wovon wir hier eine sehr gute Möglichkeit beispielhaft zeigen[^6].

[^6]: Mit `glimpse()` ("Glimpse" bedeutet auf Deutsch "kurzer Blick".) erhält man die Anzahl an Zeilen (Rows) und Spalten (Columns) der Daten und kann die Spalten (Variablen) besser verstehen. In den folgenden Zeilen werden die Spaltennamen aufgelistet. Dahinter sehen wir den Datentyp jeder Spalte (`<chr>` für "character" also Text, `<dbl>` für Zahlen im "double-precision flouting-point format" und `<dttm>` für "date-time" also Datumsangaben) und einen ersten Überblick über einige der ersten Zellen jeder Spalte. `NA` bedeutet dabei, dass eine Zelle in unserem Datensatz leer ist.

```{r}
#| eval: false
forumstar_daten %>% 
  glimpse()
```

**Was sind die Namen der Spalten des Datensatzes?**

**Im Datensatz sind vier Spalten mit Zahlenwerten enthalten. Welche sind das?**

Außerdem können wir uns die ersten Zeilen des Datensatzes ansehen. Mit einem Klick auf das schwarze Dreieck rechts über der Tabelle können wir die weiteren Spalten sehen[^7].

[^7]: Mit der Funktion `head()` können wir uns die ersten sechs Zeilen des Datensatzes ansehen. Analog könnten wir mit der Funktion `tail()` die letzten sechs Zeilen des Datensatzes ansehen.

```{r}
#| eval: false
forumstar_daten %>% 
  head()
```

**Für die Analysen ist es wichtig zu verstehen, was eine Zeile im Datensatz abbildet. Was bildet eine Zeile in unserem Datensatz ab? Betrachten Sie dazu die Spalten `Aktenzeichen`, `Verfahrensbeteiligungsart` und `Name`**[^8].

[^8]: Wir nutzen die Funktion `select()` um Spalten aus unserem Datensatz auszuwählen (auswählen auf Englisch "to select"). Hier wählen wir also die Spalten `Aktenzeichen`, `Verfahrensbeteiligungsart` und `Name` aus.

```{r}
#| eval: false
forumstar_daten %>% 
  select(`Aktenzeichen`, `Verfahrensbeteiligungsart`, `Name`)
```

**Aktenzeichen tauchen mehrmalig auf. Was bedeutet das?**

## Erste Analysen

### Welche Gerichte sind im Datensatz?

Möchten wir wissen, welche und wie viele Gerichte in unserem Datensatz vertreten sind, können wir dies auch erfahren[^9].

[^9]: Wir nutzen die Funktion `select()` um die Spalte `Gericht` auszuwählen. Damit wir nicht alle Zeilen erhalten, sondern jedes Gericht nur einmal, können wir die Funktion `unique()` ("unique" auf Englisch bedeutet einmalig).

```{r}
forumstar_daten %>%
  select(`Gericht`) %>%
  unique()
```

### Wie viele Akten haben wir pro Gericht?

Wir möchten nun wissen, mit wie vielen Akten jedes Gericht im Datensatz vertreten ist. Wir benötigen hierfür einen Datensatz, der nur eine Zeile pro Akte beinhaltet (statt zuvor einer Zeile pro Prozessbeteiligten) beinhaltet. Mit dem folgenden Code aggregieren wir die Daten auf einen Eintrag pro Gericht und Aktenzeichen[^10].

[^10]: Mithilfe der `group_by` Funktion werden die nachfolgenden Schritte (hier nur ein Schritt: `summarise`) getrennt für jede Kombination aus `Gericht` und `Aktenzeichen` ausgeführt. Das heißt in `summarise()` werden alle Zeilen, die dasselbe Gericht und Aktenzeichen haben, in einer einzigen Zeile zusammengefasst. Zusätzlich zählen wir die Anzahl Zeilen `n()`. Diese Zahl wird in einer neuen Spalte `Anzahl Beteiligte` gespeichert.

    Anschließend fügen wir noch mit `mutate()` eine eindeutige Index Spalte `Index` anhand der Zeilennummer für jede Akte hinzu. Dafür muss zunächst mit `as.data.frame()` die Gruppierung aufgehoben werden.

```{r}
#| eval: false
forumstar_daten %>%
  group_by(
    `Gericht`,
    `Aktenzeichen`
  ) %>%
  summarise(`Anzahl Beteiligte` = n()) %>%
  as.data.frame() %>%
  mutate(Index = row_number())
```

Zusätzlich wollen wir noch weitere Informationen behalten, die für jede Akte vorliegen, aber nicht personenspezifisch sind. Die entsprechenden Spaltennamen nehmen wir in `group_by()` auf. Das Ergebnis speichern wir in einem neuen Datensatz `akten` zur weiteren Analyse ab.

```{r}
akten <- forumstar_daten %>%
  group_by(
    `Gericht`,
    `Aktenzeichen`,
    `Streitwert in EURO`,
    `Gesamtstreitgegenstand`,
    `Erledigungsgrund`,
    `Dauer des Verfahrens in Tagen`,
    `Archivstatus`,
    `Anbietungsgrund (manuell erfasst)`,
    `Anbietungsgrund`
  ) %>%
  summarise(`Anzahl Beteiligte` = n()) %>%
  as.data.frame() %>%
  mutate(Index = row_number())
```

Nun können wir die Anzahl der Akten pro Amtsgericht (bzw. Zweigstelle) zählen[^11].

[^11]: Dafür gruppieren wir unsere Daten nach der Spalte `Gericht` und nutzen dann die `summarise()` Funktion innerhalb jeder Gruppe. Mit der Funktion `n()` zählen wir so die Anzahl der Zeilen pro Gruppe.

```{r}
akten %>% 
  group_by(Gericht) %>% 
  summarise(Anzahl = n())
```

Das gleiche können wir auch visuell machen[^12].

[^12]: `ggplot()` ist eine Funktion zur visuellen Darstellung von Daten (auf Englisch "to plot"), bei der mit `+`-Symbolen die Details der Darstellung bestimmt werden. `geom_bar()` erstellt einen Bar-Plot; mit `scale_x_discrete(guide = guide_axis(angle = 90))` drehen wir die Namen der Gerichte um 90 Grad, damit diese sich nicht überlappen. Sie können ausprobieren, was passiert wenn Sie den letzten Befehl sowie das letzte `+`-Symbol weglöschen.

```{r}
ggplot(akten, aes(Gericht)) + 
  geom_bar() + 
  scale_x_discrete(guide = guide_axis(angle = 90))
```

**Datenprobleme erkennen: Macht es Sinn die Zweigstellen gesondert aufzuführen?**

Wir können uns auch eine numerische Zusammenfassung des Datensatzes anzeigen lassen[^13].

[^13]: Dazu nutzen wir die Funktion `summary()`. Diese Funktion fasst numerische Spalten mit einfachen statistischen Werten zusammen. So können wir das Minimum, das erste Quartil, den Median, den Mittelwert (auf Englisch "mean"), das dritte Quartil, das Maximum der Daten, sowie die Anzahl fehlender Werte (NA's) auf einen Blick sehen.

```{r}
#| eval: false
akten %>% 
  summary()
```

**Datenprobleme erkennen: Ist es möglich, dass die tatsächliche `Dauer des Verfahrens in Tagen` negativ ist? Wie viele Jahre dauert ein Verfahren mit 17164 Tagen? Ist das ein realistischer Zeitraum?**

## Die Daten visuell kennenlernen

Wir können die Daten auch auf einer Karte darstellen. Wir haben dazu eine Karte mit den bayerischen Amtsgerichtsbezirken vorbereitet.

Die Karte ist zunächst ein zusätzlicher Datensatz, den wir oben in R eingelesen haben. Wie bei den forumSTAR Daten können wir uns zunächst einen Überblick verschaffen[^14].

[^14]: Wir nutzen dafür wieder die Funktion `glimpse()`.

```{r}
karte_amtsgerichte %>%
  glimpse()
```

In diesem Datensatz haben wir drei Variablen. `court` ist der Name des Amtsgerichtsbezirks, `geometry` definiert die Grenzen der einzelnen Amtsgerichtsbezirke und `tile_map` ist eine alternative Darstellung der Amtsgerichtsbezirke als gleich große Kacheln (sogenannte tiles).

Bei einer Karte macht es natürlich besonders Sinn die Daten zu visualisieren[^15].

[^15]: Zur visuellen Darstellung Nutzen wir wieder die `ggplot()` Funktion. Hier geben wir als Ausgangsdaten (data) den Datensatz mit der Karte `karte_amtsgerichte` an, mit `aes(fill = court)` geben wir an, dass wir jeden Gerichtsbezirk unterschiedlich farbig füllen (auf Englisch "fill") möchten. `aes` steht dabei für "aesthetics". Nun nutzen wir `geom_sf()` um die Karte anzuzeigen, dafür geben wir an, dass die Informationen zur Geometrie der Bezirke (Option geometry) in der Spalte `geometry` unseres Datensatzes liegen. Grenzen zwischen Bezirken zeigen wir in der Farbe weiß an (`color = "white"`). Zusätzlich zeigen wir mit `geom_sf_text()` noch die Namen der Amtsgerichtsbezirke auf der Karte an. Um diese an der richtigen Stelle zu platzieren nutzen wir wieder die Informationen in der Spalte `geometry`. Für die Beschriftung verwenden wir die Spalte `court`. Mit der Option `size = 1.5` geben wir die Größe der Schrift an und mit der Option `color = "black"` geben wir an, dass wir die Beschriftung in schwarz darstellen. Um nun die Labels richtig zu platzieren, berechnen wir den Mittelpunkt der Amtsgerichtsbezirke mit der Funktion `st_centroid()`. Diese Funktion wird auf Basis der Information in der Spalte `geometry` berechnet. Anschließend definieren wir mit `sclae_fill_viridis_d(option = "viridis")` die Farbskala mit der wir die verschiedenen Amtsgerichtsbezirke einfärben möchten (mehr dazu in Modul 3). Mit `guides(fill="none")` unterdrücken wir die Erstellung einer Farblegende. Diese würde in diesem Fall keine Information hinzufügen, dabei aber sehr viel Platz einnehmen. Zuletzt definieren wir mit `theme_void()`, dass wir die Karte ohne Koordinatensystem und Hintergrund abbilden möchten.

```{r}
ggplot(data = karte_amtsgerichte, aes(fill = court)) +
  geom_sf(aes(geometry = geometry), color = "white") +
  geom_sf_text(
    aes(geometry = geometry, label = court),
    size = 1.5,
    color = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) + scale_fill_viridis_d(option = "viridis") +
  guides(fill="none") +
  theme_void()
```

**Aufgabe: Visualisieren Sie die Amtsgerichtsbezirke mit den gleich großen Kacheln (`tile_map`) anstatt der geographischen Grenzen (`geometry`) . Als Starthilfe nehmen wir den gleichen Code wie für die Karte oben. Sie müssen die Spalte `geometry` an zwei Stellen austauschen.**

```{r}
ggplot(data = karte_amtsgerichte, aes(fill = court)) +
  geom_sf(aes(geometry = tile_map), color = "white") +
  geom_sf_text(
    aes(geometry = tile_map, label = court),
    size = 1.5,
    col = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) + scale_fill_viridis_d(option = "viridis") +
  guides(fill="none") +
  theme_void()
```

Nun wollen wir die Anzahl der Akten pro Gericht auf der Karte darstellen. Dazu müssen wir die Gerichte in unserem Datensatz `akten` den Amtsgerichtsbezirken im Datensatz `karte_amtsgerichte` eindeutig zuordnen.

Wenn wir die Namen der Gerichte in den beiden Datensätzen betrachten, fällt auf, dass die Namen unterschiedlich sind.

Zunächst betrachten wir die Namen in unserem Datensatz `akten` [^16].

[^16]: Dazu wählen wir zunächst mit der Funktion `select()` die Spalte `Gericht` aus und zeigen dann mit der Funktion `unique()` die einmaligen Werte an.

```{r}
akten %>% 
  select(`Gericht`) %>%
  unique()
```

Dann betrachten wir die Namen der Amtsgerichtsbezirke im Datensatz `karte_amtsgerichte` [^17].

[^17]: Hier nutzen wir den `$` Operator, mit dem wir Spalten in einem Datensatz anwählen können. Die Namen der Amtsgerichtsbezirke sind in der Spalte `court` angeführt.

```{r}
karte_amtsgerichte$court
```

**Datenprobleme erkennen: Wie können wir die verschiedenen Namen der Gerichte automatisiert zusammenführen?**

Zunächst löschen wir das "Amtsgericht" vor dem Namen des Amtsgerichtsbezirks[^18].

[^18]: Dazu nutzen wir die Funktion `sub()`. Zunächst geben wir an, welche Zeichenfolge wir suchen und ersetzen möchten, hier die Zeichenfolge "Amtsgericht". Dann geben wir an, durch welche Zeichenfolge wir die erste Zeichenfolge ersetzen möchten, hier durch eine leere Zeichenfolge "". Als letztes geben an, wir welche Werte wir verändern möchten, hier möchten wir direkt die Einträge in der Spalte `Gericht` verändern. Mit dem `$` können wir die Spalte in unserem Datensatz `akten` auswählen. Wir speichern die angepassten Namen im Objekt `tmp_Gericht`.

    Danach betrachten wir das Ergebnis, indem wir mit der Funktion `unique()` jeden Namen einmal anzeigen.

```{r}
tmp_Gericht <- sub("Amtsgericht ", "", akten$Gericht)

tmp_Gericht %>% 
  unique()
```

Genauso können wir das Wort "Zweigstelle" (und alle folgenden Buchstaben) aus dem Namen entfernen[^19].

[^19]: Dafür nutzen wir wieder die Funktion sub(). Hier wollen wir die Zeichenfolge "Zweigstelle.\*" durch die leere Zeichenfolge "" ersetzen. Das .\* gibt an, dass der Zeichenfolge "Zweigstelle" beliebige Zeichen folgen können, die trotzdem mit ausgetauscht werden.

```{r}
tmp_Gericht <- sub(" Zweigstelle.*", "", tmp_Gericht)

tmp_Gericht %>% 
  unique()
```

Nun müssen wir noch leicht unterschiedliche Schreibweisen anpassen. In `forumstar_daten` steht zum Beispiel die Abkürzung "i.d", in den `karten_amtsgerichte` Daten dagegen "i. d.". Für uns ist trotz der leicht unterschiedlichen Schreibweise eine eindeutige Zuordnung möglich. Für den Computer ist das hier schwieriger. Das "i.d." können wir auch einfach durch ein "i. d." austauschen. Wir wiederholen das dann für alle anderen Abkürzungen mit unterschiedlichen Schreibweisen[^20].

[^20]: Dafür nutzen wir wieder die Funktion sub(). Hier tauschen wir zum Beispiel die Zeichenfolge " i.d. " durch " i. d. " aus. Die Leerzeichen vor und nach den Buchstaben und Punkten sind wichtig! Leerzeichen gehören auch zur Zeichenfolge.

```{r}
tmp_Gericht <- sub(" i.d. ", " i. d. ", tmp_Gericht)
tmp_Gericht <- sub(" a.d. ", " a. d. ", tmp_Gericht)
tmp_Gericht <- sub(" am ", " a. ", tmp_Gericht)
tmp_Gericht <- sub(" i.OB", " i. OB", tmp_Gericht)

tmp_Gericht %>% 
  unique()
```

Nun können wir die neuen Namen der Gerichte als eine neue Spalte mit dem Namen `Bezirk` zu unserem Datensatz `akten` hinzufügen[^21].

[^21]: Dazu nutzen wir die Funktion `mutate`\` mit der wir neue Spalten zu unserem Datensatz hinzufügen können. Wir nennen die Spalte `Bezirk`\` und ordnen unsere aufgeräumten Namen von oben zu.

```{r}
akten <- akten %>%
  mutate(`Bezirk` = tmp_Gericht)
```

Die neue Spalte `Bezirk`\` können wir nutzen um die Daten auf der Ebene der Amtsgerichtsbezirke zu aggregieren. Zweigstellen sind nun ihrem Bezirk zugeordnet[^22].

[^22]: Wir erstellen hier ein neues Objekt `fallzahl_pro_bezirk` . Dazu gruppieren wir zunächst unseren Datensatz nach der Spalte `Bezirk` und zählen dann mit den Funktionen `summarise()` und `n()` die Anzahl der Akten pro Bezirk. Mit `as.data.frame()` speichern wir diese Information als einen neuen Datensatz.

```{r}
fallzahl_pro_bezirk <- akten %>% 
  group_by(Bezirk) %>% 
  summarise(Anzahl = n()) %>%
  as.data.frame()
```

Die aggregierten Daten stellen fügen wir dann als Information zu unserem Datensatz `karte_amtsgerichte` hinzu[^23].

[^23]: Hier erstellen wir die neue Spalte `Anzahl der Fälle` mit dem `$` Operator. Dafür nutzen wir unseren gerade erstellten Datensatz `fallzahl_pro_bezirk` und die Spalte `Anzahl` . Mit der Funktion match() stellen wir sicher, dass die Daten in beiden Datensätzen richtig sortiert sind.

```{r}
karte_amtsgerichte$`Anzahl der Fälle` <- fallzahl_pro_bezirk$Anzahl[match(karte_amtsgerichte$court, fallzahl_pro_bezirk$Bezirk)]
```

Jetzt visualisieren wir die Anzahl der Fälle pro Bezirk auf einer Karte[^24].

[^24]: Zur visuellen Darstellung Nutzen wir wieder die `ggplot()` Funktion. Hier geben wir als Ausgangsdaten (data) den Datensatz mit der Karte `karte_amtsgerichte` an, mit `aes(fill = Anzahl der Fälle)` geben wir an, dass wir Farbabstufungen nach der Anzahl der Fälle (auf Englisch "fill") möchten. `aes` steht dabei für "aesthetics". Nun nutzen wir `geom_sf()` um die Karte anzuzeigen, dafür geben wir an, dass die Informationen zur Geometrie der Bezirke (Option geometry) in der Spalte `geometry` unseres Datensatzes liegen. Grenzen zwischen Bezirken zeigen wir nicht an (`color = "transparent"`). Zusätzlich zeigen wir mit `geom_sf_text()` noch die Namen der Amtsgerichtsbezirke auf der Karte an. Um diese an der richtigen Stelle zu platzieren nutzen wir wieder die Informationen in der Spalte `geometry`. Für die Beschriftung verwenden wir die Spalte `court`. Mit der Option `size = 1.5` geben wir die Größe der Schrift an und mit der Option `color = "black"` geben wir an, dass wir die Beschriftung in schwarz darstellen. Um nun die Labels richtig zu platzieren, berechnen wir den Mittelpunkt der Amtsgerichtsbezirke mit der Funktion `st_centroid()`. Diese Funktion wird auf Basis der Information in der Spalte `geometry` berechnet. Anschließend definieren wir mit `sclae_fill_viridis_d(option = "viridis")` die Farbskala mit der wir die verschiedenen Amtsgerichtsbezirke einfärben möchten (mehr dazu in Modul 3). Zuletzt definieren wir mit `theme_void()`, dass wir die Karte ohne Koordinatensystem und Hintergrund abbilden möchten.

```{r}
ggplot(data = karte_amtsgerichte, aes(fill = `Anzahl der Fälle`)) +
  geom_sf(aes(geometry = geometry), color = "transparent") +
  geom_sf_text(
    aes(geometry = geometry, label = court),
    size = 1.5,
    col = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) +
  scale_fill_viridis_b(option = "viridis") +
  theme_void()
```

Im Amtsgerichtsbezirk München ist wirklich einiges los! Sogar so viel mehr, dass wir bei den meisten Gerichten mit weniger als 5000 Akten auf der Karte gar keinen Unterschied sehen können.

Für so "schiefe Daten" bietet sich eine logarithmische Transformation der Farbskala an[^25].

[^25]: Zur visuellen Darstellung Nutzen wir wieder die `ggplot()` Funktion. Hier geben wir als Ausgangsdaten (data) den Datensatz mit der Karte `karte_amtsgerichte` an, mit `aes(fill = Anzahl der Fälle)` geben wir an, dass wir Farbabstufungen nach der Anzahl der Fälle (auf Englisch "fill") möchten. `aes` steht dabei für "aesthetics". Nun nutzen wir `geom_sf()` um die Karte anzuzeigen, dafür geben wir an, dass die Informationen zur Geometrie der Bezirke (Option geometry) in der Spalte `geometry` unseres Datensatzes liegen. Grenzen zwischen Bezirken zeigen wir nicht an (`color = "transparent"`). Zusätzlich zeigen wir mit `geom_sf_text()` noch die Namen der Amtsgerichtsbezirke auf der Karte an. Um diese an der richtigen Stelle zu platzieren nutzen wir wieder die Informationen in der Spalte `geometry`. Für die Beschriftung verwenden wir die Spalte `court`. Mit der Option `size = 1.5` geben wir die Größe der Schrift an und mit der Option `color = "black"` geben wir an, dass wir die Beschriftung in schwarz darstellen. Um nun die Labels richtig zu platzieren, berechnen wir den Mittelpunkt der Amtsgerichtsbezirke mit der Funktion `st_centroid()`. Diese Funktion wird auf Basis der Information in der Spalte `geometry` berechnet. Anschließend definieren wir mit `sclae_fill_viridis_d(trans = "log", option = "viridis")` die Farbskala mit der wir die verschiedenen Amtsgerichtsbezirke einfärben möchten (mehr dazu in Modul 3). Mit `trans = "log"` geben wir hier an, dass wir die Werte in der Spalte Anzahl der Fälle logarithmisch transformieren um die Grenzen zwischen den verschiedenen Farben neu zu definieren. Zuletzt definieren wir mit `theme_void()`, dass wir die Karte ohne Koordinatensystem und Hintergrund abbilden möchten.

```{r}
ggplot(data = karte_amtsgerichte, aes(fill = `Anzahl der Fälle`)) +
  geom_sf(aes(geometry = geometry), color = "transparent") +
  geom_sf_text(
    aes(geometry = geometry, label = court),
    size = 1.5,
    col = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) +
  scale_fill_viridis_b(trans = "log", option = "viridis") +
  theme_void()
```

### Welche Akten sind anzubieten?

Eine der zentralen Fragen in unserem Projekt ist: welche Verfahrensakten sollen den Archiven angeboten werden und warum? Rechtspfleger:innen geben manchmal eine Begründung ein, wenn sie entscheiden, dass ein Fall archiviert werden sollte. Um diese Begründungen anzuzeigen, erstellen wir zunächste einen kleineren Datensatz mit nur denjenigen Akten, die von den Rechtspfleger:innen als anzubieten gekennzeichnet wurden[^26].

[^26]: Mit `filter()` erstellen wir den Datensatz `akten_anzubieten` mit allen Akten, bei denen der Archvstatus `anzubieten` lautet.

    `.drop = FALSE` wurde hier verwendet, damit auch Bezirke mit 0 Akten im resultierenden Dataframe erhalten bleiben.

```{r}
anzahl_anzubietend <- akten %>% 
  group_by(`Bezirk`, .drop = FALSE) %>%
  filter(`Archivstatus` == "anzubieten") %>%
  count(name = "Anzahl") %>%
  as.data.frame()
  
anzahl_anzubietend
```

Wir können die Gesamtzahl der anzubietenden Akten durch das aufsummieren der anzubietenden Akten pro Gericht herausfinden.

```{r}
anzahl_anzubietend %>%
  select(Anzahl) %>%
  sum()
```

Um die Daten besser zu verstehen, betrachten wir diese wieder in einer grafischen Darstellung.

```{r}
ggplot(anzahl_anzubietend, aes(Bezirk, Anzahl)) + 
  geom_col() + 
  scale_x_discrete(guide = guide_axis(angle = 90))
```

Und können die Daten auch auf einer Karte darstellen.

```{r}
karte_amtsgerichte$`Anzubietende Akten` <- anzahl_anzubietend$Anzahl[match(karte_amtsgerichte$court, anzahl_anzubietend$Bezirk)]
karte_amtsgerichte$`Anzubietende Akten`[karte_amtsgerichte$`Anzubietende Akten` == 0] <- NA

ggplot(data = karte_amtsgerichte, aes(fill = `Anzubietende Akten`)) +
  geom_sf(aes(geometry = geometry), color = "transparent") +
  geom_sf_text(
    aes(geometry = geometry, label = court),
    size = 1.5,
    col = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) +
  scale_fill_viridis_b(option = "viridis") +
  theme_void()
```

**Was fällt auf?**

Nur 48 der 73 Amtsgerichtsbezirke haben in unserem Datensatz Akten mit Archivstatus "anzubieten". Die Anzahl der anzubietenden Akten scheint nicht mit der Anzahl der Akten zu korrelieren.

**Woran liegt das?**

Warum sollen diese Akten angeboten werden? In zwei Spalten in unserem Datensatz haben wir Informationen zum Anbietungsgrund. Es gibt die Spalte "Anbietungsgrund", sowie die Spalte "Anbietungsgrund (manuell erfasst)". Wir erstellen uns je eine Tabelle, die uns sagt, welcher Grund wie oft angegeben wurde[^27].

[^27]: Wir nutzen hier unseren Datensatz `akten` . Mit der Funktion `filter(Archivstatus == "anzubieten")` wählen wir zunächst nur Zeilen aus die den Status anzubieten haben. Diese Daten gruppieren wir mit der `group_by()` Funktion nach den Gründen die in der Spalte `Anbietungsgrund` angeführt sind. Mit der Funktion `summarise(Anzahl = n()` zählen wir dann die Anzahl der Zeilen pro Gruppe.

```{r}
#| eval: false
akten %>% 
  filter(`Archivstatus` == "anzubieten") %>%
  group_by(Anbietungsgrund) %>% 
  summarise(Anzahl = n())
```

Das gleiche machen wir mit der Spalte `Anbietungsgrund (manuell erfasst)` [^28].

[^28]: Wir nutzen hier unseren Datensatz `akten` . Mit der Funktion `filter(Archivstatus == "anzubieten")` wählen wir zunächst nur Zeilen aus die den Status anzubieten haben. Diese Daten gruppieren wir mit der `group_by()` Funktion nach den Gründen die in der Spalte `Anbietungsgrund (maniell erfasst)` angeführt sind. Mit der Funktion `summarise(Anzahl = n()` zählen wir dann die Anzahl der Zeilen pro Gruppe.

```{r}
#| eval: false
akten %>% 
  filter(`Archivstatus` == "anzubieten") %>%
  group_by(`Anbietungsgrund (manuell erfasst)`) %>% 
  summarise(Anzahl = n())
```

`NA` steht hier für "not available" (nicht verfügbar), d. h. für alle Zeilen, bei denen kein Grund angegeben wurde.

## Quantitative Informationen darstellen

Wir können auch die quantitativen Informationen visuell darstellen und so die Daten besser verstehen. Zunächst betrachten wir den `Streitwert in EURO` und die `Anzahl Beteiligte` [^29].

[^29]: Zur visuellen Darstellung der Daten nutzen wir wieder die Funktion `ggplot()`. Als Daten nutzen wir den Datensatz `akten`. In der Option `aes()` definieren wir, welche Spalte auf der x-Achse und welche Spalte auf der y-Achse angezeigt werden soll. Hier wählen wir die Spalte `Streitwert in EURO` für die x-Achse und die Spalte `Anzahl Beteiligte` für die y-Achse. Mit `geom_point()` geben wir an, dass die Daten mit Punkten im Koordinatensystem abgetragen werden sollen.

```{r}
#| eval: false
ggplot(akten, aes(x=`Streitwert in EURO`, y=`Anzahl Beteiligte`)) + 
  geom_point()
```

Genauso können wir die `Dauer des Verfahrens in Tagen` und die `Anzahl Beteiligte` betrachten. Tauschen Sie dazu eine Spalte im Code für die visuelle Darstellung aus[^30].

[^30]: Zur visuellen Darstellung der Daten nutzen wir wieder die Funktion `ggplot()` als Daten nutzen wir den Datensatz `akten` in der Option `aes()` definieren wir, welche Spalte auf der x-Achse und welche Spalte auf der y-Achse angezeigt werden soll. Hier wählen wir die Spalte `Dauer des Verfahrens in Tagen` für die x-Achse und die Spalte `Anzahl Beteiligte` für die y-Achse. Mit `geom_point()` geben wir an, dass die Daten mit Punkten im Koordinatensystem abgetragen werden sollen.

```{r}
#| eval: false
ggplot(akten, aes(x=`Dauer des Verfahrens in Tagen`, y=`Anzahl Beteiligte`)) + 
  geom_point()
```

## Aufgaben

Welche Spalten im Datensatz finden Sie besonders spannend? Welche Spalten könnten sich gut zur Auswahl archivwürdiger Akten eignen?

Suchen Sie sich gemeinsam mit ihrem Team mindestens zwei Spalten aus und stellen Sie diese visuell dar.
