Manual renaming with dplyr::rename()

Manual renaming following the idea of newname = oldname. This is the approach you need to take for manual replacement of column-names (see an equivalent base-R code below). You can rename more than three variables like this, just add further combinations of newname = oldname…

df %>%
  rename(
    pesnwi_ls = pesnwi_leadership,
    ration_adl = bernca_adl,
    ration_docu = bernca_docu
  )

# A tibble: 3 × 5
     id pesnwi_ls pesnwi_sra ration_adl ration_docu
  <dbl>     <dbl>      <dbl>      <dbl>       <dbl>
1     1       2.3        2.1        1.8         1.4
2     2       2          3          2.1         0.9
3     3       3.1        3.5        3.9         3  

Manual renaming with base-R

Of course its also possible to rename the columns with other approaches, e.g. :

names(df)[names(df)=="pesnwi_leadership"] <- "pesnwi_ls"

Renaming multiple columns at once

df %>%
  rename_with(
    .fn = ~ stringr::str_replace(., pattern = "bernca", replacement = "ration"),
    .cols = everything()
  )

# A tibble: 3 × 5
     id pesnwi_leadership pesnwi_sra ration_adl ration_docu
  <dbl>             <dbl>      <dbl>      <dbl>       <dbl>
1     1               2.3        2.1        1.8         1.4
2     2               2          3          2.1         0.9
3     3               3.1        3.5        3.9         3  

Renaming based on names defined in an external document (e.g. xlsx)

Imagine the following situation: a survey study with three timepoints was conducted over a timespan of 2 years: T0 as baseline, T1 = T0+12months and T2 = T0+24months.
Some of the questions were only asked at baseline, some across all timepoints and selected variables only in T1 and T2. For several reasons (a.k.a. real-life data collection) this led to situations, where a variable named X12 in T0, did in fact not correspond to the variable named X12 in T1 and so on.

In total there were > 250 variables to rename and the person defining the new variables did not work with R. Thus, the solution was to store the information in an external spreadsheet and then write code to import this spreadsheet and rename based on it. But how?

A spreadsheet was created in excel that essentially held information on the variable names of a specific questions across all time points. Additionally, the first column ‘global’ defines the new variable name that will be used across all datasets once the renaming took place. Below is a small example of how the excel-file looked like:

orig_t0 <- tibble::tribble(
  ~ID, ~X1, ~X4,
  "A", "m", 1,
  "B", "x", 2
)

orig_t1 <-  tibble::tribble(
  ~ID, ~X3, ~X10, ~X2,
  "AAA", "f", 1, 44,
  "BBB", "x", 2, 56,
)

orig_t2 <-  tibble::tribble(
  ~ID, ~X2, ~X11, ~X12,
  "FFF", "f", 2, 53,
  "BGG", "f", 1, 23,
)

name_tbl <- tibble::tribble(
  ~global, ~T0, ~T1, ~T2,
  "ID", "ID", "ID", "ID",
  "X1", "X1", "X3", "X2",
  "X2", "X4", "X10", "X11",
  "X3", NA_character_, "X2", "X12"
)

# create a named vector
helper_rename_t0 <- name_tbl %>%
  select(global, T0) %>% # take the two variables needed
  drop_na() %>% # drop_na() is important here 
  deframe() # deframe creates the named vector

# rename with !!! 
(global_t0 <- 
  orig_t0 %>%
    rename(!!!helper_rename_t0))

# A tibble: 2 × 3
  ID    X1       X2
  <chr> <chr> <dbl>
1 A     m         1
2 B     x         2

# create a named vector
helper_rename_t1 <- name_tbl %>%
  select(global, T1) %>% # take the two variables needed
  drop_na() %>% # drop_na() is important here 
  deframe() # deframe creates the named vector

# rename with !!! 
(global_t1 <- 
  orig_t1 %>%
    rename(!!!helper_rename_t1))

# A tibble: 2 × 4
  ID    X1       X2    X3
  <chr> <chr> <dbl> <dbl>
1 AAA   f         1    44
2 BBB   x         2    56

# create a named vector
helper_rename_t2 <- name_tbl %>%
  select(global, T2) %>% # take the two variables needed
  drop_na() %>% # drop_na() is important here 
  deframe() # deframe creates the named vector

