Household Survey Data Check

Description

This tool performs a data check and validation over the datasets collected on the Household Survey, for those indicators which might have not been pre-validated by the Kobo form constrains. It generates an excel file highligting all the identified entries with at least one validation error in order to be reviewed back by the enumerators.

Input:

A Household Survey file as generated by Kobo for a given Governorate. The tool can be easily adapted to merge all the single governorate files into a single dataframe.

Output:

An excel file containing just the new identified shelter on the given period. The column headers are renamed to match the required format and column names

Main functions

This tool does not make use of any specific custom functions.

Configuration

Specify the default data input and output directories, and several data vectors needed by the tool:

HH_members_cols: vector containing the column names to be selected from the Demographic Section (C1)
HH_absent_cols: vector containing the column names to be selected from the Absent Members Section
shelter_lookup: vector containing the values for the Shelter option (B1)
dwelling_map: named vector containg the dwelling types and a code which maps them to the possible shelter types
warning_column_names: vector containing the list of warning messages to be added to the final excel output
suggestion_column_names: vector containing the list of suggested answers to review to be added to the final excel output

Data Load

The input file is expected to be placed under the data subdirectory. The readxl library is used instead of openxlsx as the latter was having some issues in correctly reading the Kobo output. The Household Survey in Kobo stores the collected data in three sheets, the first being the main one and the other two used for the ‘children’ values (in this case the members of a single household, either present or absent). Each of the sheets is stored in a separate dataframe for later processing.

HH_dataset_main <- readxl::read_xlsx(filepath, sheet = 1)
HH_dataset_members <- readxl::read_xlsx(filepath, sheet = 2)
HH_dataset_absent <- readxl::read_xlsx(filepath, sheet = 3)

Process

We need first to clean a little bit the datasets and remove some ‘false’ columns added by Kobo. Using dplyr and select(-starts_with("<")) we can remove the culprit columns. The starts_with("<") helper finds those columns matching the given string and the minus sign performs the removal.

#remove warning columns start with < or (
HH_dataset_main <- HH_dataset_main %>% select(-starts_with("<")) %>% select(-starts_with("("))
HH_dataset_members <- HH_dataset_members %>% select(-starts_with("<")) %>% select(-starts_with("("))
HH_dataset_absent <- HH_dataset_absent %>% select(-starts_with("<")) %>% select(-starts_with("("))

We get the range of indexes corresponding to the columns to be selected from the main dataset. This could also be acommplished by defining a vector of column names under Configuration, however the get_range_indexes() function (defined in HNAP utils.R library) makes things a little easier as it allows to get the range of several consecutive columns as once, by just specifying the initial and final columns. The get_col_indexes() gets just the index of either one or two columns defined in the parameters. The append() function adds a vector at the end of an existing vector provided as input, in this case the range vector.

# get range of demographic columns to select from HH dataset
range <- get_range_indexes(HH_dataset_main, "Date of Visit", "Pcode = ${admin4}")
range <- append(range, get_col_indexes(HH_dataset_main, "B1. Type of Shelter"))
range <- append(range, get_range_indexes(HH_dataset_main, "Name of HoH" , "HH Type"))
range <- append(range, get_range_indexes(HH_dataset_main, "HH member type of interviewee", "SELF CARE"))
...

We subset each dataset by selecting only the columns we will be working with. That step is not really necessary as R can deal with the full datasets, though it can actually save some memory and speed things up a little bit. Also it makes easier to work with the datasets when displaying their contents on the View pannel. The *_uuid* gets also renamed using the rename()function from dplyr
Before combining the datasets, we need to make sure the column types match. It is common that the expected numerical columns are coerced as non-numerical, either character or unknown type, sometimes due to the presence of NA values on the original dataset or other reasons. In order to coerce those columns containing values that are expected to remain numerical, we use the type_convert() function from the HNAP utils.R library. This function will perform a ‘soft coertion’ over each dataframe column, affecting only those columns with expected numerical columns (meaning those columns containing only numbers, or numbers and blank cells/NA values). In that case the character numbers will be coerced to numerical and the empty cell will be coerced to NA. If a given column contains any true character value (meaning a non-numerical string of text), it will be left as it is.
IMPORTANT! We need to apply type_convert() over all the columns of the dataset, therefore we use the lapply() function to perform this operation over all the column elements of the dataframe (an efficient iteration). The initial output will be a list object containing each converted column. By simply specyfing the output variable as HH_demo[] with the brackets [] we can automatically store back the list elements as dataframe elements (sort of binding them on-the-fly).

# select columns to combine for each dataset and coerce to numeric all those character columns holding numeric values before binding so all columns from each subset match type

