From 9503c5190c1e10bf72ff073b13f5e93280c673d2 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Thu, 22 Aug 2024 19:40:59 +0200
Subject: [PATCH 01/27] function to find top 10 recalibrant series

---
 R/FindRecalSeries.R | 107 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 R/FindRecalSeries.R

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
new file mode 100644
index 0000000..a87c958
--- /dev/null
+++ b/R/FindRecalSeries.R
@@ -0,0 +1,107 @@
+#' Attempts to find most suitable series for recalibration.
+#'
+#' This function takes on input the CH2 homologous recalibration series, which are provided by the RecalList function #' and tries to find the most suitable series combination for recalibration based on the following criteria:
+#' 1) Series should cover the full mass spectral range
+#' 2) Series should be optimally long and combined have a “Tall Peak” at least every 100 m/z.
+#' 3) Abundance score: the higher, the better
+#' 4) Peak score: the closer to 0, the better
+#' 5) Peak Distance: the closer to 1, the better
+#' 6) Series Score: the closer to this value, the better 
+#' 
+#' The recal function can take up to 10 series - due to the size of the search space when looking for combinations of 10
+#' elements, a pre-filtering is done: only the series which have Abundance score > 100 are considered and the one #'
+#' having Peak Distance < 2. 
+#' Combinations of 5 series are assembled, scores are computed for other metrics (in case of Peak proximity and Peak
+#' distance, an inverted score is computed) and these are summed. Finally, top 10 unique series having the highest
+#' score are outputted.
+#' 
+#' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min. 
+#' 
+#' @param df An output from RecalList, containing recalibrant CH2 series.
+#' @return A dataframe of 10 best-scoring series.
+
+findSeries <- function(df){
+
+# Arrange the data
+df <- df %>%
+  separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
+  mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
+         Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
+  mutate(Series.Length = Max.Mass.Range - Min.Mass.Range) %>%
+  filter(Abundance.Score > 100) %>%
+  filter(Peak.Distance < 2) 
+
+# Compute the global minimum and maximum (range of a dataset)
+# We need to add some tolerance, because there is low chance full 100% would be covered
+
+tolerance <- 100
+global_min <- min(data.subset$Min.Mass.Range) + tolerance
+global_max <- max(data.subset$Max.Mass.Range) - tolerance
+
+# Create all combinations of ions
+iter <- combinations(nrow(df), 5, v = 1:nrow(df))
+
+# Helper dataframe with information which combinations do cover range
+coversRange <- data.frame(iter, coversRange = 0)
+
+# Check if the combinations cover the whole data range
+for (i in 1:nrow(iter)){
+  comb <- iter[i, ]
+  subset <- df[comb, ]
+  local_min <- min(subset$Min.Mass.Range)
+  local_max <- max(subset$Max.Mass.Range)
+  if (local_min <= global_min & local_max >= global_max) {
+    coversRange$coversRange[i] <- 1
+  } 
+}
+
+# Subset only those, which cover whole range
+coversRangeTrue <- coversRange[coversRange$coversRange == 1, ]
+
+# Compute the scores
+score_combination <- function(combination) {
+  series <- paste0(combination$Series)
+  total_abundance <- sum(combination$Abundance.Score)
+  total_series_length <- sum(combination$Series.Length)
+  peak_proximity <- sum(1/(combination$Peak.Score))  
+  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))  
+  coverage <- sum(combination$Max.Mass.Range - pmax(combination$Min.Mass.Range, lag(combination$Max.Mass.Range, default = 0)))
+  coverage_percent <- coverage/((global_max+100) - (global_min-100))*100
+  
+  return(list(
+    total_abundance = total_abundance,
+    total_series_length = total_series_length,
+    peak_proximity = peak_proximity,
+    peak_distance_proximity = peak_distance_proximity,
+    series = series,
+    coverage = coverage,
+    coverage_percent = coverage_percent
+  ))
+}
+
+# Create empty list for scored combinations
+scores <- list()
+
+# Iterate over combinations and score them
+for (i in 1:nrow(coversRangeTrue)) {
+  comb <- iter[i, ]
+  subset <- data.subset[comb, ]
+  comb_score <- score_combination(subset)
+  scores <- append(scores, list(comb_score))
+}
+
+# Append all scored combinations into a dataframe
+scores_df <- do.call(rbind, lapply(scores, as.data.frame))
+
+# Filter for the 10 top scoring series
+finalSeries <- scores_df %>%
+  filter(coverage_percent > 90) %>%
+  rowwise() %>%
+  mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity, coverage_percent)) %>%
+  arrange(desc(sum_score)) %>%
+  filter(!duplicated(series)) %>%
+  head(10)
+
+# Return the top scoring series
+return(finalSeries)
+}
\ No newline at end of file

From 45023991c889d5a4b39286eca7b074b99c3bdadc Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Fri, 23 Aug 2024 08:11:09 +0200
Subject: [PATCH 02/27] typos corrected

---
 R/FindRecalSeries.R | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index a87c958..21ebbbb 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -20,7 +20,7 @@
 #' @param df An output from RecalList, containing recalibrant CH2 series.
 #' @return A dataframe of 10 best-scoring series.
 