# rename with !!! 
(global_t2 <- 
  orig_t2 %>%
    rename(!!!helper_rename_t2))

# A tibble: 2 × 4
  ID    X1       X2    X3
  <chr> <chr> <dbl> <dbl>
1 FFF   f         2    53
2 BGG   f         1    23

(version1 <- bind_rows(global_t0, global_t1, global_t2))

# A tibble: 6 × 4
  ID    X1       X2    X3
  <chr> <chr> <dbl> <dbl>
1 A     m         1    NA
2 B     x         2    NA
3 AAA   f         1    44
4 BBB   x         2    56
5 FFF   f         2    53
6 BGG   f         1    23

# create a long df with matching variable names
var_names <- 
  name_tbl %>% 
  rename(to = global) %>% 
  pivot_longer(-to, names_to = "source", values_to = "from") %>% 
  select(source, from, to) %>% 
  drop_na()


# helper function to rename the cols
rename_cols <- function(.data, from, to) {
  dplyr::rename(.data, 
                !!!rlang::syms(
                  purrr::discard(
                    rlang::set_names(from, to), is.na(from))))
}


# helper function to table the cols
# to compare their content
table_cols <- function(.data, cols, ...) {
  purrr::map(cols, ~ base::table(.data[[.x]]), ...)
}


# creating a list of all dataframes that need to be renamed
data_list <- list(
  T0 = orig_t0,
  T1 = orig_t1,
  T2 = orig_t2
)

# Create a nested tibble, define the variables to 
# be rename for each row, apply the renaming, finbally validate the
# data_table (original dataframe) versus the output_table (renamed dataframe)

mapped_object <- 
  enframe(data_list, name = "source", value = "data") %>%
  mutate(mapping = map(source, ~ filter(var_names, source == .))) %>%
  hoist(mapping, from = "from", to = "to") %>%
  mutate(
    output = pmap(list(data, from, to), rename_cols), # renaming
    data_table = map2(data, from, table_cols, useNA = "always"), # validation
    output_table = map2(output, to, table_cols, useNA = "always"), # validation
    validate = map2_lgl(data_table, output_table, identical) # validation
  )


# from the mapped_pbject, 
# unnest the output - don't forget to store it into its own object
mapped_object %>% 
  select(output) %>% 
  unnest(cols = output)

# A tibble: 6 × 4
  ID    X1       X2    X3
  <chr> <chr> <dbl> <dbl>
1 A     m         1    NA
2 B     x         2    NA
3 AAA   f         1    44
4 BBB   x         2    56
5 FFF   f         2    53
6 BGG   f         1    23

# rename 
map2_dfr(
  list(orig_t0, orig_t1, orig_t2),
  list(name_tbl$T0, name_tbl$T1, name_tbl$T2), function(tdf, names) {
    real_names <- name_tbl$global[!is.na(names)]
    names <- keep(names, function(v) !is.na(v))
    tdf %>%
      rename(!!!rlang::syms(set_names(names, real_names)))
  }
)

# A tibble: 6 × 4
  ID    X1       X2    X3
  <chr> <chr> <dbl> <dbl>
1 A     m         1    NA
2 B     x         2    NA
3 AAA   f         1    44
4 BBB   x         2    56
5 FFF   f         2    53
6 BGG   f         1    23

Print calendar in R console

system("cal")

   February 2023      
Su Mo Tu We Th Fr Sa  
          1  2  3  4  
 5  6  7  8  9 10 11  
12 13 14 15 16 17 18  
19 20 21 22 23 24 25  
26 27 28              
                      

Because, why not? 😎 It even goes for a whole year:

system("cal 2021")

                            2021
      January               February               March          
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  
                1  2      1  2  3  4  5  6      1  2  3  4  5  6  
 3  4  5  6  7  8  9   7  8  9 10 11 12 13   7  8  9 10 11 12 13  
10 11 12 13 14 15 16  14 15 16 17 18 19 20  14 15 16 17 18 19 20  
17 18 19 20 21 22 23  21 22 23 24 25 26 27  21 22 23 24 25 26 27  
24 25 26 27 28 29 30  28                    28 29 30 31           
31                                                                

       April                  May                   June          
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  
             1  2  3                     1         1  2  3  4  5  
 4  5  6  7  8  9 10   2  3  4  5  6  7  8   6  7  8  9 10 11 12  