HH_demo <- HH_dataset_main %>% 
  select(range) %>% 
  rename(uuid = "_uuid")
HH_demo[] <- lapply(HH_demo, type_convert)

HH_members <- HH_dataset_members %>% 
  select(HH_members_cols) %>% 
  rename(uuid = "_submission__uuid")
HH_members[] <- lapply(HH_members, type_convert)

HH_absent <- HH_dataset_absent %>%
  select(HH_absent_cols) %>% 
  rename(uuid = "_submission__uuid")
HH_absent[] <- lapply(HH_absent, type_convert)

We start the processing of the combined HH_all dataframe using the dplyr library and “pipelining” the different actions, starting with selecting the columns needed for the validation analysis. Some of the columns will be renamed for better manipulation later on the pipeline

HH_data_check_temp <- HH_all %>%
  select(uuid, 
         `Enumerator Code`,
         Governorate = Governorate...5,
         District = District...6,
         Subdistrict = `Sub-district...7`,
         Community = Community...8,
         Name_HoH = `Name of HoH`,
         ...

We use mutate() to create new additional columns where several logical validations are calculated according to the required constrains. Some of these columns will get TRUE or FALSE values depending on the result of the performed boolean operation.

 mutate(check_hhh = (`HH member type` == "Head of Household"), 
         check_hhh_married = (`HH member type` == "Head of Household" & `Marital status` == "Married"), 
         check_spouse = (`HH member type` == "Spouse"),
         check_child = ((`If no, why?` == "child") | (`If no, why?` == "student" & `Age - Year` < 18)),
         check_student_age = ((`If no, why?` == "child" & `Age - Year` >= 6) | (`If no, why?` == "student" & `Age - Year` >= 6)),
         check_not_student_age = (`If no, why?` == "child" & `Age - Year` < 6),
         check_child_work = (child_work == "1"),
         check_child_school = (child_school == "No children in schools"),
         ...

Other added columns are used to store calculated values resulting from the sum of the contents of several cells on the same row. As dplyr works columnwise, we need to specify that the sum operation needs to be carried on rowwise. The rowSums() function will perform the row sums for the selected columns. Please notice that in this case, the select() function needs to explicitely refer the target dataframe as it was at the end of the last “pipelined” operation. We use the . for such reference. This is needed because the use of rowSums() somehow “breaks” the columwise behaviour of dplyr, so we cannot use select() without explicitelly specifying the target dataframe.

         water = rowSums(select(.,`i) % for Network`:`ix) % for Other (specify)`), na.rm = TRUE), # sum percentages from different water sources
         number_containers = rowSums(select(.,`How many liters does hold the roof tank?`:`How many liters does hold the SmallHouseHolds?`), na.rm = TRUE), # sum total number of containers
         perc_spent = rowSums(select(., perc_water, perc_hygiene, perc_garbage, perc_septic), na.rm = TRUE), # sum percentages of income spent
...

Some new columns require an arithmetical operation which might give a double as output. Even if the column type is the generic numeric, there can be some issues when using rowSums() later on and referring to this columns, as other numeric columns are integer. Therefore to avoid errors, the calculated column is coerced to integer using as.integer().

         hygiene_purchase_monthly = as.integer(hygiene_purchase/3), # divide by 3 to get monthly and coerce to integer to avoid type mismatch
         septic_purchase_monthly = as.integer(septic_purchase/3), # divide by 3 to get monthly and coerce to integer to avoid type mismatch
...

The type of shelter and type of dwelling are related in a 1-to-many fashion as described by the dwelling_map named vector, which maps a given dwelling to the different type of shelters that can belong. This mapping is coded by referring to the shelter types via their numerical index in the shelter_lookup vector.
The match() function allows to look up a given value or pattern inside a lookup vector, in this case the shelter_lookup, and it will return the position index of the value in case a matching is found.
Once obtained the shelter indexes, we need to check for each shelter index in the column whether it is found in the selected dwelling “map”. This operation is performed by the custom check_pattern_vector() from the HNAP utils.R library. This function applies the grepl() R function over the whole column using mapply(). For each value of the column shelter_inde(), grepl() will check if the value is found within the mapping string defined for the selected dwelling.

         shelter_index = match(shelter, shelter_lookup), # lookup shelter index in shelter_type table
         check_dwelling = check_pattern_vector(shelter_index, dwelling_map[dwelling])) %>% # check if shelter index is mapped by the dwelling type
  ...

The next step is to group all the rows by a common uuid in order to calculate summarised results
When using group_by, only the selected summarised values are present in the output dataframe. If we want to also include, for informational purposes, columns which are not summarised or aggregated in the output (for example some character type columns), we can accomplish that by using the first() function, which will select the first element found for that columns (as the rest of elements for that column under that group are in any case repeated).
Some totals are also calculated, such as total_hh_income, as they will be needed to perform specific logical tests on the *_flag* columns.
The *_flag* are where the final logic checks for the specifics constraints are performed. The output will be TRUE or FALSE depending on whether the validation test has been passed or not for that constraint.

  group_by(uuid) %>%
  summarise(enumerator = first(`Enumerator Code`),
            Governorate = first(Governorate),
            District = first(District),
            Subdistrict = first(Subdistrict),
            Community = first(Community),
            Name_HoH = first(Name_HoH),
            total_hh_income = sum(hh_income, na.rm = TRUE),
            single_head_flag = ifelse((sum(check_hhh, na.rm = TRUE) == 1), TRUE, FALSE), # C1: there is a single head of household
            hh_married = ifelse((single_head_flag == TRUE & sum(check_hhh_married, na.rm = TRUE) == 1) , TRUE, FALSE), # check if married
            spouse = ifelse((single_head_flag == TRUE & sum(check_spouse, na.rm = TRUE) >= 1) , TRUE, FALSE), #check if spouse when single head household
            spouse_flag = ifelse((hh_married == TRUE & spouse == TRUE) | (hh_married == FALSE & spouse == FALSE), TRUE, FALSE), # C1: check if there are spouse/s if married or no spouse if not married
            monthly_income = sum(`Average monthly income in SYP`, na.rm = TRUE), # sum monthly incomes for all household members
            income_flag = ifelse(monthly_income <= sum(hh_income, na.rm = TRUE), TRUE, FALSE), # C3: chech if combined monthly income less or equal than reported average monthly income
            child = ifelse((sum(check_child, na.rm = TRUE) >= 1), TRUE, FALSE), # check if more than one child in household
            ...

We finally add a new columns in order to check if the household has passed all the constraints (all flags are TRUE). This is performed by calculating the arithmetical mean for that row. The rowMeans() function works in a similar manner as rowSums() in the sense that it breaks the dplyr behaviour and performs the calculation rowwise. For that reason, select() is also used in the same manner as with rowSums(). The ends_with() will make sure all the *_flag* columns are selected. As each TRUE value is automatically coerced to 1, the arithmetical mean will need to equal 1 in case all values are TRUE.

  mutate(alltrue_check = rowMeans(select(., ends_with("flag"))))# check mean value of all flags per row. TRUE equals to 1.
...

The resulting dataframe HH_data_check_temp will receive now two different treatments depending on its final use, either intended for the Enumerators, or for HNAP Information Management Unit for additional parameters review.
HH_data_check_field stores the final output for the Enumerator in the field. It simply filters out those records that do not need to be reviewed and select the flag columns which highlights the ones which have to be reviewed for each household record.

# HH dataset validated for the Enumerators to check
HH_data_check_field <- HH_data_check_temp %>%
  filter(alltrue_check != 1) %>% # filter out rows which are all TRUE, no need to review. All flags TRUE mean coerces to exactly 1.
  select(uuid, enumerator, Governorate, District, Subdistrict, Community, Name_HoH, ends_with("flag"))

For the internal review, there are several columns that might need to be reviewed in order to highlight potential outlier values that could have been recorded accidentally. Two approaches are taken, and for each of them a different dataframe is used for the final output. The first one assumes a nearly normal distribution for the specific column values (for example, the total_hh_income) and detects whether the value falls within the 95% confidence interval or not (which corresponds approximately to two standard deviations either side of the data mean). The 95% value can be changed in the custom function get_qnorm_range(), which gets the lower and upper quantiles for that specific confidence interval. The final results will then depend on the confidence interval level used, though it might highlight values which though uncommon, still fall within a reasonable margin. In order to check if a given value of total_hh_income is within the calculated range, we use the custom check_in_range() function, as defined within the HNAP utils.R library, which will output TRUE or FALSE depending on the row value for that indicator.
IMPORTANT! Currently, the script only implements the outliers checking for the total_hh_income indicator. This can be extended to other indicators as needed, following exactly the same procedure.

# HH dataset validated for internal review of value ranges (using normal distribution probability rule at 95%)
HH_data_check_internal_qnorm <- HH_data_check_temp %>%
mutate(hh_income_range_check = check_in_range(total_hh_income, get_qnorm_range(total_hh_income, 0.95))) %>%
select(uuid, enumerator, Governorate, District, Subdistrict, Community, Name_HoH, total_hh_income, hh_income_range_check, ends_with("flag"))
...

The second approach takes a more systematic way in order to find the outliers. It makes use of the commonly accepted Interquartile Range Rule or 1.5*IQR rule and could be more effective in order to straightforward detect those anomalous values caused by accidental input. This rule is implemented with the custom function get_outlier_range().

# HH dataset validated for internal review of value ranges (using 1.5*IQR rule for outlier detection)
HH_data_check_internal_iqr <- HH_data_check_temp %>%
  mutate(hh_income_range_check = check_in_range(total_hh_income, get_outlier_range(total_hh_income))) %>%
  select(uuid, enumerator, Governorate, District, Subdistrict, Community, Name_HoH, total_hh_income, hh_income_range_check, ends_with("flag"))
...

Output

The script generates an excel output file intended for the Enumerator, which contains the results stored in the HH_data_check_field. It makes use of the openxlsx library and it defines several formatting styles for the different sections of the excel sheet.

# create an excel workbook and sheet
output_file <- paste0(output_dir, "/", file_title, " - Data Check - Field.xlsx")
n_rows <- nrow(HH_data_check_field)
n_cols <- ncol(HH_data_check_field)
wb <- createWorkbook()
addWorksheet(wb, "HH Sample Size")
setColWidths(wb, sheet = 1, cols = 1:n_cols, widths = "20")


# set styles
top_row_style <- createStyle(wrapText = TRUE, valign = "center", fgFill = "#E8E8E8")
falseStyle <- createStyle(fontColour = "#9C0006", bgFill = "#FFC7CE")
trueStyle <- createStyle(fontColour = "#006100", bgFill = "#C6EFCE")
conditionalFormatting(wb, sheet = 1, cols = 8:18, rows = 3:(n_rows + 3), type = "contains", rule = "TRUE", style = trueStyle)
conditionalFormatting(wb, sheet = 1, cols = 8:18, rows = 3:(n_rows + 3), type = "contains", rule = "FALSE", style = falseStyle)
...

Two additional rows are added to the top of the table, containing specific information on the type of constrain check performed and also suggestions on the survey questions to review in the original data. Special formatting is added to these rows using the addStyle() function from the openxlsx package. To maintain previous loaded styles, use the stack = TRUE parameter.

# create warning and suggestion rows
warning_row <- as.data.frame(t(warning_column_names))
suggestion_row <- as.data.frame(t(suggestion_column_names))
writeData(wb, sheet = 1, warning_row, startRow = 1, startCol = 8, colNames = FALSE, borders = "all")
addStyle(wb, sheet = 1, top_row_style, rows = 1, cols = 8:18, gridExpand = TRUE, stack = TRUE)
writeData(wb, sheet = 1, suggestion_row, startRow = 2, startCol = 8, colNames = FALSE, borders = "all")
addStyle(wb, sheet = 1, top_row_style, rows = 2, cols = 8:18, gridExpand = TRUE, stack = TRUE)
...

The data is finally exported

# export result into excel
writeDataTable(wb, sheet = 1, HH_data_check_field, startRow = 3, startCol = 1)
saveWorkbook(wb, file = output_file, overwrite = TRUE)
...

Running everything!

The HH-survey-check.R main script contains the source files in the order that need to be loaded and run. The here library will deal with relative and direct path issues to make it issue running the tool under different file systems. It takes the root directory (the one containing the Rstudio .rproj file) as reference. The *_common* directory stores the common scripts used across all HNAP tools, defining the minimum required libraries and several commonly used functions. The rest of the tool scripts are loaded sequentially. Use the Source button on RStudio to run the whole sequence.

# load here library hto handle relative paths from project ROOT
library(here)

source(here("R", "_common", "required.R"))
source(here("R", "_common", "utils.R"))
source(here("R", "HH_survey_check", "01-hh-required.R"))
source(here("R", "HH_survey_check", "02-hh-functions.R"))
source(here("R", "HH_survey_check", "03-hh-config.R"))
source(here("R", "HH_survey_check", "04-hh-dataload.R"))
source(here("R", "HH_survey_check", "05-hh-process.R"))
source(here("R", "HH_survey_check", "06-hh-output.R"))

---
title: "Household Survey Data Check"
output:
  html_notebook: default
  pdf_document: default
---
### Description
This tool performs a data check and validation over the datasets collected on the Household Survey, for those indicators which might have not been pre-validated by the Kobo form constrains. It generates an excel file highligting all the identified entries with at least one validation error in order to be reviewed back by the enumerators.

#### Input:
A Household Survey file as generated by Kobo for a given Governorate. The tool can be easily adapted to merge all the single governorate files into a single dataframe.

#### Output:
An excel file containing just the new identified shelter on the given period. The column headers are renamed to match the required format and column names

### Main functions

This tool does not make use of any specific custom functions.
```{r echo=FALSE}
# ONLY for Notebook: do not run (eval) chunks when knitting notebook. Applies to all chunks
knitr::opts_chunk$set(eval = FALSE)

```

### Configuration
Specify the default data input and output directories, and several data vectors needed by the tool:

* `HH_members_cols`: vector containing the column names to be selected from the Demographic Section (C1)

* `HH_absent_cols`: vector containing the column names to be selected from the Absent Members Section

* `shelter_lookup`: vector containing the values for the Shelter option (B1)

* `dwelling_map`: named vector containg the dwelling types and a code which maps them to the possible shelter types

* `warning_column_names`: vector containing the list of warning messages to be added to the final excel output

* `suggestion_column_names`: vector containing the list of suggested answers to review to be added to the final excel output


### Data Load
The input file is expected to be placed under the `data` subdirectory. The **readxl** library is used instead of **openxlsx** as the latter was having some issues in correctly reading the Kobo output. The Household Survey in Kobo stores the collected data in three sheets, the first being the main one and the other two used for the 'children' values (in this case the members of a single household, either present or absent). Each of the sheets is stored in a separate dataframe for later processing.

```{r}
HH_dataset_main <- readxl::read_xlsx(filepath, sheet = 1)
HH_dataset_members <- readxl::read_xlsx(filepath, sheet = 2)
HH_dataset_absent <- readxl::read_xlsx(filepath, sheet = 3)
```

### Process


(@) We need first to clean a little bit the datasets and remove some 'false' columns added by Kobo. Using **dplyr** and `select(-starts_with("<"))` we can remove the culprit columns. The `starts_with("<")` helper finds those columns matching the given string and the minus sign performs the removal.

```{r}
#remove warning columns start with < or (
HH_dataset_main <- HH_dataset_main %>% select(-starts_with("<")) %>% select(-starts_with("("))
HH_dataset_members <- HH_dataset_members %>% select(-starts_with("<")) %>% select(-starts_with("("))
HH_dataset_absent <- HH_dataset_absent %>% select(-starts_with("<")) %>% select(-starts_with("("))
```

(@) We get the *range* of indexes corresponding to the columns to be selected from the main dataset. This could also be acommplished by defining a vector of column names under **Configuration**, however the `get_range_indexes()` function (defined in HNAP *utils.R* library) makes things a little easier as it allows to get the range of several consecutive columns as once, by just specifying the initial and final columns. The `get_col_indexes()` gets just the index of either one or two columns defined in the parameters. The `append()` function adds a vector at the end of an existing vector provided as input, in this case the *range* vector.

```{r}
# get range of demographic columns to select from HH dataset
range <- get_range_indexes(HH_dataset_main, "Date of Visit", "Pcode = ${admin4}")
range <- append(range, get_col_indexes(HH_dataset_main, "B1. Type of Shelter"))
range <- append(range, get_range_indexes(HH_dataset_main, "Name of HoH" , "HH Type"))
range <- append(range, get_range_indexes(HH_dataset_main, "HH member type of interviewee", "SELF CARE"))
...
```

(@) We *subset* each dataset by selecting only the columns we will be working with. That step is not really necessary as R can deal with the full datasets, though it can actually save some memory and speed things up a little bit. Also it makes easier to work with the datasets when displaying their contents on the *View* pannel. The *_uuid* gets also renamed using the `rename()`function from **dplyr**
(@) Before combining the datasets, we need to make sure the column types match. It is common that the expected *numerical* columns are coerced as *non-numerical*, either *character* or *unknown* type, sometimes due to the presence of `NA` values on the original dataset or other reasons. In order to coerce those columns containing values that are expected to remain *numerical*, we use the `type_convert()` function from the HNAP **utils.R** library. This function will perform a 'soft coertion' over each dataframe column, affecting only those columns with expected numerical columns (meaning those columns containing only numbers, or numbers and blank cells/NA values). In that case the character numbers will be coerced to numerical and the empty cell will be coerced to `NA`. If a given column contains any true *character* value (meaning a non-numerical string of text), it will be left as it is. 
(@) <span style="color:red">**IMPORTANT!**</span> We need to apply `type_convert()` over all the columns of the dataset, therefore we use the `lapply()` function to perform this operation over all the column elements of the dataframe (an efficient iteration). The initial output will be a *list* object containing each converted column. By simply specyfing the output variable as `HH_demo[]` with the brackets `[]` we can automatically store back the list elements as dataframe elements (sort of *binding* them on-the-fly).

```{r}
# select columns to combine for each dataset and coerce to numeric all those character columns holding numeric values before binding so all columns from each subset match type

HH_demo <- HH_dataset_main %>% 
  select(range) %>% 
  rename(uuid = "_uuid")
HH_demo[] <- lapply(HH_demo, type_convert)

HH_members <- HH_dataset_members %>% 
  select(HH_members_cols) %>% 
  rename(uuid = "_submission__uuid")
HH_members[] <- lapply(HH_members, type_convert)

HH_absent <- HH_dataset_absent %>%
  select(HH_absent_cols) %>% 
  rename(uuid = "_submission__uuid")
HH_absent[] <- lapply(HH_absent, type_convert)
```

(@) We start the processing of the combined `HH_all` dataframe using the **dplyr** library and "pipelining" the different actions, starting with selecting the columns needed for the validation analysis. Some of the columns will be renamed for better manipulation later on the pipeline

```{r}
HH_data_check_temp <- HH_all %>%
  select(uuid, 
         `Enumerator Code`,
         Governorate = Governorate...5,
         District = District...6,
         Subdistrict = `Sub-district...7`,
         Community = Community...8,
         Name_HoH = `Name of HoH`,
         ...
```

(@) We use `mutate()` to create new additional columns where several logical validations are calculated according to the required constrains. Some of these columns will get `TRUE` or `FALSE` values depending on the result of the performed boolean operation. 

```{r}
 mutate(check_hhh = (`HH member type` == "Head of Household"), 
         check_hhh_married = (`HH member type` == "Head of Household" & `Marital status` == "Married"), 
         check_spouse = (`HH member type` == "Spouse"),
         check_child = ((`If no, why?` == "child") | (`If no, why?` == "student" & `Age - Year` < 18)),
         check_student_age = ((`If no, why?` == "child" & `Age - Year` >= 6) | (`If no, why?` == "student" & `Age - Year` >= 6)),
         check_not_student_age = (`If no, why?` == "child" & `Age - Year` < 6),
         check_child_work = (child_work == "1"),
         check_child_school = (child_school == "No children in schools"),
         ...
```

(@) Other added columns are used to store calculated values resulting from the sum of the contents of several cells on the same row. As **dplyr** works columnwise, we need to specify that the sum operation needs to be carried on *rowwise*. The `rowSums()` function will perform the row sums for the selected columns. Please notice that in this case, the `select()` function needs to explicitely refer the target dataframe as it was at the end of the last "pipelined" operation. We use the `.` for such reference. This is needed because the use of `rowSums()` somehow "breaks" the *columwise* behaviour of **dplyr**, so we cannot use `select()` without explicitelly specifying the target dataframe.

```{r }
         water = rowSums(select(.,`i) % for Network`:`ix) % for Other (specify)`), na.rm = TRUE), # sum percentages from different water sources
         number_containers = rowSums(select(.,`How many liters does hold the roof tank?`:`How many liters does hold the SmallHouseHolds?`), na.rm = TRUE), # sum total number of containers
         perc_spent = rowSums(select(., perc_water, perc_hygiene, perc_garbage, perc_septic), na.rm = TRUE), # sum percentages of income spent
...
```