-findSeries <- function(df){
+findSeries <- function(df) {
 
 # Arrange the data
 df <- df %>%
@@ -35,8 +35,8 @@ df <- df %>%
 # We need to add some tolerance, because there is low chance full 100% would be covered
 
 tolerance <- 100
-global_min <- min(data.subset$Min.Mass.Range) + tolerance
-global_max <- max(data.subset$Max.Mass.Range) - tolerance
+global_min <- min(df$Min.Mass.Range) + tolerance
+global_max <- max(df$Max.Mass.Range) - tolerance
 
 # Create all combinations of ions
 iter <- combinations(nrow(df), 5, v = 1:nrow(df))
@@ -45,7 +45,7 @@ iter <- combinations(nrow(df), 5, v = 1:nrow(df))
 coversRange <- data.frame(iter, coversRange = 0)
 
 # Check if the combinations cover the whole data range
-for (i in 1:nrow(iter)){
+for (i in 1:nrow(iter)) {
   comb <- iter[i, ]
   subset <- df[comb, ]
   local_min <- min(subset$Min.Mass.Range)
@@ -85,7 +85,7 @@ scores <- list()
 # Iterate over combinations and score them
 for (i in 1:nrow(coversRangeTrue)) {
   comb <- iter[i, ]
-  subset <- data.subset[comb, ]
+  subset <- df[comb, ]
   comb_score <- score_combination(subset)
   scores <- append(scores, list(comb_score))
 }

From 52978bad5fc76a952bb4fe224fe59d1e0fcdc602 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 13:26:36 +0200
Subject: [PATCH 03/27] filter_input as a function

---
 R/FindRecalSeries.R | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 21ebbbb..8f0ac93 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -20,23 +20,28 @@
 #' @param df An output from RecalList, containing recalibrant CH2 series.
 #' @return A dataframe of 10 best-scoring series.
 
+filter_input <- function(df, abundance_score_threshold, peak_distance_threshold) {
+  df <- df %>%
+    filter(Abundance.Score > abundance_score_threshold) %>%
+    filter(Peak.Distance < peak_distance_threshold) %>%
+    separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
+    mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
+         Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
+    mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
+}
+
+
 findSeries <- function(df) {
 
-# Arrange the data
-df <- df %>%
-  separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
-  mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
-         Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
-  mutate(Series.Length = Max.Mass.Range - Min.Mass.Range) %>%
-  filter(Abundance.Score > 100) %>%
-  filter(Peak.Distance < 2) 
+  # Arrange the data
+  df <- filter_input(df, 100, 2)
 
-# Compute the global minimum and maximum (range of a dataset)
-# We need to add some tolerance, because there is low chance full 100% would be covered
+  # Compute the global minimum and maximum (range of a dataset)
+  # We need to add some tolerance, because there is low chance full 100% would be covered
 
-tolerance <- 100
-global_min <- min(df$Min.Mass.Range) + tolerance
-global_max <- max(df$Max.Mass.Range) - tolerance
+  tolerance <- 100
+  global_min <- min(df$Min.Mass.Range) + tolerance
+  global_max <- max(df$Max.Mass.Range) - tolerance
 
 # Create all combinations of ions
 iter <- combinations(nrow(df), 5, v = 1:nrow(df))

From 99a1a3753b9837afd2bd1762c1ab2d11810a9ccd Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 13:37:12 +0200
Subject: [PATCH 04/27] description of the filter_input function added

---
 R/FindRecalSeries.R | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 8f0ac93..3e087ba 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -1,3 +1,12 @@
+#' Filters the input dataframe
+#' This function filters the input dataframe based on abundance score threshold and peak distance threshold; and 
+#' computes the length of the series.
+#' @param df Input dataframe = an output from RecalList, containing recalibrant CH2 series.
+#' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
+#' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
+#' better. 
+#' @return A filtered dataframe.
+
 #' Attempts to find most suitable series for recalibration.
 #'
 #' This function takes on input the CH2 homologous recalibration series, which are provided by the RecalList function #' and tries to find the most suitable series combination for recalibration based on the following criteria:

From 7ae9894a68e29ee7f6bdf481be8e031d695c72f8 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 13:38:07 +0200
Subject: [PATCH 05/27] description of filter_input function added

---
 R/FindRecalSeries.R | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 3e087ba..deeebe5 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -7,6 +7,16 @@
 #' better. 
 #' @return A filtered dataframe.
 
+filter_input <- function(df, abundance_score_threshold, peak_distance_threshold) {
+  df <- df %>%
+    filter(Abundance.Score > abundance_score_threshold) %>%
+    filter(Peak.Distance < peak_distance_threshold) %>%
+    separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
+    mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
+         Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
+    mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
+}
+
 #' Attempts to find most suitable series for recalibration.
 #'
 #' This function takes on input the CH2 homologous recalibration series, which are provided by the RecalList function #' and tries to find the most suitable series combination for recalibration based on the following criteria:
@@ -29,15 +39,7 @@
 #' @param df An output from RecalList, containing recalibrant CH2 series.
 #' @return A dataframe of 10 best-scoring series.
 
-filter_input <- function(df, abundance_score_threshold, peak_distance_threshold) {
-  df <- df %>%
-    filter(Abundance.Score > abundance_score_threshold) %>%
-    filter(Peak.Distance < peak_distance_threshold) %>%
-    separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
-    mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
-         Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
-    mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
-}
+
 
 
 findSeries <- function(df) {

From bc75cf52815af9f697a781cc8a8268de9d503aa5 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 13:47:00 +0200
Subject: [PATCH 06/27] compute_scores moved out of top-level

---
 R/FindRecalSeries.R | 47 ++++++++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index deeebe5..55ee78f 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -17,6 +17,27 @@ filter_input <- function(df, abundance_score_threshold, peak_distance_threshold)
     mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
 }
 
+# Compute the scores
+compute_scores <- function(combination) {
+  series <- paste0(combination$Series)
+  total_abundance <- sum(combination$Abundance.Score)
+  total_series_length <- sum(combination$Series.Length)
+  peak_proximity <- sum(1/(combination$Peak.Score))  
+  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))  
+  coverage <- sum(combination$Max.Mass.Range - pmax(combination$Min.Mass.Range, lag(combination$Max.Mass.Range, default = 0)))
+  coverage_percent <- coverage/((global_max+100) - (global_min-100))*100
+  
+  return(list(
+    total_abundance = total_abundance,
+    total_series_length = total_series_length,
+    peak_proximity = peak_proximity,
+    peak_distance_proximity = peak_distance_proximity,
+    series = series,
+    coverage = coverage,
+    coverage_percent = coverage_percent
+  ))
+}
+
 #' Attempts to find most suitable series for recalibration.
 #'
 #' This function takes on input the CH2 homologous recalibration series, which are provided by the RecalList function #' and tries to find the most suitable series combination for recalibration based on the following criteria:
@@ -39,9 +60,6 @@ filter_input <- function(df, abundance_score_threshold, peak_distance_threshold)
 #' @param df An output from RecalList, containing recalibrant CH2 series.
 #' @return A dataframe of 10 best-scoring series.
 
-
-
-
 findSeries <- function(df) {
 
   # Arrange the data
@@ -74,26 +92,7 @@ for (i in 1:nrow(iter)) {
 # Subset only those, which cover whole range
 coversRangeTrue <- coversRange[coversRange$coversRange == 1, ]
 
-# Compute the scores
-score_combination <- function(combination) {
-  series <- paste0(combination$Series)
-  total_abundance <- sum(combination$Abundance.Score)
-  total_series_length <- sum(combination$Series.Length)
-  peak_proximity <- sum(1/(combination$Peak.Score))  
-  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))  
-  coverage <- sum(combination$Max.Mass.Range - pmax(combination$Min.Mass.Range, lag(combination$Max.Mass.Range, default = 0)))
-  coverage_percent <- coverage/((global_max+100) - (global_min-100))*100
-  
-  return(list(
-    total_abundance = total_abundance,
-    total_series_length = total_series_length,
-    peak_proximity = peak_proximity,
-    peak_distance_proximity = peak_distance_proximity,
-    series = series,
-    coverage = coverage,
-    coverage_percent = coverage_percent
-  ))
-}
+
 
 # Create empty list for scored combinations
 scores <- list()
@@ -102,7 +101,7 @@ scores <- list()
 for (i in 1:nrow(coversRangeTrue)) {
   comb <- iter[i, ]
   subset <- df[comb, ]
-  comb_score <- score_combination(subset)
+  comb_score <- compute_scores(subset)
   scores <- append(scores, list(comb_score))
 }
 

From eb6893eaf60f6589f27a707c6edeff0926fe44c7 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 14:41:51 +0200
Subject: [PATCH 07/27] number of combinations and tolerance as arguments

---
 R/FindRecalSeries.R | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 55ee78f..d21ccff 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -58,22 +58,24 @@ compute_scores <- function(combination) {
 #' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min. 
 #' 
 #' @param df An output from RecalList, containing recalibrant CH2 series.
+#' @param tolerance A tolerance value to compute the global minimum and maximum. We expect that there is a low probability that the true minimal/maximal m/z value of the dataset will be in a top-scoring series. Therefore we need to set a reasonable tolerance, which will allow us to cover the most of the m/z range. Global minimum is then computed as true minimum + tolerance ; global maximum as true maximum - tolerance. In case tolerance is set to 0, true minimum and maximum will be used. Default value is 100.
+#' @param combination_subset Combinations of how many series should be computed. Default is 5, Recal function can take
+#' up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
+#' 
 #' @return A dataframe of 10 best-scoring series.
 
-findSeries <- function(df) {
+findSeries <- function(df, tolerance, combination_subset) {
 
   # Arrange the data
   df <- filter_input(df, 100, 2)
 
   # Compute the global minimum and maximum (range of a dataset)
   # We need to add some tolerance, because there is low chance full 100% would be covered
-
-  tolerance <- 100
   global_min <- min(df$Min.Mass.Range) + tolerance
   global_max <- max(df$Max.Mass.Range) - tolerance
 
-# Create all combinations of ions
-iter <- combinations(nrow(df), 5, v = 1:nrow(df))
+  # Create all combinations of ions
+  iter <- combinations(nrow(df), combination_subset, v = 1:nrow(df))
 
 # Helper dataframe with information which combinations do cover range
 coversRange <- data.frame(iter, coversRange = 0)

From 49dba75c25b20b2dc2995296b9cb88cb3bb597e4 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 14:44:05 +0200
Subject: [PATCH 08/27] abundance_score_threshold and peak_distance_threshold
 as global arguments

---
 R/FindRecalSeries.R | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index d21ccff..92b2a72 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -58,16 +58,27 @@ compute_scores <- function(combination) {
 #' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min. 
 #' 
 #' @param df An output from RecalList, containing recalibrant CH2 series.
-#' @param tolerance A tolerance value to compute the global minimum and maximum. We expect that there is a low probability that the true minimal/maximal m/z value of the dataset will be in a top-scoring series. Therefore we need to set a reasonable tolerance, which will allow us to cover the most of the m/z range. Global minimum is then computed as true minimum + tolerance ; global maximum as true maximum - tolerance. In case tolerance is set to 0, true minimum and maximum will be used. Default value is 100.
+#' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
+#' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
+#' better.
+#' @param tolerance A tolerance value to compute the global minimum and maximum. We expect that there is a low
+#' probability that the true minimal/maximal m/z value of the dataset will be in a top-scoring series. Therefore we
+#' need to set a reasonable tolerance, which will allow us to cover the most of the m/z range. Global minimum is then
+#' computed as true minimum + tolerance ; global maximum as true maximum - tolerance. In case tolerance is set to 0,
+#' true minimum and maximum will be used. Default value is 100.
 #' @param combination_subset Combinations of how many series should be computed. Default is 5, Recal function can take
 #' up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
 #' 
 #' @return A dataframe of 10 best-scoring series.
 
-findSeries <- function(df, tolerance, combination_subset) {
+findSeries <- function(df, 
+                       tolerance, 
+                       combination_subset,
+                       abundance_score_threshold,
+                       peak_distance_threshold) {
 
   # Arrange the data
-  df <- filter_input(df, 100, 2)
+  df <- filter_input(df, abundance_score_threshold, peak_distance_threshold)
 
   # Compute the global minimum and maximum (range of a dataset)
   # We need to add some tolerance, because there is low chance full 100% would be covered

From f65564ba11ac8bf159e5aea625b8cbd5f9d17581 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 14:45:46 +0200
Subject: [PATCH 09/27] filter_input changed to filter_recal_series

---
 R/FindRecalSeries.R | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 92b2a72..b31f735 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -7,7 +7,7 @@
 #' better. 
 #' @return A filtered dataframe.
 
-filter_input <- function(df, abundance_score_threshold, peak_distance_threshold) {
+filter_recal_series <- function(df, abundance_score_threshold, peak_distance_threshold) {
   df <- df %>%
     filter(Abundance.Score > abundance_score_threshold) %>%
     filter(Peak.Distance < peak_distance_threshold) %>%
@@ -78,7 +78,7 @@ findSeries <- function(df,
                        peak_distance_threshold) {
 
   # Arrange the data
-  df <- filter_input(df, abundance_score_threshold, peak_distance_threshold)
+  df <- filter_recal_series(df, abundance_score_threshold, peak_distance_threshold)
 
   # Compute the global minimum and maximum (range of a dataset)
   # We need to add some tolerance, because there is low chance full 100% would be covered

From 60898f71e2bdffddbc01dec06ff966988027cb2d Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Mon, 2 Sep 2024 16:41:27 +0200
Subject: [PATCH 10/27] test for compute_coverage

---
 tests/testthat/test-findRecalSeries.R | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 tests/testthat/test-findRecalSeries.R

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
new file mode 100644
index 0000000..b56ab28
--- /dev/null
+++ b/tests/testthat/test-findRecalSeries.R
@@ -0,0 +1,6 @@
+test_that("Compute coverage works", {
+  pos_recalList <- readRDS(file.path("test-data", "pos_recalSeries.rds"))
+  actual <- compute_coverage(pos_recalList, 499.326, 111.044)
+  expected <- 23.5797
+  expect_equal(actual, expected, tolerance = 0.5)
+})
\ No newline at end of file

From 4368a58426cd9b8ceeefccee0dd9c4066ed9f438 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Tue, 3 Sep 2024 09:00:02 +0200
Subject: [PATCH 11/27] test and test data for compute_coverage function

---
 R/FindRecalSeries.R                          |  88 +++++++++++++------
 tests/testthat/test-data/pos_recalSeries.rds | Bin 0 -> 595 bytes
 tests/testthat/test-findRecalSeries.R        |   4 +-
 3 files changed, 62 insertions(+), 30 deletions(-)
 create mode 100644 tests/testthat/test-data/pos_recalSeries.rds

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index b31f735..5af398d 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -15,6 +15,8 @@ filter_recal_series <- function(df, abundance_score_threshold, peak_distance_thr
     mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
          Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
     mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
+
+  return(df)
 }
 
 # Compute the scores
@@ -22,7 +24,7 @@ compute_scores <- function(combination) {
   series <- paste0(combination$Series)
   total_abundance <- sum(combination$Abundance.Score)
   total_series_length <- sum(combination$Series.Length)
-  peak_proximity <- sum(1/(combination$Peak.Score))  
+  peak_score <- sum(1/(combination$Peak.Score))  
   peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))  
   coverage <- sum(combination$Max.Mass.Range - pmax(combination$Min.Mass.Range, lag(combination$Max.Mass.Range, default = 0)))
   coverage_percent <- coverage/((global_max+100) - (global_min-100))*100
@@ -30,7 +32,7 @@ compute_scores <- function(combination) {
   return(list(
     total_abundance = total_abundance,
     total_series_length = total_series_length,
-    peak_proximity = peak_proximity,
+    peak_proximity = peak_score,
     peak_distance_proximity = peak_distance_proximity,
     series = series,
     coverage = coverage,
@@ -38,6 +40,54 @@ compute_scores <- function(combination) {
   ))
 }
 
+compute_coverage <- function(subset, global_max, global_min) {
+  subset <- subset[order(subset$Min.Mass.Range), ]
+
+  # Initialize the coverage and the end of the last segment
+  total_coverage <- 0
+  last_end <- -Inf
+
+  # Iterate through the intervals
+  for (i in 1:nrow(subset)) {
+    current_start <- subset$Min.Mass.Range[i]
+    current_end <- subset$Max.Mass.Range[i]
+  
+    if (current_start > last_end) {
+      # Non-overlapping segment, add the full length to coverage
+      total_coverage <- total_coverage + (current_end - current_start)
+    } else {
+      # Overlapping segment, add only the non-overlapping portion
+      total_coverage <- total_coverage + max(0, current_end - last_end)
+    }
+  
+    # Update the last_end to the current segment's end
+    last_end <- max(last_end, current_end)
+  }
+  coverage_percent <- total_coverage/(global_max - global_min)*100
+  return(coverage_percent)
+}
+
+covers_range <- function(subset, global_min, global_max, coverage_threshold) {
+  coverage <- sum(subset$Max.Mass.Range - pmax(subset$Min.Mass.Range, lag(subset$Max.Mass.Range, default = 0)))
+  coverage_percent <- coverage/((global_max-100) - (global_min+100))*100
+  return(coverage_percent >= coverage_threshold)
+}
+
+find_series_combinations <- function(df, iter, global_min, global_max) {
+  # Create empty list for scored combinations
+  scores <- list()
+  
+  for (i in 1:nrow(iter)) {
+    comb <- iter[i, ]
+    subset <- df[comb, ]
+    if (covers_range(subset, global_min, global_max, coverage_threshold)) {
+        comb_score <- compute_scores(subset)
+        scores <- append(scores, list(comb_score))
+    }
+   
+}
+}
+
 #' Attempts to find most suitable series for recalibration.
 #'
 #' This function takes on input the CH2 homologous recalibration series, which are provided by the RecalList function #' and tries to find the most suitable series combination for recalibration based on the following criteria:
@@ -68,14 +118,16 @@ compute_scores <- function(combination) {
 #' true minimum and maximum will be used. Default value is 100.
 #' @param combination_subset Combinations of how many series should be computed. Default is 5, Recal function can take
 #' up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
+#' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
 #' 
 #' @return A dataframe of 10 best-scoring series.
 
-findSeries <- function(df, 
+find_series <- function(df, 
                        tolerance, 
                        combination_subset,
                        abundance_score_threshold,
-                       peak_distance_threshold) {
+                       peak_distance_threshold,
+                       coverage_threshold) {
 
   # Arrange the data
   df <- filter_recal_series(df, abundance_score_threshold, peak_distance_threshold)
@@ -88,34 +140,14 @@ findSeries <- function(df,
   # Create all combinations of ions
   iter <- combinations(nrow(df), combination_subset, v = 1:nrow(df))
 
-# Helper dataframe with information which combinations do cover range
-coversRange <- data.frame(iter, coversRange = 0)
-
-# Check if the combinations cover the whole data range
-for (i in 1:nrow(iter)) {
-  comb <- iter[i, ]
-  subset <- df[comb, ]
-  local_min <- min(subset$Min.Mass.Range)
-  local_max <- max(subset$Max.Mass.Range)
-  if (local_min <= global_min & local_max >= global_max) {
-    coversRange$coversRange[i] <- 1
-  } 
-}
-
-# Subset only those, which cover whole range
-coversRangeTrue <- coversRange[coversRange$coversRange == 1, ]
-
-
-
-# Create empty list for scored combinations
-scores <- list()
+  # Find the most appropriate combination of series
+  scores_df <- find_series_combinations(df, iter, global_min, global_max, coverage_threshold)
 
 # Iterate over combinations and score them
 for (i in 1:nrow(coversRangeTrue)) {
   comb <- iter[i, ]
   subset <- df[comb, ]
-  comb_score <- compute_scores(subset)
-  scores <- append(scores, list(comb_score))
+
 }
 
 # Append all scored combinations into a dataframe
@@ -125,7 +157,7 @@ scores_df <- do.call(rbind, lapply(scores, as.data.frame))
 finalSeries <- scores_df %>%
   filter(coverage_percent > 90) %>%
   rowwise() %>%
-  mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity, coverage_percent)) %>%
+  mutate(sum_score = sum(total_abundance, total_series_length, peak_score, peak_distance_proximity, coverage_percent)) %>%
   arrange(desc(sum_score)) %>%
   filter(!duplicated(series)) %>%
   head(10)
diff --git a/tests/testthat/test-data/pos_recalSeries.rds b/tests/testthat/test-data/pos_recalSeries.rds
new file mode 100644
index 0000000000000000000000000000000000000000..40501c09ff4a085544819b385d217de31e94d1d3
GIT binary patch
literal 595
zcmV-Z0<8TXiwFP!000001B>8dU|?WoU}0uvU}gm}8CXL@+;lB~V!}WUHxLVe1Q}Qu
zIDs@vyhpq-659lcZHmM;Lt>i)X+Dq{4k8R-;GhPjmC*PS3^2e8wv&M&3WzO%*ae8K
zfjAg$R^0KLw-Ymp9pc=|PHeG^aELuxu=qNctwXF!)kF7nA`UT!OZH^d{er7cOWhS`
zYG3P+xy%-%&><7bPhH~JY3_a8AvJj)$RH&1t1kUH5DqlI;@c#}`#|$6sx%hwa!69P
zYbvU}12n&)y|af2rv8AFe=X}|p9Kd@ZyYnwc=y-AnSHnK%$4c~9B1!3lh&1YAkZOU
zsgvX~n0oui9v$4}89VGBWKGz9-NnW}US!tqnT^`^2jh}X=I*{}|D-|b)qyGvxcUz)
zb7p;6!{@-j()*wH;%gv1u{t`10Z2Fhuw~M85MY@l{VSOXp`LlcUO9(q`zJ}_QFhxa
z>|eZGb$H>Q4fc0sf3B`H3ATT=;e7keqn>d8`mn#ByGfVNA(V|pVsgnID81LgheIIA
z_tF<A{Q(%IAUhbL@ynW=lUQ5~O(ZZuu9U=*M7^}4#N1SL<#|9cm~w8YAX{*1Q6^9n
z!sGWV%}q)z((_L$PAw`+O@RvYKoseD=B1=oK*jicGxPL(f%fYKCFZ54!bKA+Fhw~-
z5_59&0#XyRVfHvCmFA@+<|U`<1t;eh!PIeql%R<4f<;_1i%UR?(VT;#5Gv-AnwMUZ
hf#!40qWp3_nD0TUo2dbk(m|>G9{_XyW?zK^008O%9%ujn

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index b56ab28..8304591 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -1,6 +1,6 @@
 test_that("Compute coverage works", {
   pos_recalList <- readRDS(file.path("test-data", "pos_recalSeries.rds"))
   actual <- compute_coverage(pos_recalList, 499.326, 111.044)
-  expected <- 23.5797
-  expect_equal(actual, expected, tolerance = 0.5)
+  expected <- 23.21534
+  expect_equal(actual, expected, tolerance = 0.0005)
 })
\ No newline at end of file

From 368abe05c0e5588bb649b5b3908f3e8ab3f99fb2 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Tue, 3 Sep 2024 11:42:38 +0200
Subject: [PATCH 12/27] gtools added as dependency

---
 DESCRIPTION                | 3 ++-
 conda/environment-dev.yaml | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 68ac7eb..3029773 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -21,7 +21,8 @@ Depends: R (>= 3.4.1)
 Imports: dplyr (>= 0.7.6),
          tidyr (>= 0.8.1),
          ggplot2 (>= 3.0.0),
-	 	 colorRamps (>= 2.3)
+	 	 colorRamps (>= 2.3),
+		 gtools (>= 3.9.5)
 Roxygen: list(markdown = TRUE)
 RoxygenNote: 7.2.3
 Suggests: knitr,
diff --git a/conda/environment-dev.yaml b/conda/environment-dev.yaml
index 5437e0e..99825f7 100644
--- a/conda/environment-dev.yaml
+++ b/conda/environment-dev.yaml
@@ -14,3 +14,4 @@ dependencies:
 - radian
 - r-covr
 - r-patrick
+- r-gtools

From 4c23182d0b23473d4934b61ce42a84d1709ca0b3 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Tue, 3 Sep 2024 11:43:09 +0200
Subject: [PATCH 13/27] tests for the compute_combinations and compute_subsets

---
 tests/testthat/test-data/combination_subsets.rds | Bin 0 -> 1077 bytes
 tests/testthat/test-data/combinations_simple.rds | Bin 0 -> 93 bytes
 tests/testthat/test-findRecalSeries.R            |  14 ++++++++++++++
 3 files changed, 14 insertions(+)
 create mode 100644 tests/testthat/test-data/combination_subsets.rds
 create mode 100644 tests/testthat/test-data/combinations_simple.rds

diff --git a/tests/testthat/test-data/combination_subsets.rds b/tests/testthat/test-data/combination_subsets.rds
new file mode 100644
index 0000000000000000000000000000000000000000..727b1cfe7c3634a2094f9ba07dcbb304352eacd8
GIT binary patch
literal 1077
zcmV-51j_p#iwFP!000001MQe?NK;W5$M4=OHBCs!h=L5v2uG0X1+!gil#ynol9Xw8
z+cj6ZVq3Z_qn8h56l8wV3JNReg@_0YZLtuuAc*{8LQzp4dZF@zMA?g-yL-;I``kT~
zYTw%6a_&9n-0kk{$M3)AR3vd6r{nZ`4W~1ZQ_fIcwlZfiIhjHZGN_Z<WOAg*6S+jv
z>Z=Q@7lfVXhMk*8n<~xa)49Nl&!TN6$6hIc_u{xs<XA!uOYokm{(T=?Yu$X+%7zEG
zmQ?Ut`gU~=CglgmYsBs<lew99T*{XQc!zu)c7M~r5C2ATzxT_jSue=_-lpu%ZZ_^;
zUeau6D>~;lJ-t6a`_oT;#e|;X_RDkFxcPPA(d5S3+vb<sPj(GjmYS>6JHEFcoEID)
z)}QGZxt7Xv`V(U*Pd<>gb?;_77aG@{^UdV<n%`KbZd%smHNSm#rT6@g8^Px*n(+DT
z&74%eJVBq)=D9;#A6Ysr8Q0KtG&qHN(M=aUnRX_WiY^D~m9HkR-Cb`LUB(itTXZ#u
zcG^8jo@89@w2NNams;#_8jA(D+qgk+ZWDvOf>+&}SSHlf8P|!z4)!?(*4<9K;IxUx
zQrk`!o0lX_QS_t)dMpmNN16;CM=_E16^YJmo?7tD6J0wSjqKY?m}n2k$mrk_+3Lu%
z(<Ne^Np`^_7;9YQescBeFX&x}(wl|Sn}^eDX?nHldOAw4c%h(W(VBjgUhC{-hg{9i
zFnaw3r@J539CM=d-m9`ctnV3$Lhs?P`P#WCz0YTSySgX06s5OlVw$yhU_}0DG-Lk}
zu-dUO5Hu2}5<v2pjx9v&uv~;<nSo*%`q?0smA#%j+xL&+SlaGN6HzQHd%Z_mj%!gY
z*YjI1E}wP@#q!O8%=iALY!u5heaG}so0h|{e1GHdk)giT<6t=)$5O`95K}BoQEi#2
z#1mjC<-FRKG~;nw(iXEN&3Md~EaOpI(u|K{%Rt7Xwxk(9jxBw0TZXWd+SuCC6xEgt
z%gDBruvFWUVTsz3VTst1VTsr>h$UuAh9z!G8B5HT49n=Y^u=wd#4@(FT=)+mo);NQ
z*^(%h)RHKc)RJh3Q%j;)QcFg`GGIv*OKM3JOKQnDmLV+lF~Kqyv1KU4L7^TY#96T(
z7UIf6T@~V>P*;bzvQSrrI4IOrAr1<47~-%{SA{qz)Kwu43iWu1%OGgEScN!-WyqEg
zOSLT-mSMI8SVCK>u!Ob*SVCJuETJtSmcW)OETJtSme7`wu^f(L8LJRiZVE-i5)W~<
zITQg)B*ekS5Q-%h;$UM4#S#f|xG{uciG?`W7>Z*V!ZJ1?ZW<R$5Z)26WC0$+5`?!J
v%W?i&g7Ah|!thpM3Bo%9mWuFJVF|(;!O|DUQi-MR&#?RrDOl+9EE)g+pQagk

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-data/combinations_simple.rds b/tests/testthat/test-data/combinations_simple.rds
new file mode 100644
index 0000000000000000000000000000000000000000..021b58b8b9b818bb5351184b58781610b14de435
GIT binary patch
literal 93
zcmb2|=3oE==I#ec2?+^l35kg*32CfGk`d0%cS>|6BxY1J%2+C-9ci37!N6F|j$`wJ
vjgb>>tno0hlJ1C{ap2nqgMy|nOH!UOX~wPi7!#2EkC7qa&GU!*fTjWfzR)A^

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index 8304591..b889b9a 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -3,4 +3,18 @@ test_that("Compute coverage works", {
   actual <- compute_coverage(pos_recalList, 499.326, 111.044)
   expected <- 23.21534
   expect_equal(actual, expected, tolerance = 0.0005)
+})
+
+test_that("Compute combinations works", {
+  df <- data.frame(series = c(1:5))
+  expected <- readRDS("test-data/combinations_simple.rds")
+  actual <- compute_combinations(df, 3)
+  expect_equal(actual, expected)
+})
+
+test_that("Compute subsets from combinations", {
+  df <- head(readRDS(file.path("test-data", "pos_recalSeries.rds")), 5)
+  expected <- readRDS("test-data/combination_subsets.rds")
+  actual <- compute_subsets(df, 3)
+  expect_equal(actual, expected)
 })
\ No newline at end of file

From 8a9445daa83fc3fc77ad25097109a209dc849689 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Tue, 3 Sep 2024 15:59:18 +0200
Subject: [PATCH 14/27] test for selecting final series

---
 tests/testthat/test-data/scores_df.rds | Bin 0 -> 580 bytes
 tests/testthat/test-findRecalSeries.R  |  22 ++++++++++++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)
 create mode 100644 tests/testthat/test-data/scores_df.rds

diff --git a/tests/testthat/test-data/scores_df.rds b/tests/testthat/test-data/scores_df.rds
new file mode 100644
index 0000000000000000000000000000000000000000..621ffe5d51ec1cce83bede81052642da9012b74f
GIT binary patch
literal 580
zcmV-K0=xYmiwFP!000001B>8dU|?WoU}0foU}gm}8CXL@+;lB~V!}WU8v_%A0Fahu
zU}4|{(k$^F@y1AO6C}1N5o*kcP-BimjVTf4nBp)8mpjdfP=m`HGaPDgnQsmZOFmFo
z9x%!9Tp(lm9)k|gK3mGJ?uJ3f-wW6x`g<z|?eMs!B|-N&1|9IkvC-~z5(aI|a8&ou
z#%>JSD>YN(KjRV%I=&@;di|_97<52aLduFRFLWB_KZhI+P(otBpflQ;cszH-kx0km
zpfT0waBvu^y{y7PS76W??Oe76i?8FLZ=lm~|20hGS(H0927^}p^8Avr?*<H7WbGlQ
zd+|ybbi={SH1!joG3iMky`KE2!lV!H`n-EXKPElZ=|;r^aSU4ZP-)25KcyIS!-4s8
zjD^>s({TTFU-Y-uX?cx}_E-=x9g{x&H{V}r8YX?w-&KQAACo@)H~ZRYJq()tQ;Mfp
zcn1c}w4m$zgRr?+=o#5t7++war+ki?m4r^Cm1TUOvO@ussTGiNE%~Bm6pNZuB5I1&
zT#`kxn@d>K1gp8^iDEaGNKrFNL`}&QWnf_fiZViFS@RNeQ;UHN0dN%x5o9Y)Ey@In
zLU{Zo`6Y=t@rg;Lc`1o`$*E9bVTdq9X?#v<UV2Fe%*uk)#O(NjqWp@?+{}_nsHiwt
zG$pgR1Y`<^G$+)g%oH>yau(&6>%pAK3&czfK;r-Z|4-5VlAM!R4D$<2kSiszBvCJ|
S2&f;(`v(A#U<-9b2mk<BPz&Jz

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index b889b9a..babad13 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -12,9 +12,27 @@ test_that("Compute combinations works", {
   expect_equal(actual, expected)
 })
 
-test_that("Compute subsets from combinations", {
+test_that("Compute subsets from combinations works", {
   df <- head(readRDS(file.path("test-data", "pos_recalSeries.rds")), 5)
   expected <- readRDS("test-data/combination_subsets.rds")
   actual <- compute_subsets(df, 3)
   expect_equal(actual, expected)
-})
\ No newline at end of file
+})
+
+test_that("Filtering of the subsets work", {
+  df <- readRDS("test-data/combination_subsets.rds")
+  expected <- readRDS("test-data/filtered_subsets.rds")
+  actual <- filter_subsets_based_on_coverage(df, 80, 206, 117)
+  expect_equal(actual, expected)
+}
+)
+
+patrick::with_parameters_test_that("Selection of the final series works",
+  {
+    df <- readRDS("test-data/scores_df.rds")
+    expected <- readRDS(file.path("test-data", paste0("final_series", mode, ".rds")))
+    actual <- find_final_series(df, 3, mode)
+    expect_equal(actual, expected)
+  },
+  mode = c(TRUE, FALSE)
+)

From 7497e6416f6a20d0642894cca3a7fe999c9a07c5 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Tue, 3 Sep 2024 15:59:51 +0200
Subject: [PATCH 15/27] test data

---
 tests/testthat/test-data/filtered_subsets.rds    | Bin 0 -> 1030 bytes
 tests/testthat/test-data/final_seriesFALSE.rds   | Bin 0 -> 395 bytes
 tests/testthat/test-data/final_seriesTRUE.rds    | Bin 0 -> 493 bytes
 .../test-data/final_series_combinations.rds      | Bin 0 -> 395 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/testthat/test-data/filtered_subsets.rds
 create mode 100644 tests/testthat/test-data/final_seriesFALSE.rds
 create mode 100644 tests/testthat/test-data/final_seriesTRUE.rds
 create mode 100644 tests/testthat/test-data/final_series_combinations.rds

diff --git a/tests/testthat/test-data/filtered_subsets.rds b/tests/testthat/test-data/filtered_subsets.rds
new file mode 100644
index 0000000000000000000000000000000000000000..95e281957a0e2aeafdd2b42ad63c387e9b6a48ce
GIT binary patch
literal 1030
zcmV+h1o`_PiwFP!000001MQbxNEA^NfXDsG)HETXA__7vBV2-9P0DsGu_W!!A~Dlu
zcSqgQEq1rsG^3vfD+)57w1UD4`XM3$L*3XAvml6kF`=l)hcYT3B+7p5&d$BNJ7@N+
zRNGTKFx;7Q?%kca^YI-{X*|bqT27~n;k0^k$>}$5D#%zuE~b$)j^v~<ft<<mL@CDU
zDpyx74!X_^x;BzANt(;2aK3|2qhl(^jzr&Yaa<WWbI6(RUsKU{;6rnbldmY)`|wUq
zDZj0Ecl$tmu0LNTc2*cojlAtju9V<y@_o?y`u^|UEo8m>^O?CX$$EEvdV43!dsnP$
z)VCB}@EV^zSd{+p2fs45tGM;*e3m!8S$!;FU(H?9s~x912J)AgDpT6NwH{vR&yVQN
zwT<3L;yK-^@x-U^$=KYm)yf6(+6$gJe1mDoJiTmrhuie_-L;;J-*5S!uPFA@`P&&u
z{N_oz87;1EI(o>~X-GbX?xWr=)QL{I=?OGAsYG<xNL0R?x^_>US#%iInVq6zuV|&=
zDe@#kq1`IFX)LMOW;YZIPN!j`V6PVaQNgW_#%&U6YYpo~VJG{aJo6sARj^w`Ly2XV
zgUySVrYItbzDT~!>5?Xc$5BkAu_Do4?WzH99_QG#&%oYZ!bEdOMn(&_$Wlw5oo*2e
z##;rKV5oAC_2lm7AJChH(wm0TyA-E4zy9^An<*&0;-$Rf*=zbxdd>5eA8|B3$LRIu
zo$Y*Fb;6F)d%wc`sIF@;482Fc<Z2e6^uCz=_4@wI5|rMe$;sy8{!#hU#Ekz(z-q>W
zK!}kzl>m}+TDB39!!jGiat4ZJ;Ilz2%X?hiI}VQFSX%B$6HzS7d)!UOPijysH}Kmp
zub6oS#d7FS>ae#y9mO(P*EVa+qTw(shi^S;8tg5c0LzgmmNJ(5h+=6BYs*w6o&Za!
z&Z})nYdmgCI%2k@H6F7itMRBUX^jtKOJ9vgZAokV1h(`<Z5hB)8Y62<V^~`<EJNE;
z!cuKZh9zoCh9zQ4h9zQ4KbDv+8J4&$Wh^mUGAzT}(i63%63f50W#)vo1RYTbTe7Yw
z$d<~ENM%dV5vgsd?1)sh1RasemY^eowuBv#%9fxbQrQx8L{VGHAZWNq*%HGtU`vRl
z+LjE<AX@?~p)FNdLR$hXp)Dbn(3TKOU`rL2(3TKOXv@%8jzqEi7q-j_izVLjur53V
zma-*LEU6_?EU6_iESV)yEU6{KVCl0YiY2uqiY2vV6w3gXx`<$DoDfS;yhC8g3U~lZ
zP`uSxDvP%YOHjNamaurMumr_B1eS{8t-=x%Zv;zE6iX$R+TX+S7jobJVwD#F0522%
AQ~&?~

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-data/final_seriesFALSE.rds b/tests/testthat/test-data/final_seriesFALSE.rds
new file mode 100644
index 0000000000000000000000000000000000000000..47560eb8d4551d8a976f8ae2888305c700b5f890
GIT binary patch
literal 395
zcmV;60d)Q!iwFP!000001C>&{N&`U@oqa@2NMay`jYU2{)0lu@V<id!8wCqtnCwoH
z#eK0eF{VplXRRPuh+kr9>vvfA1!ldInOVccLW`Mm@4091WA9v45JC=eT?;uSFj49J
z>}Yo%xF$I3a2is8%789D#(PV4XUXmY)`j-9Gdg+R?tYr6<A>pfD1=Nb;<Jb9OLTu}
zViCW4KRwvF{V>t!wJv&Xi6&c%?*7B-N{?Rkt@qS35eBv)ZmF+JUPu^I<y}QqvScy|
z7{&fTF>AaZ{&)^}TIv%{+JlTl)W}?hB<&b@k-Y}Tp23yp`Ip&(7Bv=IQw15#0$`=L
z$rDaOO#0*4C$UEr-ITPH;*iEeKGJ_BrQ`~yS#lFZ0iP;%Yr*;f<08vSxU4b-enE^Q
z%)BHshg%zF$v9=|saXmgHL0bJw(TX`F{e-YG^I*_WYEfu_fWg`cm@+f<2cb<s7O-W
p`Y8(m;9RD0bef`88+O8E(9VBf%S!FPtzOhb^KbRA&g_x{001Jsx&;6L

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-data/final_seriesTRUE.rds b/tests/testthat/test-data/final_seriesTRUE.rds
new file mode 100644
index 0000000000000000000000000000000000000000..7018b70952f1212193b974642ed2c3ffca0ff020
GIT binary patch
literal 493
zcmV<J0TTWniwFP!000001B>8dU|?WoU}0foU}gm}8CXL@+;lB~V!}WUI}i(i1Q}Qu
zIDs@vyhpq-659lcZHmM;Lt>i)X+Dq{2TU?N7s!~t$Dkb^*R&+)K0grf#Ie!tbrMXy
zLk<VXK@1plMmrOa=dO4t9S2w6FpXzX?$j7e`e0_7`iajD4U;~4J^4`uSKocn-&&{T
zH8$E+gHhk1`}E)JYp3<l!hjDH1_~h0D<JurEKyShq_9F2g@>BM%w(PuK6899=oyz4
zHuFinbC_Wy+;Ukf3mDi;K=q7J(^!*p5{rwWPG^A%auwy5muD8I#;2q~Mc7J`au7Ub
zAP=TAC9xz?FRdssHx<ofPM{%rc|dWH>AXP9)Bq&@|Ns9R-3c&70^pPcwXis~C=)0O
z;qjN`mn7!ICnlBVr6lGhr$U8=A;J))@j0n^=_MJkP%21G%#JT8%CE@G%`B;eii(3p
zQ!<N7K&D_wb3#qZOo0oO=EfH%=NF-SjxD_?zqFtjn*14|G%M7nj8F_?Ga<2=k=QIq
zY*zG8DJZEdNQEk3fJid_hlUa}R1t4ka!C=;=Rgm|=fh%$3nB<2Vc83$07(CX7{d%R
j25y%gFs_Orl1%@xM;C_O#3c!koeci~y+_mNJ_G;&l*ZDy

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-data/final_series_combinations.rds b/tests/testthat/test-data/final_series_combinations.rds
new file mode 100644
index 0000000000000000000000000000000000000000..47560eb8d4551d8a976f8ae2888305c700b5f890
GIT binary patch
literal 395
zcmV;60d)Q!iwFP!000001C>&{N&`U@oqa@2NMay`jYU2{)0lu@V<id!8wCqtnCwoH
z#eK0eF{VplXRRPuh+kr9>vvfA1!ldInOVccLW`Mm@4091WA9v45JC=eT?;uSFj49J
z>}Yo%xF$I3a2is8%789D#(PV4XUXmY)`j-9Gdg+R?tYr6<A>pfD1=Nb;<Jb9OLTu}
zViCW4KRwvF{V>t!wJv&Xi6&c%?*7B-N{?Rkt@qS35eBv)ZmF+JUPu^I<y}QqvScy|
z7{&fTF>AaZ{&)^}TIv%{+JlTl)W}?hB<&b@k-Y}Tp23yp`Ip&(7Bv=IQw15#0$`=L
z$rDaOO#0*4C$UEr-ITPH;*iEeKGJ_BrQ`~yS#lFZ0iP;%Yr*;f<08vSxU4b-enE^Q
z%)BHshg%zF$v9=|saXmgHL0bJw(TX`F{e-YG^I*_WYEfu_fWg`cm@+f<2cb<s7O-W
p`Y8(m;9RD0bef`88+O8E(9VBf%S!FPtzOhb^KbRA&g_x{001Jsx&;6L

literal 0
HcmV?d00001


From 204450faa258d6beccbec34ccbdaece06e1ea212 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Tue, 3 Sep 2024 16:00:21 +0200
Subject: [PATCH 16/27] code refactored

---
 R/FindRecalSeries.R | 135 ++++++++++++++++++++++++--------------------
 1 file changed, 75 insertions(+), 60 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 5af398d..b4a7996 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -25,18 +25,16 @@ compute_scores <- function(combination) {
   total_abundance <- sum(combination$Abundance.Score)
   total_series_length <- sum(combination$Series.Length)
   peak_score <- sum(1/(combination$Peak.Score))  
-  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))  
-  coverage <- sum(combination$Max.Mass.Range - pmax(combination$Min.Mass.Range, lag(combination$Max.Mass.Range, default = 0)))
-  coverage_percent <- coverage/((global_max+100) - (global_min-100))*100
-  
+  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))
+  series_id <- paste(combination$Series, collapse=" ")
+
   return(list(
+    series = series,
     total_abundance = total_abundance,
     total_series_length = total_series_length,
     peak_proximity = peak_score,
     peak_distance_proximity = peak_distance_proximity,
-    series = series,
-    coverage = coverage,
-    coverage_percent = coverage_percent
+    series_id = series_id
   ))
 }
 