11 12 13 14 15 16 17   9 10 11 12 13 14 15  13 14 15 16 17 18 19  
18 19 20 21 22 23 24  16 17 18 19 20 21 22  20 21 22 23 24 25 26  
25 26 27 28 29 30     23 24 25 26 27 28 29  27 28 29 30           
                      30 31                                       

        July                 August              September        
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  
             1  2  3   1  2  3  4  5  6  7            1  2  3  4  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   5  6  7  8  9 10 11  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  12 13 14 15 16 17 18  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  19 20 21 22 23 24 25  
25 26 27 28 29 30 31  29 30 31              26 27 28 29 30        
                                                                  

      October               November              December        
Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  
                1  2      1  2  3  4  5  6            1  2  3  4  
 3  4  5  6  7  8  9   7  8  9 10 11 12 13   5  6  7  8  9 10 11  
10 11 12 13 14 15 16  14 15 16 17 18 19 20  12 13 14 15 16 17 18  
17 18 19 20 21 22 23  21 22 23 24 25 26 27  19 20 21 22 23 24 25  
24 25 26 27 28 29 30  28 29 30              26 27 28 29 30 31     
31                                                                

further reading and more elaborate stuff: https://www.garrickadenbuie.com/blog/r-console-calendar/

How it started

Thanks to google, I read numerous blog posts but did not understand much (not a regular command-line-user)…

• I gasped that using the .pkg-installer (double clicking through the GUI) will remove the previous version (noted here)

• I briefly played with the idea that instead I could unpack the .tar.gz-files and build from source as noted here - while I was finally able to run all steps (something alongside ./configure make etc) the version I installed was not placed in ~/Library/Frameworks/R.frameworks/ but remained in /usr/local/bin/R r emo::ji("weary") Not confident about meddling too much there another round of google was on.

• I finally came across this answer on SO: https://stackoverflow.com/a/66155919 - it is pointed out, that pkgutil --forget should not mention the name of the file I downloaded (which I did…) but the name of the pkgs inside the thing I downloaded - thanks for this very helpful clarification! With new hope I did this:

How it’s going

1. Download the package installer from the official page, eg. https://stat.ethz.ch/CRAN/bin/macosx/

2. Open the terminal and run the following line:

pkgutil --pkgs | grep -i org.r-project | xargs -I {} sudo pkgutil --forget {}

Entering sudo-mode I got prompted for the admin password.

3. Open the package installer and follow the GUI-prompts as usual

4. Check with RSwitch - the new (and the old versions) should be there r emo::ji("party")

Your data is… not in the right format!

You have a wide dataset of patient data, each patient identified through ID. They have been hospitalised multiple times, each place of hospitalisation and outcome listed in its own variable. Place and Outcome of a hospitalization are linked with the same suffix number, e.g. _2_2:

# load packages
suppressPackageStartupMessages(library(tidyverse))

# create sample data
patient_data <- 
tibble::tribble(~ID, ~Hosp_Place_1, ~Hosp_Outcome_1, ~Hosp_Place_2_2, 
                ~Hosp_Outcome_2_2, ~Hosp_Place_2_3, ~Hosp_Outcome_2_3, 
                1, "London", "Alive", "Paris", "alive", "Rome", "dead",
                2, "Paris", "alive", "Rome", "alive", "London", "alive",
                3, "Berne", "dead", NA_character_, NA_character_, NA_character_, NA_character_) 

# look at data
patient_data

# A tibble: 3 × 7
     ID Hosp_Place_1 Hosp_Outcome_1 Hosp_Place_2_2 Hosp_Outcom…¹ Hosp_…² Hosp_…³
  <dbl> <chr>        <chr>          <chr>          <chr>         <chr>   <chr>  
1     1 London       Alive          Paris          alive         Rome    dead   
2     2 Paris        alive          Rome           alive         London  alive  
3     3 Berne        dead           <NA>           <NA>          <NA>    <NA>   
# … with abbreviated variable names ¹​Hosp_Outcome_2_2, ²​Hosp_Place_2_3,
#   ³​Hosp_Outcome_2_3

Patient No. 3 died in his first hospitatisation, so the following variables are listed NA.