(@) Some new columns require an arithmetical operation which might give a *double* as output. Even if the column type is the generic *numeric*, there can be some issues when using `rowSums()` later on and referring to this columns, as other *numeric* columns are *integer*. Therefore to avoid errors, the calculated column is coerced to integer using `as.integer()`.

```{r}
         hygiene_purchase_monthly = as.integer(hygiene_purchase/3), # divide by 3 to get monthly and coerce to integer to avoid type mismatch
         septic_purchase_monthly = as.integer(septic_purchase/3), # divide by 3 to get monthly and coerce to integer to avoid type mismatch
...
```

(@) The *type of shelter* and *type of dwelling* are related in a *1-to-many* fashion as described by the `dwelling_map` named vector, which maps a given *dwelling* to the different type of *shelters* that can belong. This *mapping* is coded by referring to the *shelter types* via their numerical index in the `shelter_lookup` vector.
(@) The `match()` function allows to look up a given value or pattern inside a lookup vector, in this case the `shelter_lookup`, and it will return the position index of the value in case a matching is found.
(@) Once obtained the shelter indexes, we need to check for each shelter index in the column whether it is found in the selected dwelling "map". This operation is performed by the custom `check_pattern_vector()` from the HNAP **utils.R** library. This function applies the `grepl()` R function over the whole column using `mapply()`. For each value of the column `shelter_inde()`, `grepl()` will check if the value is found within the mapping string defined for the selected *dwelling*. 
```{r}
         shelter_index = match(shelter, shelter_lookup), # lookup shelter index in shelter_type table
         check_dwelling = check_pattern_vector(shelter_index, dwelling_map[dwelling])) %>% # check if shelter index is mapped by the dwelling type
  ...
```