@@ -67,25 +65,45 @@ compute_coverage <- function(subset, global_max, global_min) {
   return(coverage_percent)
 }
 
-covers_range <- function(subset, global_min, global_max, coverage_threshold) {
-  coverage <- sum(subset$Max.Mass.Range - pmax(subset$Min.Mass.Range, lag(subset$Max.Mass.Range, default = 0)))
-  coverage_percent <- coverage/((global_max-100) - (global_min+100))*100
-  return(coverage_percent >= coverage_threshold)
+
+compute_combinations <- function(df, n) {
+  combs <- gtools::combinations(nrow(df), n, v = 1:nrow(df))
+  return(combs)
 }
 
-find_series_combinations <- function(df, iter, global_min, global_max) {
-  # Create empty list for scored combinations
-  scores <- list()
+compute_subsets <- function(df, n) {
+  subsets <- apply(compute_combinations(df, n), 1, function(x) { df[x, ] })
+  return(subsets)
+}
+
+filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global_max, global_min) {
+  filtered_subsets <- Filter(function(x) compute_coverage(x, global_max, global_min) > coverage_threshold, subsets)
+  return(filtered_subsets)
+}
+
+compute_final_score <- function(scores_df) {
+  final_score <- scores_df %>%
+    dplyr::rowwise() %>%
+    dplyr::mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity)) %>%
+    dplyr::arrange(desc(sum_score))
   