For some analysis, this data structure would work ok, but for your specific questions you need to switch the unit of analysis to “hospitalisation” instead of “patient”. In other words, you’d like to switch the data from wide to long.

Thanks to the tidyverse’s initiative of making clear function names, it might be obvious, that tidyr::pivot_longer() should do what you want.

Familiarize yourself with the function - What to do with tidyr::pivot_longer()?

The first step is to initially think about, what the outcome should look like and what input-arguments the function takes, so let’s do this:

# tidyr::pivot_long() and its arguments
tidyr::pivot_longer(data, 
                    cols, 
                    names_to = "name", 
                    names_prefix = NULL, 
                    names_sep = NULL, 
                    names_pattern = NULL,
                    names_ptypes = list(),
                    names_repair = "check_unique",
                    values_to = "value",
                    values_drop_na = FALSE,
                    values_ptypes = list())

As you can see, only data and cols are effectively needed, so let’s try that. As I want to exclude the Patient-ID from pivoting, I remove this line from pivoting:

# as with all the tidyverse functions you can easily pipe-in the data as 
# the first argument

# '-ID' means, that all variables are used other than ID
patient_data %>% 
  pivot_longer(cols = -ID)

# A tibble: 18 × 3
      ID name             value 
   <dbl> <chr>            <chr> 
 1     1 Hosp_Place_1     London
 2     1 Hosp_Outcome_1   Alive 
 3     1 Hosp_Place_2_2   Paris 
 4     1 Hosp_Outcome_2_2 alive 
 5     1 Hosp_Place_2_3   Rome  
 6     1 Hosp_Outcome_2_3 dead  
 7     2 Hosp_Place_1     Paris 
 8     2 Hosp_Outcome_1   alive 
 9     2 Hosp_Place_2_2   Rome  
10     2 Hosp_Outcome_2_2 alive 
11     2 Hosp_Place_2_3   London
12     2 Hosp_Outcome_2_3 alive 
13     3 Hosp_Place_1     Berne 
14     3 Hosp_Outcome_1   dead  
15     3 Hosp_Place_2_2   <NA>  
16     3 Hosp_Outcome_2_2 <NA>  
17     3 Hosp_Place_2_3   <NA>  
18     3 Hosp_Outcome_2_3 <NA>  

# I could have put the following instead, meaning selecting the variables I want
# but it was generally shorter to drop just the ID
# patient_data %>%
#   pivot_longer(cols = Hosp_Place_1:Hosp_Outcome_2_3)

Something clearly happened, but name and value are not exactly what we want here.
The colnames “name” and “value” are actually coming from the default arguments.
What is now the next step?

Mental image of desired outcome - How should my dataframe look like?

My desired output is a dataframe with the colum names ID, Hosp_Place and Hosp_Outcome. Additionally, I want a variable - lets call it hosp_sequence - that captures the number of the hospitalisation (you remember the suffix of the original variable names).

tidyr::pivot_longer()’s names_to =-arguments states in the help-page:
Can be a character vector, creating multiple columns, if names_sep or names_pattern is provided.

If you can detect any patterns in the column names, its possible to use them for the column naming. If we look at Hosp_Place_1 and Hosp_Outcome_1 we can clearly see a pattern: The information I want as name is Hosp_Place and Hosp_Outcome and the number followed should be put in variable called hosp_sequence.

This translates to something like (Hosp_Place)_(1) where the parts in brackets correspond to the inputs given in names_to =. With the .value-argument, I can easily take over the string as it is.

I actually found this very confusing (honestly - still do…) and I had great help for defining the regular expression from R4DS¹.

Finally, this is the code we need:

# this code should do the trick
patient_data %>% 
  pivot_longer(cols = -ID, 
               names_to = c(".value", "hosp_sequence"),
               names_pattern = '(^[A-z]+_[A-z]+)_([0-9].*)')

# A tibble: 9 × 4
     ID hosp_sequence Hosp_Place Hosp_Outcome
  <dbl> <chr>         <chr>      <chr>       
1     1 1             London     Alive       
2     1 2_2           Paris      alive       
3     1 2_3           Rome       dead        
4     2 1             Paris      alive       
5     2 2_2           Rome       alive       
6     2 2_3           London     alive       
7     3 1             Berne      dead        
8     3 2_2           <NA>       <NA>        
9     3 2_3           <NA>       <NA>        