(@) The next step is to group all the rows by a common `uuid` in order to calculate summarised results
(@) When using `group_by`, only the selected summarised values are present in the output dataframe. If we want to also include, for informational purposes,  columns which are not summarised or aggregated in the output (for example some *character* type columns), we can accomplish that by using the `first()` function, which will select the first element found for that columns (as the rest of elements for that column under that group are in any case repeated). 
(@) Some totals are also calculated, such as *total_hh_income*, as they will be needed to perform specific logical tests on the *_flag* columns.
(@) The *_flag* are where the final logic checks for the specifics constraints are performed. The output will be `TRUE` or `FALSE` depending on whether the validation test has been passed or not for that constraint.

```{r}
  group_by(uuid) %>%
  summarise(enumerator = first(`Enumerator Code`),
            Governorate = first(Governorate),
            District = first(District),
            Subdistrict = first(Subdistrict),
            Community = first(Community),
            Name_HoH = first(Name_HoH),
            total_hh_income = sum(hh_income, na.rm = TRUE),
            single_head_flag = ifelse((sum(check_hhh, na.rm = TRUE) == 1), TRUE, FALSE), # C1: there is a single head of household
            hh_married = ifelse((single_head_flag == TRUE & sum(check_hhh_married, na.rm = TRUE) == 1) , TRUE, FALSE), # check if married
            spouse = ifelse((single_head_flag == TRUE & sum(check_spouse, na.rm = TRUE) >= 1) , TRUE, FALSE), #check if spouse when single head household
            spouse_flag = ifelse((hh_married == TRUE & spouse == TRUE) | (hh_married == FALSE & spouse == FALSE), TRUE, FALSE), # C1: check if there are spouse/s if married or no spouse if not married
            monthly_income = sum(`Average monthly income in SYP`, na.rm = TRUE), # sum monthly incomes for all household members
            income_flag = ifelse(monthly_income <= sum(hh_income, na.rm = TRUE), TRUE, FALSE), # C3: chech if combined monthly income less or equal than reported average monthly income
            child = ifelse((sum(check_child, na.rm = TRUE) >= 1), TRUE, FALSE), # check if more than one child in household
            ...
```