-  for (i in 1:nrow(iter)) {
-    comb <- iter[i, ]
-    subset <- df[comb, ]
-    if (covers_range(subset, global_min, global_max, coverage_threshold)) {
-        comb_score <- compute_scores(subset)
-        scores <- append(scores, list(comb_score))
-    }
-   
+  return(final_score)
 }
+
+find_final_series <- function(scores_df, number_of_combinations, fill_series){
+  final_series <- compute_final_score(scores_df)
+  
+  if (fill_series == FALSE) {
+    final_series <- final_series %>%
+      head(number_of_combinations)
+  } else {
+    final_series <- final_series %>%
+     # dplyr::filter(!duplicated(series)) %>%
+    dplyr::distinct(series, .keep_all = TRUE) %>%
+    head(10)
+  }
+
+  return(final_series)
 }
 
 #' Attempts to find most suitable series for recalibration.
@@ -116,52 +134,49 @@ find_series_combinations <- function(df, iter, global_min, global_max) {
 #' need to set a reasonable tolerance, which will allow us to cover the most of the m/z range. Global minimum is then
 #' computed as true minimum + tolerance ; global maximum as true maximum - tolerance. In case tolerance is set to 0,
 #' true minimum and maximum will be used. Default value is 100.
-#' @param combination_subset Combinations of how many series should be computed. Default is 5, Recal function can take
+#' @param number_of_combinations Combinations of how many series should be computed. Default is 5, Recal function can take
 #' up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
 #' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
+#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best 
+#' combination will be returned
 #' 
 #' @return A dataframe of 10 best-scoring series.
 
-find_series <- function(df, 
-                       tolerance, 
-                       combination_subset,
-                       abundance_score_threshold,
-                       peak_distance_threshold,
-                       coverage_threshold) {
+find_series <- function(df,
+                        global_min,
+                        global_max,
+                        number_of_combinations,
+                        abundance_score_threshold,
+                        peak_distance_threshold,
+                        coverage_threshold,
+                        fill_series) {
 
   # Arrange the data
   df <- filter_recal_series(df, abundance_score_threshold, peak_distance_threshold)
 
-  # Compute the global minimum and maximum (range of a dataset)
-  # We need to add some tolerance, because there is low chance full 100% would be covered
-  global_min <- min(df$Min.Mass.Range) + tolerance
-  global_max <- max(df$Max.Mass.Range) - tolerance
-
   # Create all combinations of ions
-  iter <- combinations(nrow(df), combination_subset, v = 1:nrow(df))
-
-  # Find the most appropriate combination of series
-  scores_df <- find_series_combinations(df, iter, global_min, global_max, coverage_threshold)
-
-# Iterate over combinations and score them
-for (i in 1:nrow(coversRangeTrue)) {
-  comb <- iter[i, ]
-  subset <- df[comb, ]
-
-}
-
-# Append all scored combinations into a dataframe
-scores_df <- do.call(rbind, lapply(scores, as.data.frame))
-
-# Filter for the 10 top scoring series
-finalSeries <- scores_df %>%
-  filter(coverage_percent > 90) %>%
-  rowwise() %>%
-  mutate(sum_score = sum(total_abundance, total_series_length, peak_score, peak_distance_proximity, coverage_percent)) %>%
-  arrange(desc(sum_score)) %>%
-  filter(!duplicated(series)) %>%
-  head(10)
-
-# Return the top scoring series
-return(finalSeries)
+  subsets <- compute_subsets(df, number_of_combinations)
+  # combs <- lapply(combs, function(x) { list(subset = x)})
+  # combs_with_coverage <- lapply(
+  #   combs,
+  #   function(x){
+  #     x[["coverage"]] <- compute_coverage(x[["subset"]], global_max, global_min)
+  #     return(x)
+  #   }
+  # )
+
+  # Filter the subsets based on coverage threshold
+  subsets_filtered <- filter_subsets_based_on_coverage(subsets, coverage_threshold, global_max, global_min)
+
+  # Compute the scores
+  scores <- lapply(subsets_filtered, function(x) { compute_scores(x) })
+
+  # Append all scored combinations into a dataframe
+  scores_df <- do.call(rbind, lapply(scores, as.data.frame))
+
+  # Filter for final series
+  final_series <- find_final_series(scores_df, number_of_combinations, fill_series)
+
+  # Return the top scoring series
+  return(final_series)
 }
\ No newline at end of file

From 5f37bddb7c079890750eeeaf26d7336ff671c8a6 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Wed, 4 Sep 2024 09:48:41 +0200
Subject: [PATCH 17/27] test for filtering the input recal list

---
 tests/testthat/test-data/filtered_recallist.rds | Bin 0 -> 321 bytes
 tests/testthat/test-findRecalSeries.R           |   8 ++++++++
 2 files changed, 8 insertions(+)
 create mode 100644 tests/testthat/test-data/filtered_recallist.rds

diff --git a/tests/testthat/test-data/filtered_recallist.rds b/tests/testthat/test-data/filtered_recallist.rds
new file mode 100644
index 0000000000000000000000000000000000000000..bbc0f8cf5a699a4dc271982fde4827526bbad82e
GIT binary patch
literal 321
zcmV-H0lxkpiwFP!000001B>8dU|?WoU}0foU}gm}8CXL@+;lB~V!}WUHxLT|F(U&D
z11FGX^EZn3h&KkZ_&}l#jtnrs3s%Lzzz>&;alX!FTd)MqFAgc%pm1akoS&-va<Rqr
zPjJ3f;_HW-X6=RX?Kgh@`|oMeIvC$}k*CTeAcD)^ao(%`@gl<fjJBV*l`cGEU|?ZF
zaxrUiPGWH}nm4#o5=#>G(uxvuQ_+>@0mWd-xnaHzPA$p=ib8n&ex<odsYQDJNyVu}
zWvMApVIGJgJ<q(9)C#B=pKoTKo-fdTy`aRr^i;TLVg;rsXGmgBj$S}&Vm8bk$E4D{
zl*GK`RK4Kj{34h-E|3xw5nix}OJ;EiNHLmoP!vMNd{Xn$OES=W&RLXSt_SlyC^nfI
TfW&_w08;+|Gy$@wCjtNfKP8cJ

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index babad13..e268102 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -1,3 +1,11 @@
+test_that("Filtering input dataframe works", {
+  pos_recalList <-head(readRDS(file.path("test-data", "pos_recallist.rds")), 10)
+  colnames(pos_recalList) <- gsub(" ", ".", colnames(pos_recalList))
+  expected <- readRDS("test-data/filtered_recallist.rds")
+  actual <- filter_recal_series(pos_recalList, abundance_score_threshold = 0, peak_distance_threshold = 2)
+  expect_equal(actual, expected)
+})
+
 test_that("Compute coverage works", {
   pos_recalList <- readRDS(file.path("test-data", "pos_recalSeries.rds"))
   actual <- compute_coverage(pos_recalList, 499.326, 111.044)

From f3888772cbe7291ef3978b79f096bc92933e2d82 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Wed, 4 Sep 2024 11:36:49 +0200
Subject: [PATCH 18/27] functions documented

---
 R/FindRecalSeries.R | 158 +++++++++++++++++++++++++++-----------------
 1 file changed, 99 insertions(+), 59 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index b4a7996..f102ae5 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -4,13 +4,13 @@
 #' @param df Input dataframe = an output from RecalList, containing recalibrant CH2 series.
 #' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
 #' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
-#' better. 
+#' better.
 #' @return A filtered dataframe.
 
 filter_recal_series <- function(df, abundance_score_threshold, peak_distance_threshold) {
   df <- df %>%
-    filter(Abundance.Score > abundance_score_threshold) %>%
-    filter(Peak.Distance < peak_distance_threshold) %>%
+    dplyr::filter(Abundance.Score > abundance_score_threshold) %>%
+    dplyr::filter(Peak.Distance < peak_distance_threshold) %>%
     separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
     mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
          Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
@@ -19,25 +19,38 @@ filter_recal_series <- function(df, abundance_score_threshold, peak_distance_thr
   return(df)
 }
 
-# Compute the scores
-compute_scores <- function(combination) {
-  series <- paste0(combination$Series)
-  total_abundance <- sum(combination$Abundance.Score)
-  total_series_length <- sum(combination$Series.Length)
-  peak_score <- sum(1/(combination$Peak.Score))  
-  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))
-  series_id <- paste(combination$Series, collapse=" ")
+#' Computes all possible combinations of series
+#' This function computes all possible combinations of series. The number of combinations is specified by user.
+#' @param df A pre-filtered dataframe containing series.
+#' @param n Number of combinations to compute.
+#'
+#' @return A dataframe of row-index based combinations. 
 
-  return(list(
-    series = series,
-    total_abundance = total_abundance,
-    total_series_length = total_series_length,
-    peak_proximity = peak_score,
-    peak_distance_proximity = peak_distance_proximity,
-    series_id = series_id
-  ))
+compute_combinations <- function(df, n) {
+  combs <- gtools::combinations(nrow(df), n, v = 1:nrow(df))
+  return(combs)
+}
+
+#' Computes subsets based on combinations.
+#' This function selects subsets of the input data based on the combinations of series.
+#' @param df A pre-filtered dataframe containing series.
+#' @param n Number of combinations to compute.
+#'
+#' @return A list of subsets based on series combinations.
+
+compute_subsets <- function(df, n) {
+  subsets <- apply(compute_combinations(df, n), 1, function(x) { df[x, ] })
+  return(subsets)
 }
 
+#' Computes coverage of a subset.
+#' This function computes m/z range coverage of a particular subset. The higher coverage, the better.
+#' @param subset A subset of pre-filtered input data, has a size of combination number. 
+#' @param global_min A lower bound of the instrument m/z range.
+#' @param global_max A higher bound of the instrument m/z range.
+#'
+#'@return Coverage (in %) of a particular subset.
+
 compute_coverage <- function(subset, global_max, global_min) {
   subset <- subset[order(subset$Min.Mass.Range), ]
 
@@ -65,22 +78,50 @@ compute_coverage <- function(subset, global_max, global_min) {
   return(coverage_percent)
 }
 
-
-compute_combinations <- function(df, n) {
-  combs <- gtools::combinations(nrow(df), n, v = 1:nrow(df))
-  return(combs)
-}
-
-compute_subsets <- function(df, n) {
-  subsets <- apply(compute_combinations(df, n), 1, function(x) { df[x, ] })
-  return(subsets)
-}
+#' Filters subsets based on the coverage.
+#' This function filters the subsets based on the coverage threshold.
+#' @param subsets A subset of pre-filtered input data, has a size of combination number. 
+#' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
+#' @param global_min A lower bound of the instrument m/z range.
+#' @param global_max A higher bound of the instrument m/z range.
+#' 
+#' @return A list of subsets which pass the coverage threshold (their coverage is higher than the threshold)
 
 filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global_max, global_min) {
   filtered_subsets <- Filter(function(x) compute_coverage(x, global_max, global_min) > coverage_threshold, subsets)
   return(filtered_subsets)
 }
 
+#' Computes the scores for individual subsets.
+#' This function computes individual scores for the particular combination of series.
+#' @param combination A subset of pre-filtered input data, has a size of combination number.
+#' 
+#' @return List of scores for individual parameters.
+
+compute_scores <- function(combination) {
+  series <- paste0(combination$Series)
+  total_abundance <- sum(combination$Abundance.Score)
+  total_series_length <- sum(combination$Series.Length)
+  peak_score <- sum(1/(combination$Peak.Score))  
+  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))
+  series_id <- paste(combination$Series, collapse=" ")
+
+  return(list(
+    series = series,
+    total_abundance = total_abundance,
+    total_series_length = total_series_length,
+    peak_proximity = peak_score,
+    peak_distance_proximity = peak_distance_proximity,
+    series_id = series_id
+  ))
+}
+
+#' Compute a sum score for the whole combination.
+#' This function computes a score summing all parameter scores and arranges them in descending manner.
+#' @param scores_df A dataframe of scores.
+#' 
+#' @return A sorted dataframe containing the final score.
+
 compute_final_score <- function(scores_df) {
   final_score <- scores_df %>%
     dplyr::rowwise() %>%
@@ -90,9 +131,19 @@ compute_final_score <- function(scores_df) {
   return(final_score)
 }
 
+#' Selects final series.
+#' This function selects final best-scoring series. An user can choose, whether only a number of series corresponding
+#' to the size of the combination will be returned, or 10 best-scoring 10 series will be returned.
+#' @param scores_df A dataframe of scores.
+#' @param number_of_combinations Number of combinations to compute.
+#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best 
+#' combination will be returned.
+#' 
+#' @return A dataframe of best-scoring series.
+
 find_final_series <- function(scores_df, number_of_combinations, fill_series){
   final_series <- compute_final_score(scores_df)
-  
+
   if (fill_series == FALSE) {
     final_series <- final_series %>%
       head(number_of_combinations)
@@ -109,38 +160,35 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series){
 #' Attempts to find most suitable series for recalibration.
 #'
 #' This function takes on input the CH2 homologous recalibration series, which are provided by the RecalList function #' and tries to find the most suitable series combination for recalibration based on the following criteria:
-#' 1) Series should cover the full mass spectral range
-#' 2) Series should be optimally long and combined have a “Tall Peak” at least every 100 m/z.
-#' 3) Abundance score: the higher, the better
-#' 4) Peak score: the closer to 0, the better
-#' 5) Peak Distance: the closer to 1, the better
-#' 6) Series Score: the closer to this value, the better 
-#' 
+#' 1) Series should cover the full mass spectral range,
+#' 2) Series should be optimally long and combined have a “Tall Peak” at least every 100 m/z,
+#' 3) Abundance score: the higher, the better,
+#' 4) Peak score: the closer to 0, the better,
+#' 5) Peak Distance: the closer to 1, the better,
+#' 6) Series Score: the closer to this value, the better.
+#'
 #' The recal function can take up to 10 series - due to the size of the search space when looking for combinations of 10
 #' elements, a pre-filtering is done: only the series which have Abundance score > 100 are considered and the one #'
-#' having Peak Distance < 2. 
+#' having Peak Distance < 2.
 #' Combinations of 5 series are assembled, scores are computed for other metrics (in case of Peak proximity and Peak
 #' distance, an inverted score is computed) and these are summed. Finally, top 10 unique series having the highest
 #' score are outputted.
-#' 
+#'
 #' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min. 
-#' 
+#'
 #' @param df An output from RecalList, containing recalibrant CH2 series.
+#' @param global_min A lower bound of the instrument m/z range.
+#' @param global_max A higher bound of the instrument m/z range.
+#' @param number_of_combinations Combinations of how many series should be computed. Default is 5, Recal function can
+#' take up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
 #' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
 #' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
 #' better.
-#' @param tolerance A tolerance value to compute the global minimum and maximum. We expect that there is a low
-#' probability that the true minimal/maximal m/z value of the dataset will be in a top-scoring series. Therefore we
-#' need to set a reasonable tolerance, which will allow us to cover the most of the m/z range. Global minimum is then
-#' computed as true minimum + tolerance ; global maximum as true maximum - tolerance. In case tolerance is set to 0,
-#' true minimum and maximum will be used. Default value is 100.
-#' @param number_of_combinations Combinations of how many series should be computed. Default is 5, Recal function can take
-#' up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
 #' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
 #' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best 
-#' combination will be returned
-#' 
-#' @return A dataframe of 10 best-scoring series.
+#' combination will be returned.
+#'
+#' @return A dataframe of n-10 best-scoring series.
 
 find_series <- function(df,
                         global_min,
@@ -151,19 +199,11 @@ find_series <- function(df,
                         coverage_threshold,
                         fill_series) {
 
-  # Arrange the data
+  # Pre-filter and arrange the data
   df <- filter_recal_series(df, abundance_score_threshold, peak_distance_threshold)
 
   # Create all combinations of ions
   subsets <- compute_subsets(df, number_of_combinations)
-  # combs <- lapply(combs, function(x) { list(subset = x)})
-  # combs_with_coverage <- lapply(
-  #   combs,
-  #   function(x){
-  #     x[["coverage"]] <- compute_coverage(x[["subset"]], global_max, global_min)
-  #     return(x)
-  #   }
-  # )
 
   # Filter the subsets based on coverage threshold
   subsets_filtered <- filter_subsets_based_on_coverage(subsets, coverage_threshold, global_max, global_min)

From a0c72c841b578d607ef7083913111bb4248a6b2a Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Wed, 4 Sep 2024 12:00:10 +0200
Subject: [PATCH 19/27] test for computing final scores

---
 tests/testthat/test-data/final_scores.rds | Bin 0 -> 461 bytes
 tests/testthat/test-findRecalSeries.R     |  23 ++++++++++++++--------
 2 files changed, 15 insertions(+), 8 deletions(-)
 create mode 100644 tests/testthat/test-data/final_scores.rds

diff --git a/tests/testthat/test-data/final_scores.rds b/tests/testthat/test-data/final_scores.rds
new file mode 100644
index 0000000000000000000000000000000000000000..7073bee5d7a1ebb62654d39061441ee11ccaea05
GIT binary patch
literal 461
zcmV;;0W$s{iwFP!000001B>8dU|?WoU}0foU}gm}8CXL@+;lB~V!}WUI}i&1F&hI5
z11FGXiT8*%Mq-;Fu}z6kV+N%8K;|7V$?#ktWBMM04$nSY%C7E)PQ&y$<Zyr-$$&v;
zv@`K|?utXF;rbe;@hr-n8iPTretCXL*>?jv4cFIw(cfC9<ux|iV?o4pbQ&$Z_&{Ny
z015;Jq!1!s)Qluim>*^)^PKRR<AXu>$7b${%CAAEfl<W-)W--ll{GmhvA7uOF&3yG
zS5ba>d1i5Hd`cQrgsmhg2f<?o@?c6+5=#>G(uxvuQ_)Q31RA232NVaH&I`m$4M5`m
z|Np<x6tblk<(C!|LlY$<lxBnKVuWHCn+b`{jKpR^VzVN#+0Z>)P*Pct3RS=Wk!1W2
z4FG1SBHps(lA_}HoXp~q_<WeJxgdfd5|-#e3V`%KbUR?)7C;u%0|rPjL?zRI>|ui8
z5aPle<^Wchc6ONd;?$x{pi3Y;{*wHX#GLrVq|&^U#JuEGsIV|Z7@{;jCp9m<Bm<V_
z3Q`lZ;|q%ND>8F4ODdtF;$YDfpx;5JU`TU9P0CDx3zX)@7boWzft?BfSsNCtlmq|(
D^t8=g

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index e268102..272c35f 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -6,13 +6,6 @@ test_that("Filtering input dataframe works", {
   expect_equal(actual, expected)
 })
 
-test_that("Compute coverage works", {
-  pos_recalList <- readRDS(file.path("test-data", "pos_recalSeries.rds"))
-  actual <- compute_coverage(pos_recalList, 499.326, 111.044)
-  expected <- 23.21534
-  expect_equal(actual, expected, tolerance = 0.0005)
-})
-
 test_that("Compute combinations works", {
   df <- data.frame(series = c(1:5))
   expected <- readRDS("test-data/combinations_simple.rds")
@@ -27,7 +20,14 @@ test_that("Compute subsets from combinations works", {
   expect_equal(actual, expected)
 })
 
-test_that("Filtering of the subsets work", {
+test_that("Compute coverage works", {
+  pos_recalList <- readRDS(file.path("test-data", "pos_recalSeries.rds"))
+  actual <- compute_coverage(pos_recalList, 499.326, 111.044)
+  expected <- 23.21534
+  expect_equal(actual, expected, tolerance = 0.0005)
+})
+
+test_that("Filtering of the subsets based on coverage works", {
   df <- readRDS("test-data/combination_subsets.rds")
   expected <- readRDS("test-data/filtered_subsets.rds")
   actual <- filter_subsets_based_on_coverage(df, 80, 206, 117)
@@ -35,6 +35,13 @@ test_that("Filtering of the subsets work", {
 }
 )
 
+test_that("Computing final scores work", {
+  df <- head(readRDS("test-data/scores_df.rds"), 6)
+  expected <- readRDS("test-data/final_scores.rds")
+  actual <- compute_final_score(df)
+  expect_equal(actual, expected)
+})
+
 patrick::with_parameters_test_that("Selection of the final series works",
   {
     df <- readRDS("test-data/scores_df.rds")

From 6da3fcadb58db9fba420d34ad777a77ee1676cdf Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Wed, 4 Sep 2024 12:47:47 +0200
Subject: [PATCH 20/27] test for compute_scores

---
 tests/testthat/test-data/computed_scores.rds | Bin 0 -> 211 bytes
 tests/testthat/test-findRecalSeries.R        |   7 +++++++
 2 files changed, 7 insertions(+)
 create mode 100644 tests/testthat/test-data/computed_scores.rds

diff --git a/tests/testthat/test-data/computed_scores.rds b/tests/testthat/test-data/computed_scores.rds
new file mode 100644
index 0000000000000000000000000000000000000000..7e136f0ece57cae0bcb21f50307c5105939b7f6c
GIT binary patch
literal 211
zcmV;^04)C>iwFP!000001B>8dU|?WoU}0foU}gm}8CXL@+;lA%7?^~C95x^pfGA+#
z1kx<=9`VLVY!f85DUjv^V#Wg|8J-JdOy9%!4mlhQPypdKOygOUJ2eK*@4o17t<&-v
zY8NBaOg@lZ3Lr}qAf~f0A<44lCFZ6UL$$C$1=)&Ii!y<t5FUR?eo10Zd}2~*UP@wK
zaw=3<7$OW&8lRJzmtK+qv$7yHF+0AXD8C{zH?yP?Dk=^ZP01`S0hxj!%?ULrGX==`
N2LO6HTUAg2007fZOoIRb

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index 272c35f..690fefd 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -42,6 +42,13 @@ test_that("Computing final scores work", {
   expect_equal(actual, expected)
 })
 
+test_that("Computing scores works", {
+  df <- readRDS("test-data/filtered_subsets.rds")[[1]]
+  expected <- readRDS("test-data/computed_scores.rds")
+  actual <- compute_scores(df)
+  expect_equal(actual, expected)
+})
+
 patrick::with_parameters_test_that("Selection of the final series works",
   {
     df <- readRDS("test-data/scores_df.rds")

From 00fd06b42975f7b14976861790ab129d355f6626 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Wed, 4 Sep 2024 12:53:18 +0200
Subject: [PATCH 21/27] linting done

---
 R/FindRecalSeries.R | 70 ++++++++++++++++++++++++---------------------
 1 file changed, 37 insertions(+), 33 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index f102ae5..03c7e48 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -1,5 +1,5 @@
 #' Filters the input dataframe
-#' This function filters the input dataframe based on abundance score threshold and peak distance threshold; and 
+#' This function filters the input dataframe based on abundance score threshold and peak distance threshold; and
 #' computes the length of the series.
 #' @param df Input dataframe = an output from RecalList, containing recalibrant CH2 series.
 #' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
@@ -11,10 +11,12 @@ filter_recal_series <- function(df, abundance_score_threshold, peak_distance_thr
   df <- df %>%
     dplyr::filter(Abundance.Score > abundance_score_threshold) %>%
     dplyr::filter(Peak.Distance < peak_distance_threshold) %>%
-    separate(col = Mass.Range, into = c('Min.Mass.Range', 'Max.Mass.Range'), sep = "-") %>%
-    mutate(Min.Mass.Range = as.numeric(Min.Mass.Range), 
-         Max.Mass.Range = as.numeric(Max.Mass.Range)) %>%
-    mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
+    tidyr::separate(col = Mass.Range, into = c("Min.Mass.Range", "Max.Mass.Range"), sep = "-") %>%
+    dplyr::mutate(
+      Min.Mass.Range = as.numeric(Min.Mass.Range),
+      Max.Mass.Range = as.numeric(Max.Mass.Range)
+    ) %>%
+    dplyr::mutate(Series.Length = Max.Mass.Range - Min.Mass.Range)
 
   return(df)
 }
@@ -24,10 +26,10 @@ filter_recal_series <- function(df, abundance_score_threshold, peak_distance_thr
 #' @param df A pre-filtered dataframe containing series.
 #' @param n Number of combinations to compute.
 #'
-#' @return A dataframe of row-index based combinations. 
+#' @return A dataframe of row-index based combinations.
 
 compute_combinations <- function(df, n) {
-  combs <- gtools::combinations(nrow(df), n, v = 1:nrow(df))
+  combs <- gtools::combinations(nrow(df), n, v = seq_len(nrow(df)))
   return(combs)
 }
 
@@ -39,17 +41,19 @@ compute_combinations <- function(df, n) {
 #' @return A list of subsets based on series combinations.
 
 compute_subsets <- function(df, n) {
-  subsets <- apply(compute_combinations(df, n), 1, function(x) { df[x, ] })
+  subsets <- apply(compute_combinations(df, n), 1, function(x) {
+    df[x, ]
+  })
   return(subsets)
 }
 
 #' Computes coverage of a subset.
 #' This function computes m/z range coverage of a particular subset. The higher coverage, the better.
-#' @param subset A subset of pre-filtered input data, has a size of combination number. 
+#' @param subset A subset of pre-filtered input data, has a size of combination number.
 #' @param global_min A lower bound of the instrument m/z range.
 #' @param global_max A higher bound of the instrument m/z range.
 #'
-#'@return Coverage (in %) of a particular subset.
+#' @return Coverage (in %) of a particular subset.
 
 compute_coverage <- function(subset, global_max, global_min) {
   subset <- subset[order(subset$Min.Mass.Range), ]
@@ -59,10 +63,10 @@ compute_coverage <- function(subset, global_max, global_min) {
   last_end <- -Inf
 
   # Iterate through the intervals
-  for (i in 1:nrow(subset)) {
+  for (i in seq_len(nrow(subset))) {
     current_start <- subset$Min.Mass.Range[i]
     current_end <- subset$Max.Mass.Range[i]
-  
+
     if (current_start > last_end) {
       # Non-overlapping segment, add the full length to coverage
       total_coverage <- total_coverage + (current_end - current_start)
@@ -70,21 +74,21 @@ compute_coverage <- function(subset, global_max, global_min) {
       # Overlapping segment, add only the non-overlapping portion
       total_coverage <- total_coverage + max(0, current_end - last_end)
     }
-  
+
     # Update the last_end to the current segment's end
     last_end <- max(last_end, current_end)
   }
-  coverage_percent <- total_coverage/(global_max - global_min)*100
+  coverage_percent <- total_coverage / (global_max - global_min) * 100
   return(coverage_percent)
 }
 
 #' Filters subsets based on the coverage.
 #' This function filters the subsets based on the coverage threshold.
-#' @param subsets A subset of pre-filtered input data, has a size of combination number. 
+#' @param subsets A subset of pre-filtered input data, has a size of combination number.
 #' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
 #' @param global_min A lower bound of the instrument m/z range.
 #' @param global_max A higher bound of the instrument m/z range.
-#' 
+#'
 #' @return A list of subsets which pass the coverage threshold (their coverage is higher than the threshold)
 
 filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global_max, global_min) {
@@ -95,16 +99,16 @@ filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global
 #' Computes the scores for individual subsets.
 #' This function computes individual scores for the particular combination of series.
 #' @param combination A subset of pre-filtered input data, has a size of combination number.
-#' 
+#'
 #' @return List of scores for individual parameters.
 
 compute_scores <- function(combination) {
   series <- paste0(combination$Series)
   total_abundance <- sum(combination$Abundance.Score)
   total_series_length <- sum(combination$Series.Length)
-  peak_score <- sum(1/(combination$Peak.Score))  
-  peak_distance_proximity <- sum(1/(combination$Peak.Distance - 1))
-  series_id <- paste(combination$Series, collapse=" ")
+  peak_score <- sum(1 / (combination$Peak.Score))
+  peak_distance_proximity <- sum(1 / (combination$Peak.Distance - 1))
+  series_id <- paste(combination$Series, collapse = " ")
 
   return(list(
     series = series,
@@ -119,7 +123,7 @@ compute_scores <- function(combination) {
 #' Compute a sum score for the whole combination.
 #' This function computes a score summing all parameter scores and arranges them in descending manner.
 #' @param scores_df A dataframe of scores.
-#' 
+#'
 #' @return A sorted dataframe containing the final score.
 
 compute_final_score <- function(scores_df) {
@@ -127,7 +131,7 @@ compute_final_score <- function(scores_df) {
     dplyr::rowwise() %>%
     dplyr::mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity)) %>%
     dplyr::arrange(desc(sum_score))
-  
+
   return(final_score)
 }
 
@@ -136,12 +140,12 @@ compute_final_score <- function(scores_df) {
 #' to the size of the combination will be returned, or 10 best-scoring 10 series will be returned.
 #' @param scores_df A dataframe of scores.
 #' @param number_of_combinations Number of combinations to compute.
-#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best 
+#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best
 #' combination will be returned.
-#' 
+#'
 #' @return A dataframe of best-scoring series.
 
-find_final_series <- function(scores_df, number_of_combinations, fill_series){
+find_final_series <- function(scores_df, number_of_combinations, fill_series) {
   final_series <- compute_final_score(scores_df)
 
   if (fill_series == FALSE) {
@@ -149,9 +153,8 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series){
       head(number_of_combinations)
   } else {
     final_series <- final_series %>%
-     # dplyr::filter(!duplicated(series)) %>%
-    dplyr::distinct(series, .keep_all = TRUE) %>%
-    head(10)
+      dplyr::distinct(series, .keep_all = TRUE) %>%
+      head(10)
   }
 
   return(final_series)
@@ -174,7 +177,7 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series){
 #' distance, an inverted score is computed) and these are summed. Finally, top 10 unique series having the highest
 #' score are outputted.
 #'
-#' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min. 
+#' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min.
 #'
 #' @param df An output from RecalList, containing recalibrant CH2 series.
 #' @param global_min A lower bound of the instrument m/z range.
@@ -185,7 +188,7 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series){
 #' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
 #' better.
 #' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
-#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best 
+#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best
 #' combination will be returned.
 #'
 #' @return A dataframe of n-10 best-scoring series.
@@ -198,7 +201,6 @@ find_series <- function(df,
                         peak_distance_threshold,
                         coverage_threshold,
                         fill_series) {
-
   # Pre-filter and arrange the data
   df <- filter_recal_series(df, abundance_score_threshold, peak_distance_threshold)
 
@@ -209,7 +211,9 @@ find_series <- function(df,
   subsets_filtered <- filter_subsets_based_on_coverage(subsets, coverage_threshold, global_max, global_min)
 
   # Compute the scores
-  scores <- lapply(subsets_filtered, function(x) { compute_scores(x) })
+  scores <- lapply(subsets_filtered, function(x) {
+    compute_scores(x)
+  })
 
   # Append all scored combinations into a dataframe
   scores_df <- do.call(rbind, lapply(scores, as.data.frame))
@@ -219,4 +223,4 @@ find_series <- function(df,
 
   # Return the top scoring series
   return(final_series)
-}
\ No newline at end of file
+}

From 066d94a0775457643da786bd137219f922f3a486 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Wed, 4 Sep 2024 12:54:52 +0200
Subject: [PATCH 22/27] linting done

---
 tests/testthat/test-findRecalSeries.R | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index 690fefd..f558bdf 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -1,5 +1,5 @@
 test_that("Filtering input dataframe works", {
-  pos_recalList <-head(readRDS(file.path("test-data", "pos_recallist.rds")), 10)
+  pos_recalList <- head(readRDS(file.path("test-data", "pos_recallist.rds")), 10)
   colnames(pos_recalList) <- gsub(" ", ".", colnames(pos_recalList))
   expected <- readRDS("test-data/filtered_recallist.rds")
   actual <- filter_recal_series(pos_recalList, abundance_score_threshold = 0, peak_distance_threshold = 2)
@@ -32,8 +32,7 @@ test_that("Filtering of the subsets based on coverage works", {
   expected <- readRDS("test-data/filtered_subsets.rds")
   actual <- filter_subsets_based_on_coverage(df, 80, 206, 117)
   expect_equal(actual, expected)
-}
-)
+})
 
 test_that("Computing final scores work", {
   df <- head(readRDS("test-data/scores_df.rds"), 6)

From 495a0b40bf4ac3cefecd24574499c5070f19c781 Mon Sep 17 00:00:00 2001
From: Helge Hecht <helge.hecht@recetox.muni.cz>
Date: Thu, 5 Sep 2024 10:25:40 +0200
Subject: [PATCH 23/27] fixed filling

---
 R/FindRecalSeries.R                   | 19 +++++--------------
 tests/testthat/test-findRecalSeries.R | 10 +++++++++-
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 03c7e48..66f3d22 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -6,7 +6,6 @@
 #' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
 #' better.
 #' @return A filtered dataframe.
-
 filter_recal_series <- function(df, abundance_score_threshold, peak_distance_threshold) {
   df <- df %>%
     dplyr::filter(Abundance.Score > abundance_score_threshold) %>%
@@ -27,7 +26,6 @@ filter_recal_series <- function(df, abundance_score_threshold, peak_distance_thr
 #' @param n Number of combinations to compute.
 #'
 #' @return A dataframe of row-index based combinations.
-
 compute_combinations <- function(df, n) {
   combs <- gtools::combinations(nrow(df), n, v = seq_len(nrow(df)))
   return(combs)
@@ -39,7 +37,6 @@ compute_combinations <- function(df, n) {
 #' @param n Number of combinations to compute.
 #'
 #' @return A list of subsets based on series combinations.
-
 compute_subsets <- function(df, n) {
   subsets <- apply(compute_combinations(df, n), 1, function(x) {
     df[x, ]
@@ -49,12 +46,11 @@ compute_subsets <- function(df, n) {
 
 #' Computes coverage of a subset.
 #' This function computes m/z range coverage of a particular subset. The higher coverage, the better.
-#' @param subset A subset of pre-filtered input data, has a size of combination number.
-#' @param global_min A lower bound of the instrument m/z range.
-#' @param global_max A higher bound of the instrument m/z range.
+#' @param subset DataFrame A subset of pre-filtered input data, has a size of combination number.
+#' @param global_min numeric A lower bound of the instrument m/z range.
+#' @param global_max numeric A higher bound of the instrument m/z range.
 #'
 #' @return Coverage (in %) of a particular subset.
-
 compute_coverage <- function(subset, global_max, global_min) {
   subset <- subset[order(subset$Min.Mass.Range), ]
 
@@ -90,7 +86,6 @@ compute_coverage <- function(subset, global_max, global_min) {
 #' @param global_max A higher bound of the instrument m/z range.
 #'
 #' @return A list of subsets which pass the coverage threshold (their coverage is higher than the threshold)
-
 filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global_max, global_min) {
   filtered_subsets <- Filter(function(x) compute_coverage(x, global_max, global_min) > coverage_threshold, subsets)
   return(filtered_subsets)
@@ -101,7 +96,6 @@ filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global
 #' @param combination A subset of pre-filtered input data, has a size of combination number.
 #'
 #' @return List of scores for individual parameters.
-
 compute_scores <- function(combination) {
   series <- paste0(combination$Series)
   total_abundance <- sum(combination$Abundance.Score)
@@ -125,7 +119,6 @@ compute_scores <- function(combination) {
 #' @param scores_df A dataframe of scores.
 #'
 #' @return A sorted dataframe containing the final score.
-
 compute_final_score <- function(scores_df) {
   final_score <- scores_df %>%
     dplyr::rowwise() %>%
@@ -144,17 +137,16 @@ compute_final_score <- function(scores_df) {
 #' combination will be returned.
 #'
 #' @return A dataframe of best-scoring series.
-
 find_final_series <- function(scores_df, number_of_combinations, fill_series) {
   final_series <- compute_final_score(scores_df)
 
   if (fill_series == FALSE) {
     final_series <- final_series %>%
-      head(number_of_combinations)
+      dplyr::slice_head(n = number_of_combinations)
   } else {
     final_series <- final_series %>%
       dplyr::distinct(series, .keep_all = TRUE) %>%
-      head(10)
+      dplyr::slice_head(n = 10)
   }
 
   return(final_series)
@@ -192,7 +184,6 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series) {
 #' combination will be returned.
 #'
 #' @return A dataframe of n-10 best-scoring series.
-
 find_series <- function(df,
                         global_min,
                         global_max,
diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index f558bdf..94378ae 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -52,7 +52,15 @@ patrick::with_parameters_test_that("Selection of the final series works",
   {
     df <- readRDS("test-data/scores_df.rds")
     expected <- readRDS(file.path("test-data", paste0("final_series", mode, ".rds")))
-    actual <- find_final_series(df, 3, mode)
+    n <- 3
+
+    actual <- find_final_series(df, n, mode)
+    if (mode == TRUE) {
+      expect_equal(nrow(actual), 5)
+    } else {
+      expect_true(nrow(actual), n)
+
+    }
     expect_equal(actual, expected)
   },
   mode = c(TRUE, FALSE)

From e1b77550d639992e3be2dfd3c3ca3e25ca58d5e0 Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Thu, 5 Sep 2024 12:43:52 +0200
Subject: [PATCH 24/27] type annotations, slice_head

---
 R/FindRecalSeries.R | 67 +++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 66f3d22..9f5525c 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -1,11 +1,11 @@
 #' Filters the input dataframe
 #' This function filters the input dataframe based on abundance score threshold and peak distance threshold; and
 #' computes the length of the series.
-#' @param df Input dataframe = an output from RecalList, containing recalibrant CH2 series.
-#' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
-#' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
+#' @param df DataFrame An output from RecalList, containing recalibrant CH2 series.
+#' @param abundance_score_threshold Float A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
+#' @param peak_distance_threshold Float A threshold for the peak distance parameter. The closer this value is to 1, the
 #' better.
-#' @return A filtered dataframe.
+#' @return DataFrame A filtered dataframe.
 filter_recal_series <- function(df, abundance_score_threshold, peak_distance_threshold) {
   df <- df %>%
     dplyr::filter(Abundance.Score > abundance_score_threshold) %>%
@@ -22,10 +22,10 @@ filter_recal_series <- function(df, abundance_score_threshold, peak_distance_thr
 
 #' Computes all possible combinations of series
 #' This function computes all possible combinations of series. The number of combinations is specified by user.
-#' @param df A pre-filtered dataframe containing series.
-#' @param n Number of combinations to compute.
+#' @param df DataFrame A pre-filtered dataframe containing series.
+#' @param n Integer Number of combinations to compute.
 #'
-#' @return A dataframe of row-index based combinations.
+#' @return DataFrame A dataframe of row-index based combinations.
 compute_combinations <- function(df, n) {
   combs <- gtools::combinations(nrow(df), n, v = seq_len(nrow(df)))
   return(combs)
@@ -33,8 +33,8 @@ compute_combinations <- function(df, n) {
 
 #' Computes subsets based on combinations.
 #' This function selects subsets of the input data based on the combinations of series.
-#' @param df A pre-filtered dataframe containing series.
-#' @param n Number of combinations to compute.
+#' @param df DataFrame A pre-filtered dataframe containing series.
+#' @param n Integer Number of combinations to compute.
 #'
 #' @return A list of subsets based on series combinations.
 compute_subsets <- function(df, n) {
@@ -47,8 +47,8 @@ compute_subsets <- function(df, n) {
 #' Computes coverage of a subset.
 #' This function computes m/z range coverage of a particular subset. The higher coverage, the better.
 #' @param subset DataFrame A subset of pre-filtered input data, has a size of combination number.
-#' @param global_min numeric A lower bound of the instrument m/z range.
-#' @param global_max numeric A higher bound of the instrument m/z range.
+#' @param global_min Float A lower bound of the instrument m/z range.
+#' @param global_max Float A higher bound of the instrument m/z range.
 #'
 #' @return Coverage (in %) of a particular subset.
 compute_coverage <- function(subset, global_max, global_min) {
@@ -80,12 +80,12 @@ compute_coverage <- function(subset, global_max, global_min) {
 
 #' Filters subsets based on the coverage.
 #' This function filters the subsets based on the coverage threshold.
-#' @param subsets A subset of pre-filtered input data, has a size of combination number.
-#' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
-#' @param global_min A lower bound of the instrument m/z range.
-#' @param global_max A higher bound of the instrument m/z range.
+#' @param subsets DataFrame A subset of pre-filtered input data, has a size of combination number.
+#' @param coverage_threshold Integer How many % of the m/z range should be covered. Default is 90 %.
+#' @param global_min Float A lower bound of the instrument m/z range.
+#' @param global_max Float A higher bound of the instrument m/z range.
 #'
-#' @return A list of subsets which pass the coverage threshold (their coverage is higher than the threshold)
+#' @return List A list of subsets which pass the coverage threshold (their coverage is higher than the threshold)
 filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global_max, global_min) {
   filtered_subsets <- Filter(function(x) compute_coverage(x, global_max, global_min) > coverage_threshold, subsets)
   return(filtered_subsets)
@@ -93,9 +93,9 @@ filter_subsets_based_on_coverage <- function(subsets, coverage_threshold, global
 
 #' Computes the scores for individual subsets.
 #' This function computes individual scores for the particular combination of series.
-#' @param combination A subset of pre-filtered input data, has a size of combination number.
+#' @param combination DataFrame A subset of pre-filtered input data, has a size of combination number.
 #'
-#' @return List of scores for individual parameters.
+#' @return List List of scores for individual parameters.
 compute_scores <- function(combination) {
   series <- paste0(combination$Series)
   total_abundance <- sum(combination$Abundance.Score)
@@ -116,14 +116,15 @@ compute_scores <- function(combination) {
 
 #' Compute a sum score for the whole combination.
 #' This function computes a score summing all parameter scores and arranges them in descending manner.
-#' @param scores_df A dataframe of scores.
+#' @param scores_df DataFrame A dataframe of scores.
 #'
-#' @return A sorted dataframe containing the final score.
+#' @return DataFrame A sorted dataframe containing the final score.
 compute_final_score <- function(scores_df) {
   final_score <- scores_df %>%
     dplyr::rowwise() %>%
     dplyr::mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity)) %>%
-    dplyr::arrange(desc(sum_score))
+    dplyr::arrange(desc(sum_score)) %>%
+    ungroup()
 
   return(final_score)
 }
@@ -131,12 +132,12 @@ compute_final_score <- function(scores_df) {
 #' Selects final series.
 #' This function selects final best-scoring series. An user can choose, whether only a number of series corresponding
 #' to the size of the combination will be returned, or 10 best-scoring 10 series will be returned.
-#' @param scores_df A dataframe of scores.
-#' @param number_of_combinations Number of combinations to compute.
-#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best
+#' @param scores_df DataFrame A dataframe of scores.
+#' @param number_of_combinations Integer Number of combinations to compute.
+#' @param fill_series Boolean If TRUE, top 10 unique series will be returned, otherwise only the series from the best
 #' combination will be returned.
 #'
-#' @return A dataframe of best-scoring series.
+#' @return DataFrame A dataframe of best-scoring series.
 find_final_series <- function(scores_df, number_of_combinations, fill_series) {
   final_series <- compute_final_score(scores_df)
 
@@ -171,16 +172,16 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series) {
 #'
 #' Warning: this step is in general computationally demanding, for ~30 series it took around 30 min.
 #'
-#' @param df An output from RecalList, containing recalibrant CH2 series.
-#' @param global_min A lower bound of the instrument m/z range.
-#' @param global_max A higher bound of the instrument m/z range.
-#' @param number_of_combinations Combinations of how many series should be computed. Default is 5, Recal function can
+#' @param df DataFrame An output from RecalList, containing recalibrant CH2 series.
+#' @param global_min Float A lower bound of the instrument m/z range.
+#' @param global_max Float A higher bound of the instrument m/z range.
+#' @param number_of_combinations Integer Combinations of how many series should be computed. Default is 5, Recal function can
 #' take up to 10 series, but the more combinations, the longer computing time is expected (growing exponentially)
-#' @param abundance_score_threshold A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
-#' @param peak_distance_threshold A threshold for the peak distance parameter. The closer this value is to 1, the
+#' @param abundance_score_threshold Float A threshold for filtering abundance score parameter. The series with higher values #' are better. Default value is 100.
+#' @param peak_distance_threshold Float A threshold for the peak distance parameter. The closer this value is to 1, the
 #' better.
-#' @param coverage_threshold How many % of the m/z range should be covered. Default is 90 %.
-#' @param fill_series If TRUE, top 10 unique series will be returned, otherwise only the series from the best
+#' @param coverage_threshold Integer How many % of the m/z range should be covered. Default is 90 %.
+#' @param fill_series Boolean If TRUE, top 10 unique series will be returned, otherwise only the series from the best
 #' combination will be returned.
 #'
 #' @return A dataframe of n-10 best-scoring series.

From 54613e2e5b57ebb8e215c847a1fc54d23dc72c9e Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Thu, 5 Sep 2024 12:59:47 +0200
Subject: [PATCH 25/27] arrange instead of order

---
 R/FindRecalSeries.R | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index 9f5525c..b5c86c5 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -52,7 +52,10 @@ compute_subsets <- function(df, n) {
 #'
 #' @return Coverage (in %) of a particular subset.
 compute_coverage <- function(subset, global_max, global_min) {
-  subset <- subset[order(subset$Min.Mass.Range), ]
+  subset <- subset %>%
+    dplyr::arrange(Min.Mass.Range)
+  
+  #subset <- subset[order(subset$Min.Mass.Range), ]
 
   # Initialize the coverage and the end of the last segment
   total_coverage <- 0
@@ -124,7 +127,7 @@ compute_final_score <- function(scores_df) {
     dplyr::rowwise() %>%
     dplyr::mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity)) %>%
     dplyr::arrange(desc(sum_score)) %>%
-    ungroup()
+    dplyr::ungroup()
 
   return(final_score)
 }

From dcd40510eb0415ae236ec2d214a5c256d0e0b61c Mon Sep 17 00:00:00 2001
From: KristinaGomoryova <gomoryova@sci.muni.cz>
Date: Thu, 5 Sep 2024 15:54:25 +0200
Subject: [PATCH 26/27] find_final_series works only partially

---
 R/FindRecalSeries.R                           |   4 +-
 .../testthat/test-data/final_seriesFALSE.rds  | Bin 395 -> 309 bytes
 tests/testthat/test-data/final_seriesTRUE.rds | Bin 493 -> 648 bytes
 tests/testthat/test-data/scores_df_full.rds   | Bin 0 -> 16210 bytes
 tests/testthat/test-findRecalSeries.R         |  38 +++++++++++-------
 5 files changed, 26 insertions(+), 16 deletions(-)
 create mode 100644 tests/testthat/test-data/scores_df_full.rds

diff --git a/R/FindRecalSeries.R b/R/FindRecalSeries.R
index b5c86c5..0f6f3c4 100644
--- a/R/FindRecalSeries.R
+++ b/R/FindRecalSeries.R
@@ -127,7 +127,7 @@ compute_final_score <- function(scores_df) {
     dplyr::rowwise() %>%
     dplyr::mutate(sum_score = sum(total_abundance, total_series_length, peak_proximity, peak_distance_proximity)) %>%
     dplyr::arrange(desc(sum_score)) %>%
-    dplyr::ungroup()
+    dplyr::ungroup() 
 
   return(final_score)
 }
@@ -147,10 +147,12 @@ find_final_series <- function(scores_df, number_of_combinations, fill_series) {
   if (fill_series == FALSE) {
     final_series <- final_series %>%
       dplyr::slice_head(n = number_of_combinations)
+    saveRDS(final_series, "test-data/final_seriesFALSE.rds")
   } else {
     final_series <- final_series %>%
       dplyr::distinct(series, .keep_all = TRUE) %>%
       dplyr::slice_head(n = 10)
+    saveRDS(final_series, "test-data/final_seriesTRUE.rds")
   }
 
   return(final_series)
diff --git a/tests/testthat/test-data/final_seriesFALSE.rds b/tests/testthat/test-data/final_seriesFALSE.rds
index 47560eb8d4551d8a976f8ae2888305c700b5f890..c9b6a5a7e1aabdfb2fa76688a60a6307f3821fe2 100644
GIT binary patch
literal 309
zcmV-50m}X#iwFP!000001B>8dU|?WoU}0foU}gm}8CXL@+;lB~V!}WUI}i&%6fkgt
zB>m$(;?1EPHh&`^&kV|A_csUf42^+IK9CNFuH-!@Lj`@%X}ElSC!5M$eMxj0E}x{%
zQQmZNDLM_8Un=rEzid_<I*sOH5wMFDAWl_)xshBsnB5x^Hh+76V>&v`z`();lxKv6
zR&q{aaWR^M*h-Re;#1O~JZ2yd%H&E(EJ@T$D@x2wMKg!9D8F1U4=4^Yix-HQ8i2(A
z|NsA@TL@Dm0FFDTg~h2wnLtqpkG~|pBrzvGF{v~!B{45K6)G$Y5r!y@&q>WoFUf#P
z@fD;dX2%y4<yU0pW|mY!Ma99QDVfD3AX6};IiV(HroaVCbK{GX^NWC<WB3OEK_3mM
Hb^-tZisXD)

literal 395
zcmV;60d)Q!iwFP!000001C>&{N&`U@oqa@2NMay`jYU2{)0lu@V<id!8wCqtnCwoH
z#eK0eF{VplXRRPuh+kr9>vvfA1!ldInOVccLW`Mm@4091WA9v45JC=eT?;uSFj49J
z>}Yo%xF$I3a2is8%789D#(PV4XUXmY)`j-9Gdg+R?tYr6<A>pfD1=Nb;<Jb9OLTu}
zViCW4KRwvF{V>t!wJv&Xi6&c%?*7B-N{?Rkt@qS35eBv)ZmF+JUPu^I<y}QqvScy|
z7{&fTF>AaZ{&)^}TIv%{+JlTl)W}?hB<&b@k-Y}Tp23yp`Ip&(7Bv=IQw15#0$`=L
z$rDaOO#0*4C$UEr-ITPH;*iEeKGJ_BrQ`~yS#lFZ0iP;%Yr*;f<08vSxU4b-enE^Q
z%)BHshg%zF$v9=|saXmgHL0bJw(TX`F{e-YG^I*_WYEfu_fWg`cm@+f<2cb<s7O-W
p`Y8(m;9RD0bef`88+O8E(9VBf%S!FPtzOhb^KbRA&g_x{001Jsx&;6L

diff --git a/tests/testthat/test-data/final_seriesTRUE.rds b/tests/testthat/test-data/final_seriesTRUE.rds
index 7018b70952f1212193b974642ed2c3ffca0ff020..e1742a1fc77ec0baeaed031ec12dc42cf904b13b 100644
GIT binary patch
delta 619
zcmV-x0+jvj1BeBXD1QJk7Xu3eCrHvi-Xq=|%3<?20`knDJa&I`AkWYk&IL&t8p73L
zku-rzT7bB4o(Yg=1m_t8dB({0n*kYoAV)cLCGR;ID(Hhjcl`AZ@LV^`p?m*cG1J}*
zht|W3t*>XQIJC%2Ft&dX=Fn37ccXAnr$ejZ#cAt#+#FhLmw$UsFertaTi?m1a#vpx
zCtcAFqNN-fMIO4Z6RC1&Z21oY4h>5V^~Y#@1*+q+Em(Zbp>D;I*-IY>!Ocxl=O}MF
zxfGMO(RuZB{Z5A@m6shGQe7O9zTFX=y=}fj(xNKODc7esBu!;zG>_46NYWD2Q|_JV
zkk&u@UHja7aDQ``iagIRn-zyi$6orqtZ#|KQpt}pURjC`OKtddEYx;6ER}PQ-5kBj
zVX3Ibj}sP34od}um3}N`cUUT8T{lJcEn1|DfFoT2659%>(M+zK7)%tBO3-9QVX|OB
zyjo3gX$2=KT$11vhD#Eh;IR3{4BaoV@ZXTI`P=&&(|<APNS2L_wNo56$hF_Ex4G%C
zLEt>Q<bq=k>o;8Hm04)vu)bxb#rK{g4(kg%ADe8=aaf<ZeQ{_4Fukxa0nKHECHlO?
z+|*)dq_D&CMR96TCQuZ@<1fiCNz92)Oe)PwNz6-5g$fHpgds}fb5irtOERERd<ChA
z+3^KM`D7KDxtS%EP*HKPXi8>r3CI)-X-=p~nJI9A(%kss<ou#kG&ge=<(KQh+|3Kb
zObtK+m`A>$doDRAu^8q#W|-$nl5*lx(x5zMAP>sqN=Yn9)JrP@8Vuz90{}mgt0lbz
F0085?BohDt

delta 463
zcmV;=0WkiE1?>ZnD1U$i8CV!Nfiz3JN4zl-+XRViio`ZUVw(eLK9Cs)Ofozd$e6yz
zpdB99v?S<0KM?T5vC-~z5=^~A4hP6V3>b7qI}?xRu6QUN2Up)Pjb~Br)EG?qU}l>7
ziO&uVlRkPq`B4Q|-+j^FTBqeTHriE#QQx8a^xy1jr}fanfPW7Z1_~h0D<JurEKySh
zq_9F2g@>BM%w(PuK6899=oyz4HuFinbC_Wy+;Ukf3mDi;K=q7J(^!*p5{rwWPG^A%
zauwy5muD8I#;2q~Mc7J`au7UbAP=TAC9xz?FRdssHx<ofPM{%rc|dWH>AXP9)Bq&@
z|Ns9R-3c&70)OC?1hud@wI~xP3gPjW<d-Do#3v?|=A|U&C8t7#g(1QarSUnbdFdq?
zuuv*UP0WrjD9W$M%*`yRgo=uTMN=}1OF*VzNOM9>%1nU^l;*}4C+8QTdyXx=D8ICz
z7@GVUp)@Phr;JbxV>2PKnUUBmNNiU0P$?*>EJ%eaU`T*SGX95#5;Ig0Z&`9l5zyyA
z55?!hVuuSN2qIzG3#0%@|AQFA3^N99mmV;#iXoCr|FK6GhTX&^36Px({{X#5)95|~
F000<M%WD7t

diff --git a/tests/testthat/test-data/scores_df_full.rds b/tests/testthat/test-data/scores_df_full.rds
new file mode 100644
index 0000000000000000000000000000000000000000..5dfd47bacbd0270f538bf86eaa21629332bf1bc9
GIT binary patch
literal 16210
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

literal 0
HcmV?d00001

diff --git a/tests/testthat/test-findRecalSeries.R b/tests/testthat/test-findRecalSeries.R
index 94378ae..4b6b998 100644
--- a/tests/testthat/test-findRecalSeries.R
+++ b/tests/testthat/test-findRecalSeries.R
@@ -48,20 +48,28 @@ test_that("Computing scores works", {
   expect_equal(actual, expected)
 })
 
-patrick::with_parameters_test_that("Selection of the final series works",
-  {
-    df <- readRDS("test-data/scores_df.rds")
-    expected <- readRDS(file.path("test-data", paste0("final_series", mode, ".rds")))
-    n <- 3
+test_that("Positive final series work", {
+  df <- readRDS("test-data/scores_df_full.rds")
+  expected <- readRDS("test-data/final_seriesTRUE.rds")
+  actual <- find_final_series(df, 3, TRUE)
+  expect_equal(actual, expected)
+})
 
-    actual <- find_final_series(df, n, mode)
-    if (mode == TRUE) {
-      expect_equal(nrow(actual), 5)
-    } else {
-      expect_true(nrow(actual), n)
+#patrick::with_parameters_test_that("Selection of the final series works",
+#  {
+#    df <- readRDS("test-data/scores_df_full.rds")
+#    expected <- readRDS(file.path("test-data", paste0("final_series", mode, ".rds")))
+#    n <- 3
 
-    }
-    expect_equal(actual, expected)
-  },
-  mode = c(TRUE, FALSE)
-)
+#    actual <- find_final_series(df, n, mode)
+  #  if (mode == TRUE) {
+  #    expect_equal(nrow(actual), 10)
+  # } else {
+  #    expect_true(nrow(actual), n)
+  #
+  #  }
+  #  expect_equal(actual, expected)
+#  expect_equal(actual,expected)
+#  },
+#  mode = c(TRUE, FALSE)
+#)

From 0380c8315df5b156e25479dcc2b60bf9cea0e899 Mon Sep 17 00:00:00 2001
From: Helge Hecht <helge.hecht@recetox.muni.cz>
Date: Thu, 5 Sep 2024 16:46:22 +0200
Subject: [PATCH 27/27] upsated test output to ungrouped df

---
 tests/testthat/test-data/final_scores.rds | Bin 461 -> 352 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/tests/testthat/test-data/final_scores.rds b/tests/testthat/test-data/final_scores.rds
index 7073bee5d7a1ebb62654d39061441ee11ccaea05..824afe2d7be706bbbd4403b5ee38ada6a9b2631f 100644
GIT binary patch
delta 162
zcmV;T0A2sh1K<LX#(!q0AX`aNPJBull*bI@L77}Bi6x18X+?>-sc7bK7Uh@g<pIS(
zX7K_sQv;Cr|Ns9lbPHjM1i&c}YGH9|Q6^9n!s9Q=FG<XaPfRM!OG(U2PK62!Lxdqp
z<8xB;(n~U6VN;Nrm>pkGlwXmVn^{r`6%_}IreqeEfK0)V<{N~Xl$in-D9w#8PR=g^
QdXC{A0Mg06qdWru0L*+vU;qFB

delta 272
zcmV+r0q_3c0?h-E#(x&5AXia-d3k1WYJ5r>RD`W0DF?x02J&D^QxZ!O_0ozGb5qew
z<^&p|mj@IFna&HuObtNd|NsBL&=j(z7v+~06hjjwBa~)?>SBaq7@G-+&5XomL1MEa
zvDwf)Tu@S3kP2160Fh+;4-Eijs3P97<dUM|_?*n*lK6a>uYb89f*=x>=s^mA^gnbv
zVBQu$7Ssa<NHIhu(|_z?g5eP2!X4%SR+x5nnD*k-qD-JmAUyt({F20+_{5~ryp+Ve
z<W#7zFhm%lG(IOaFTErKmgWjl6SLzBit;Nmb2CdSp`zko(G;NHL8f3xb3#qZOo0oO
W=EfH%=NEyU3JCyN8y2jT1ONcqi+gMU