Wait, what is happening with rows 8 and 9? This is my deceased Patient No. 3 an those are not hospitalisations anymore - how do I drop those rows?

# you can either use dplyr::drop_na() or specify the built-in argument to TRUE
patient_data %>% 
  pivot_longer(cols = -ID, 
               names_to = c(".value", "hosp_sequence"),
               names_pattern = '(^[A-z]+_[A-z]+)_([0-9].*)', 
               values_drop_na = TRUE)

# A tibble: 7 × 4
     ID hosp_sequence Hosp_Place Hosp_Outcome
  <dbl> <chr>         <chr>      <chr>       
1     1 1             London     Alive       
2     1 2_2           Paris      alive       
3     1 2_3           Rome       dead        
4     2 1             Paris      alive       
5     2 2_2           Rome       alive       
6     2 2_3           London     alive       
7     3 1             Berne      dead        

Comment

I wrote this blogpost after after solving exactly this issue with a real dataset for a colleague.
My work as a research programmer allows me to dive into data wrangling problems on a regular basis. As I learned most of my R skills from other blogposts from the fantastic R community, I started to write up some of the problems I encountered for others. I also use my previous blogposts sometimes, when I have to dig up old code…

Any comments from your side? Let me know!

Examples from the ggswissmaps-package

#install.packages("ggswissmaps")

suppressPackageStartupMessages(library(ggswissmaps))
suppressPackageStartupMessages(library(tidyverse))

# Data frame with the coordinates of all swiss districts
d <- shp_df[["g1b15"]]

# Look at the structure of the data frame
glimpse(d)

Rows: 19,502
Columns: 21
$ long    <int> 679207, 680062, 679981, 680365, 680281, 680479, 680717, 681021…
$ lat     <int> 245176, 244294, 244051, 243411, 241866, 241584, 240695, 240306…
$ order   <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,…
$ hole    <lgl> FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,…
$ piece   <fct> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,…
$ group   <fct> 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.…
$ id      <chr> "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0…
$ BZNR    <int> 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 10…
$ KTNR    <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,…
$ GRNR    <int> 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,…
$ AREA_HA <int> 11303, 11303, 11303, 11303, 11303, 11303, 11303, 11303, 11303,…
$ X_MIN   <int> 671862, 671862, 671862, 671862, 671862, 671862, 671862, 671862…
$ X_MAX   <int> 686462, 686462, 686462, 686462, 686462, 686462, 686462, 686462…
$ Y_MIN   <int> 229137, 229137, 229137, 229137, 229137, 229137, 229137, 229137…
$ Y_MAX   <int> 245396, 245396, 245396, 245396, 245396, 245396, 245396, 245396…
$ X_CNTR  <int> 678300, 678300, 678300, 678300, 678300, 678300, 678300, 678300…
$ Y_CNTR  <int> 235900, 235900, 235900, 235900, 235900, 235900, 235900, 235900…
$ Z_MIN   <int> 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 38…
$ Z_MAX   <int> 914, 914, 914, 914, 914, 914, 914, 914, 914, 914, 914, 914, 91…
$ Z_AVG   <int> 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 56…
$ Z_MED   <int> 557, 557, 557, 557, 557, 557, 557, 557, 557, 557, 557, 557, 55…

# The cantons are identified by the KTNR column
# Extract from this data the districts of two cantons (18 = Graubünden, 21 = Ticino)

two_cantons <- d %>% filter(KTNR  %in%  c(18, 21))

# And draw the map
maps2_(two_cantons)

This worked quite fine - but I was more interested in plotting by language region, so I did the following:

# add an aditional variable "region"
d %>% 
  mutate(region = case_when(KTNR == 21 ~ "Ticino",
                                 KTNR  %in% c(22, 23, 24, 25, 26) ~ "Romandie",
                                 TRUE ~ "Deutschschweiz")) -> d

# draw a ggplot 
ggplot(d, aes(x = long, y = lat, group = group)) +
  geom_polygon(aes(fill = factor(region)), color = "black") +
  scale_fill_manual(name = "Region",
                   values = c("Ticino" = "grey90",
                              "Romandie" = "#b2df8a",
                              "Deutschschweiz" = "#a6cee3")) +
  theme_void() +
  theme(legend.position = "bottom") +
  coord_equal()