(@) We finally add a new columns in order to check if the household has passed all the constraints (all *flags* are `TRUE`). This is performed by calculating the arithmetical mean for that row. The `rowMeans()` function works in a similar manner as `rowSums()` in the sense that it breaks the **dplyr** behaviour and performs the calculation *rowwise*. For that reason, `select()` is also used in the same manner as with `rowSums()`.  The `ends_with()` will make sure all the *_flag* columns are selected. As each `TRUE` value is automatically coerced to `1`, the arithmetical mean will need to equal `1` in case all values are `TRUE`.
```{r}
  mutate(alltrue_check = rowMeans(select(., ends_with("flag"))))# check mean value of all flags per row. TRUE equals to 1.
...
```

(@) The resulting dataframe `HH_data_check_temp` will receive now two different treatments depending on its final use, either intended for the Enumerators, or for HNAP Information Management Unit for additional parameters review.
(@) `HH_data_check_field` stores the final output for the Enumerator in the field. It simply filters out those records that do not need to be reviewed and select the *flag* columns which highlights the ones which have to be reviewed for each household record.

```{r}
# HH dataset validated for the Enumerators to check
HH_data_check_field <- HH_data_check_temp %>%
  filter(alltrue_check != 1) %>% # filter out rows which are all TRUE, no need to review. All flags TRUE mean coerces to exactly 1.
  select(uuid, enumerator, Governorate, District, Subdistrict, Community, Name_HoH, ends_with("flag"))
```