Troubleshooting

What is the problem with this plot (aside from the ugly black color of the boundaries)? The boundaries correspond to district, not cantonal level (what I wanted). As the variable KTNR identifies the cantons, I did the following:

# draw a ggplot and changed to aes(....group = KTNR)
ggplot(d, aes(x = long, y = lat, group = KTNR)) +
  geom_polygon(aes(fill = factor(region)), color = "black") +
  scale_fill_manual(name = "Region",
                   values = c("Ticino" = "grey90",
                              "Romandie" = "#b2df8a",
                              "Deutschschweiz" = "#a6cee3")) +
  theme_void() +
  theme(legend.position = "bottom") +
  coord_equal()

…It got even worse…

I did not understand why at first. After a brief online exchange in the Rladies-Slack (sidenote: fantastic place to learn! 😎), I realized that my problem is with the data: aes(x = long, y = lat) in my dataframe correspond to district level not cantonal level. Unfortunately, the link on the website of the Federal Office of Statistics didn’t work either¹, so what to do else?

Look at the data structure:

# a list containing 8 elements (dataframes)
# which each contain lon/lat on different levels
class(shp_df)

[1] "list"

# very long output, not shown here
#str(shp_df)

I now knew that I could use the plot from above and check each element of the list - either by hand (corresponding to seven times copy/paste) or with purrr::map()!

Solution

# create a function to map over each element of the list to
# identify if one is on cantonal-level
my_plot <- function(data){
  
  ggplot2::ggplot(data = data, ggplot2::aes(x = long, y = lat, group = group)) +
    ggplot2::geom_polygon() +
    ggplot2::theme_void() +
    coord_equal()
  
}

Then do the magic (1 simple line of code will give me 8 plots!):

# map it over the list
purrr::map(ggswissmaps::shp_df, ~my_plot(.x))

$g1b15

$g1g15_encl

$g1g15_li

$g1g15

$g1k15

$g1l15

$g1r15

$g1s15

From the plots above I now know which dataframe to use:

# solution: the second last element of the list is what I need
cant_level <- 
  ggswissmaps::shp_df$g1k15 %>% 
      mutate(region = case_when(KTNR == 21 ~ "Ticino",
                                KTNR  %in% c(22, 23, 24, 25, 26) ~ "Romandie",
                                TRUE ~ "Deutschschweiz"))

# draw the prettier graph
ggplot(cant_level, aes(x = long, y = lat, group = group)) +
  geom_polygon(aes(fill = factor(region))) +
  scale_fill_manual(name = "Region",
                   values = c("Ticino" = "grey90",
                              "Romandie" = "#b2df8a",
                              "Deutschschweiz" = "#a6cee3")) +
  theme_void() +
  theme(legend.position = "bottom") +
  coord_equal()

The output is what I wanted - altough we could improve it, as the lakes (which are left out in the district-level data) are not shown here…

Edit:

thanks to the ggswissmaps-maintainer gibo’s help, the maps look now much prettier:

ggplot(cant_level, aes(x = long, y = lat, group = group)) +
  geom_polygon(aes(fill = factor(region)), color = "white", size = 0.1) +
  scale_fill_manual(name = "Region",
                    values = c("Ticino" = "grey90",
                               "Romandie" = "#b2df8a",
                               "Deutschschweiz" = "#a6cee3")) +
  theme_void() +
  theme(legend.position = "bottom") +
  coord_equal() + # add a layer for the lakes
  geom_polygon(aes(x = long, y = lat, group = group), 
               data = shp_df[["g1s15"]], fill = NA, alpha = .5, color = "#0529B3", size = .1, lty = "solid")

Warning: Using `size` aesthetic for lines was deprecated in ggplot2 3.4.0.
ℹ Please use `linewidth` instead.

Introduction - what were the problems I faced?

The topic of my master’s thesis - unfinished / missed / rationed nursing care - is an important topic in health services research with growing numbers of publications over the last years. Altough I did not have to use R extensively during my thesis, in one specific case I greatly profited from it:

Usually, PubMed provides a small graphical display of the yearly publication count on each query as shown in the image below:

For some reason it failed for my exact search query. This was especially bad because I had to make a somehow valid statement that the publication numbers were increasing over the last years. If I only could get all meta data (i.e. years) from my query (~900) into a spreadsheet…¹

At some point I realized that the PubMed database should be accessible and I was sure that R has a solution to it - that’s how I found the RISmed-package.

RISmed package

In short: the RISmed package provides functions to extract bibliographic information from
the NCBI databases. In other words: you can extract the information from PubMed through R code - exactly what I needed!

# load necessary packages
library(tidyverse)
library(RISmed)

# build the search topic
search_topic <- 'missed care [TI] OR implicit rationing [TI] OR unfinished care [TI]'

# the EUtilsSummary()-function gets information on your search results
# (maximum results set as 1000, years between 1980 and 2019)
search_query <- EUtilsSummary(search_topic, retmax=1000, mindate=1980,maxdate=2019)

Warning in any(is.na(WhichArgs)) || sapply(WhichArgs, length) > 1: 'length(x) =
3 > 1' in coercion to 'logical(1)'

# Printing the summary displays the actual results that are available
summary(search_query)

Query:
("missed care"[Title] OR "implicit rationing"[Title] OR "unfinished care"[Title]) AND 1980/01/01:2019/12/31[Date - Entry] 

Result count:  66

# see the PMIIDs of our returned query
QueryId(search_query)

 [1] "31883182" "31850645" "31845542" "31773131" "31680364" "31596988"
 [7] "31583822" "31529752" "31334567" "31305955" "30937945" "30866129"
[13] "30686577" "30681485" "30589706" "30475323" "30303195" "30303194"
[19] "30303193" "30145041" "30095046" "29791753" "29655017" "29569380"
[25] "29554590" "29471742" "29281908" "28978300" "28971888" "28960457"
[31] "28844649" "28599196" "27556651" "27492884" "27322941" "27292861"
[37] "27234155" "29718634" "26947419" "26259338" "26032730" "25794946"
[43] "25563066" "25430513" "24681453" "24681452" "24481345" "24397252"
[49] "24248553" "23991529" "23334645" "23084600" "22674763" "20661063"
[55] "19590471" "18055900" "16323493" "11467274" "10862990" "9694173" 
[61] "10173241" "8611380"  "7549650"  "7549649"  "7795458"  "8332926" 

# get the actual data from PubMed and store them in an object called records
records <- EUtilsGet(search_query, type = "efetch", db = "pubmed")

# check what kind of object "records" is
class(records)

[1] "Medline"
attr(,"package")
[1] "RISmed"

# store it in either list or dataframe (Author() returns a list, therefore 
# list chosen here)
pubmed_data_list <- list('Title' = ArticleTitle(records), 
                         'Authors' = Author(records), 
                         'Year' = YearPubmed(records), 
                         'Journal' = Title(records),
                         'PublicationType' = PublicationType(records),
                         'Language' = Language(records))

# version without Authors for dataframe
pubmed_data <- data.frame('Title' = ArticleTitle(records),
                    'Year' = YearPubmed(records), 
                    'Journal' = Title(records),
                    'Language' = Language(records))

# plot the yearcount
ggplot(pubmed_data, aes(x = factor(Year))) +
  geom_bar() +
  scale_y_discrete() +
  labs(x = "Year",
       y = "No. of publications") +
  theme_classic()

How could my thesis profit from the RISmed package?

The figure I created² helped me visualize meta information on the publications: I could clearly see that the topic unfinished nursing care has been mentioned with increasing tendency in publications. This gave me valid data for accepting my assumption.

Due to the nature of my thesis, I (sadly) didn’t have to use the exact numbers. Yet, I still learned two useful things 💡:

1. Using bibliographic information to inform your research may be helpful and should not be forgotten.

2. I felt like I reached a whole new level of R’s numerous capabilities: Using an R package to connect to a web-database should not be the end of my discoveries 😃

Notes on this post:

• Be careful with the search query - there can be differences in using different codes, see here: https://stackoverflow.com/questions/32994991/r-package-rismed-different-results-using-the-eutilsget-or-summary-function

• Dowloading information from PubMed (EUtilsGet()) can take a while

• I had some trouble with long search terms (no further explanation found)