(@) For the internal review, there are several columns that might need to be reviewed in order to highlight potential outlier values that could have been recorded accidentally. Two approaches are taken, and for each of them a different dataframe is used for the final output. The first one assumes a nearly *normal distribution* for the specific column values (for example, the `total_hh_income`) and detects whether the value falls within the 95% confidence interval or not (which corresponds approximately to *two standard deviations* either side of the data *mean*). The 95% value can be changed in the custom function `get_qnorm_range()`, which gets the lower and upper quantiles for that specific confidence interval. The final results will then depend on the confidence interval level used, though it might highlight values which though uncommon, still fall within a reasonable margin. In order to check if a given value of `total_hh_income` is within the calculated range, we use the custom `check_in_range()` function, as defined within the HNAP **utils.R** library, which will output `TRUE` or `FALSE` depending on the row value for that indicator.
(@) <span style="color:red">**IMPORTANT!**</span> Currently, the script only implements the outliers checking for the `total_hh_income` indicator. This can be extended to other indicators as needed, following exactly the same procedure.

```{r}
# HH dataset validated for internal review of value ranges (using normal distribution probability rule at 95%)
HH_data_check_internal_qnorm <- HH_data_check_temp %>%
mutate(hh_income_range_check = check_in_range(total_hh_income, get_qnorm_range(total_hh_income, 0.95))) %>%
select(uuid, enumerator, Governorate, District, Subdistrict, Community, Name_HoH, total_hh_income, hh_income_range_check, ends_with("flag"))
...
```
 (@) The second approach takes a more systematic way in order to find the *outliers*. It makes use of the commonly accepted [Interquartile Range Rule or 1.5*IQR rule](https://www.thoughtco.com/what-is-the-interquartile-range-rule-3126244) and could be more effective in order to straightforward detect those anomalous values caused by accidental input. This rule is implemented with the custom function `get_outlier_range()`.
 
```{r}
# HH dataset validated for internal review of value ranges (using 1.5*IQR rule for outlier detection)
HH_data_check_internal_iqr <- HH_data_check_temp %>%
  mutate(hh_income_range_check = check_in_range(total_hh_income, get_outlier_range(total_hh_income))) %>%
  select(uuid, enumerator, Governorate, District, Subdistrict, Community, Name_HoH, total_hh_income, hh_income_range_check, ends_with("flag"))
...
```
 
### Output
The script generates an excel output file intended for the Enumerator, which contains the results stored in the `HH_data_check_field`. It makes use of the **openxlsx** library and it defines several formatting styles for the different sections of the excel sheet.

```{r}
# create an excel workbook and sheet
output_file <- paste0(output_dir, "/", file_title, " - Data Check - Field.xlsx")
n_rows <- nrow(HH_data_check_field)
n_cols <- ncol(HH_data_check_field)
wb <- createWorkbook()
addWorksheet(wb, "HH Sample Size")
setColWidths(wb, sheet = 1, cols = 1:n_cols, widths = "20")


# set styles
top_row_style <- createStyle(wrapText = TRUE, valign = "center", fgFill = "#E8E8E8")
falseStyle <- createStyle(fontColour = "#9C0006", bgFill = "#FFC7CE")
trueStyle <- createStyle(fontColour = "#006100", bgFill = "#C6EFCE")
conditionalFormatting(wb, sheet = 1, cols = 8:18, rows = 3:(n_rows + 3), type = "contains", rule = "TRUE", style = trueStyle)
conditionalFormatting(wb, sheet = 1, cols = 8:18, rows = 3:(n_rows + 3), type = "contains", rule = "FALSE", style = falseStyle)
...
```
(@) Two additional rows are added to the top of the table, containing specific information on the type of constrain check performed and also suggestions on the survey questions to review in the original data. Special formatting is added to these rows using the `addStyle()` function from the **openxlsx** package. To maintain previous loaded styles, use the `stack = TRUE` parameter.

```{r}
# create warning and suggestion rows
warning_row <- as.data.frame(t(warning_column_names))
suggestion_row <- as.data.frame(t(suggestion_column_names))
writeData(wb, sheet = 1, warning_row, startRow = 1, startCol = 8, colNames = FALSE, borders = "all")
addStyle(wb, sheet = 1, top_row_style, rows = 1, cols = 8:18, gridExpand = TRUE, stack = TRUE)
writeData(wb, sheet = 1, suggestion_row, startRow = 2, startCol = 8, colNames = FALSE, borders = "all")
addStyle(wb, sheet = 1, top_row_style, rows = 2, cols = 8:18, gridExpand = TRUE, stack = TRUE)
...
```
(@) The data is finally exported
```{r}
# export result into excel
writeDataTable(wb, sheet = 1, HH_data_check_field, startRow = 3, startCol = 1)
saveWorkbook(wb, file = output_file, overwrite = TRUE)
...
```

### Running everything!

The *HH-survey-check.R* main script contains the source files in the order that need to be loaded and run. The **here** library will deal with relative and direct path issues to make it issue running the tool under different file systems. It takes the root directory (the one containing the Rstudio *.rproj* file) as reference. The *_common* directory stores the common scripts used across all HNAP tools, defining the minimum required libraries and several commonly used functions. The rest of the tool scripts are loaded sequentially. Use the *Source* button on *RStudio* to run the whole sequence.

```{r}
# load here library hto handle relative paths from project ROOT
library(here)

source(here("R", "_common", "required.R"))
source(here("R", "_common", "utils.R"))
source(here("R", "HH_survey_check", "01-hh-required.R"))
source(here("R", "HH_survey_check", "02-hh-functions.R"))
source(here("R", "HH_survey_check", "03-hh-config.R"))
source(here("R", "HH_survey_check", "04-hh-dataload.R"))
source(here("R", "HH_survey_check", "05-hh-process.R"))
source(here("R", "HH_survey_check", "06-hh-output.R"))
```