Package 'DaparToolshed'

Description

Adds one or more items to the dataset. This function is specific of the type of dataset.

Usage

Add_Item_to_Dataset(dataset, name)

Arguments

Value

The dataset minus some items

Description

This function adds a row to the history.

Usage

Add2History(history, process, step.name, param.name, value)

Arguments

Value

A data.frame with one added row

Examples

history <- InitializeHistory()
Add2History(history, "Process1", "Step1", "Parameter1", "Value1")

Description

These functions filters (delete) peptides of an assay, applying a function on peptides and proteins. They can be used alone but the usual usage is to create an instance of a class FunctionFilter and to pass it to the function filterFeaturesOneSE in order to create a new assay, embedded into the QFeatures object.

Usage

AdjMatFilters()

allPeptides(object, ...)

specPeptides(object, ...)

subAdjMat_specificPeptides(X)

sharedPeptides(object, ...)

subAdjMat_sharedPeptides(X)

topnFunctions()

topnPeptides(object, fun, top)

subAdjMat_topnPeptides(X, qData, fun, top)

Arguments

Details

This function builds an intermediate matrix with scores for each peptide based on 'fun' parameter. Once this matrix is built, one select the 'n' peptides which have the higher score

The list of filter functions is given by adjMatFilters():

• specPeptides(): returns a new assay of class SummazizedExperiment with only specific peptides;

• sharedpeptides(): returns a new assay of class SummazizedExperiment with only shared peptides;

• opnPeptides(): returns a new assay of class SummazizedExperiment with only the 'n' peptides which best satisfies the condition. The condition is represented by functions which calculates a score for each peptide among all samples. The list of these functions is given by topnFunctions():

• rowMedians(): returns the median of the entities in each selected row;

• rowMeans(): returns the median of the entities in each selected row;

• rowSums(): returns the sum of the entities in each selected row;

Value

NA

Author(s)

Samuel Wieczorek

See Also

The QFeatures-filtering-oneSE man page for the class FunctionFilter.

Examples

library(Matrix)
library(QFeatures)
#------------------------------------------------
# This function will keep only specific peptides
#------------------------------------------------

f1 <- FunctionFilter("specPeptides", list())

#------------------------------------------------
# This function will keep only shared peptides
#------------------------------------------------

f2 <- FunctionFilter("sharedPeptides", list())

#------------------------------------------------
# This function will keep only the 'n' best peptides
# w.r.t the quantitative sum of each peptides among
# all samples
#------------------------------------------------

f3 <- FunctionFilter("topnPeptides", fun = "rowSums", top = 2)

#------------------------------------------------------
# IF several filters must be used, store them in a list
#------------------------------------------------------

data(subR25pept)
lst.filters <- list()
lst.filters <- append(lst.filters, f1)
lst.filters <- append(lst.filters, f3)

subR25prot <- filterFeaturesOneSE(
    object = subR25pept,
    i = 1,
    name = "filtered",
    filters = lst.filters
)

Description

iteratively applies OWAnova() on the features of an MSnSet object

Usage

applyAnovasOnProteins(obj, i)

Arguments

Value

a list of linear models

Author(s)

Thomas Burger

Examples

data(subR25prot)
applyAnovasOnProteins(subR25prot[seq_len(5),], 1)

Description

Method to create a binary matrix with proteins in columns and peptides in lines on a SummarizedExperiment object (peptides)

Usage

BuildAdjacencyMatrix(obj.pep)

Arguments

Value

A binary matrix

Author(s)

Florence Combes, Samuel Wieczorek, Alexia Dorffer

Examples

data(subR25pept)
BuildAdjacencyMatrix(subR25pept[[1]])

Description

Display a CC

Usage

buildGraph(The.CC, X)

Arguments

Value

A plot

Author(s)

Thomas Burger, Samuel Wieczorek

Examples

data(subR25pept)
X <- QFeatures::adjacencyMatrix(subR25pept[[1]])
ll <- getPepProtCC(X)
g <- buildGraph(ll[[1]], X)

Description

Create metacell

Usage

BuildMetacell(from = NULL, level, qdata = NULL, conds = NULL, df = NULL)

Arguments

Value

NA

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
conds <- design_qf(subR25pept)$Condition
qdata <- SummarizedExperiment::assay(subR25pept[[1]])
metacell1 <- BuildMetacell('maxquant', 'peptide', qdata, conds)
metacell2 <- BuildMetacell('proline', 'peptide', qdata, conds)

Description

Check if the design is valid

Usage

checkConditions(conds)

Arguments

Value

A list including : "valid" : Wether the conditions are valid or not. "warn" : A message describing the issue if the conditions ar not valid.

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
checkConditions(design_qf(subR25pept)$Condition)

Description

Check if the design is valid

Usage

checkDesign(sTab)

Arguments

Value

A boolean

Author(s)

Thomas Burger, Samuel Wieczorek

Examples

data(subR25pept)
checkDesign(SummarizedExperiment::colData(subR25pept)[, -1])

Description

Names of all children of a node

Usage

Children(level, parent = NULL)

Arguments

Value

A vector

Examples

Children('protein', 'Missing')
Children('protein', 'Missing POV')
Children('protein', c('Missing POV', 'Missing MEC'))
Children('protein', c('Missing', 'Missing POV', 'Missing MEC'))

Description

Function to perform a One-way Anova statistical test on a MsnBase dataset

Usage

classic1wayAnova(current_line, conditions)

Arguments

Value

A named vector containing all the different values of the aov model

Author(s)

Hélène Borges

Examples

library(SummarizedExperiment)
data(subR25prot)
obj <- subR25prot
filter <- FunctionFilter('qMetacellOnConditions',
  cmd = 'delete',
  mode = 'AtLeastOneCond',
  pattern = c("Missing POV", "Missing MEC"),
  conds = design_qf(obj)$Condition,
  percent = TRUE,
  th = 0.8,
  operator = '>')
obj <- filterFeaturesOneSE(obj, name = "Filtered", filters = list(filter))

qdata <- SummarizedExperiment::assay(obj[[2]])
conds <- design_qf(obj)$Condition
anova_tests <- apply(qdata, 1, classic1wayAnova, conditions = as.factor(conds))
anova_tests <- t(anova_tests)

Description

Clean row data

Usage

CleanRowData(obj, i)

Arguments

Value

An instance of the SummarizedExperiment structure

Author(s)

Samuel Wieczorek

Examples

NULL

Description

Plot to compare the quantitative proteomics data before and after normalization using the package plotly

Usage

compareNormalizationD_HC(
  qDataBefore,
  qDataAfter,
  keyId = NULL,
  conds = NULL,
  pal = NULL,
  subset.view = NULL,
  n = 100,
  type = "scatter"
)

Arguments

Value

A plot

Author(s)

Samuel Wieczorek

Examples

library(SummarizedExperiment)
data(subR25prot)
qDataBefore <- SummarizedExperiment::assay(subR25prot[[1]])
conds <- design_qf(subR25prot)$Condition
id <- rowData(subR25prot[[1]])[, idcol(subR25prot[[1]])]
# pal <- ExtendPalette(2)
qDataAfter <- LOESS(qDataBefore, conds, type = "overall")

n <- 1
compareNormalizationD_HC(
qDataBefore = qDataBefore,
qDataAfter = qDataAfter, 
keyId = id, 
pal = NULL, 
n = n,
subset.view = seq_len(n),
conds = conds)

Description

Compute a t-test

Usage

compute_t_tests(
  obj,
  i = 1,
  contrast = c("OnevsOne", "OnevsAll"),
  type = c("Student", "Welch")
)

Arguments

Value

A list of two items : logFC and P_Value; both are dataframe. The first one contains the logFC values of all the comparisons (one column for one comparison), the second one contains the pvalue of all the comparisons (one column for one comparison). The names of the columns for those two dataframes are identical and correspond to the description of the comparison.

Author(s)

Florence Combes, Samuel Wieczorek

Examples

library(SummarizedExperiment)
data(subR25prot)
obj <- subR25prot
filter <- FunctionFilter('qMetacellOnConditions',
  cmd = 'delete',
  mode = 'AtLeastOneCond',
  pattern = c("Missing POV", "Missing MEC"),
  conds = design_qf(obj)$Condition,
  percent = TRUE,
  th = 0.8,
  operator = '>')
obj <- filterFeaturesOneSE(obj, name = "Filtered", filters = list(filter))
ttest <- compute_t_tests(obj, 2)

Description

Convert a list to unnumbered HTML list

Usage

ConvertListToHtml(ll)

Arguments

Value

HTML

Examples

ConvertListToHtml(list('foo1', 'foo2', 'foo3'))

Description

Creates an object of class QFeatures from a single tabulated-like file for quantitative and meta-data and a dataframe for the samples description.

Usage

createQFeatures(
  data = NULL,
  file = "myDataset",
  sample,
  indQData,
  keyId = "AutoID",
  indexForMetacell = NULL,
  logData = FALSE,
  force.na = TRUE,
  typeDataset,
  parentProtId = NULL,
  analysis = "foo",
  description = NULL,
  processes = NULL,
  typePipeline = NULL,
  name.pipeline = NULL,
  software = NULL,
  name = "original"
)

Arguments

Value

An instance of class QFeatures.

Author(s)

Samuel Wieczorek, Manon Gaudin

Examples

NULL

Description

This function aggregates the quantitative features of an assay, applying a summarization function (fun) to sets of features. The fcol variable name points to a rowData column that defines how to group the features during aggregate. This variable has to be an adjacency matrix. This function uses QFeatures::aggregateFeatures() to aggregate quantitative data.

The list of agregation methods can be obtained with the function aggregateMethods(). This function compiles both methods from the packages DaparToolshed and QFeatures.

Aggregate the quantitative metadata tag.

This function aggregate both quantitative and rowdata from the last assay contained in a QFeatures. Note that the function assumes that the intensities in the QFeatures are already log-transformed.

This function creates a column for the protein dataset after aggregation by using the previous peptide dataset.

Aggregation of rowData of a QFeatures assay.

Aggregate the metadata

This function computes the number of proteins that are only defined by specific peptides, shared peptides or a mixture of two.

This function computes the number of peptides used to aggregate proteins.

Method to compute the number of quantified peptides used for aggregating each protein

Method to compute the detailed number of quantified peptides used for aggregating each protein

Method to compute the detailed number of quantified peptides for each protein

Method to create a plot with proteins and peptides on a MSnSet object (peptides)

This function aggregate quantitative data using a method of redistribution of shared peptides. Intensity of shared peptides are redistributed proportionally to each protein. Note that the function assumes that the intensities are not log-transformed.

Aggregation using sum method.

Aggregation using mean method.

Aggregation using median method.

Aggregation using medianPolish method. Note that this method is parallelized to be more efficient.

Aggregation using robustSummary method.

Usage

aggregateFeatures4Prostar(object, ...)

## S4 method for signature 'QFeatures'
aggregateFeatures4Prostar(
  object,
  i,
  fcol,
  name = "newAssay",
  fun = MsCoreUtils::robustSummary,
  shared = TRUE,
  n = NULL,
  ...
)

## S4 method for signature 'SummarizedExperiment'
aggregateFeatures4Prostar(
  object,
  fcol,
  fun = MsCoreUtils::robustSummary,
  conds,
  shared = TRUE,
  n = NULL,
  ...
)

aggQmetacell(qMeta, X, level, conds)

aggregateMethods()

RunAggregation(
  qf,
  includeSharedPeptides = "Yes_As_Specific",
  operator = "Mean",
  considerPeptides = "allPeptides",
  adjMatrix = "adjacencyMatrix",
  ponderation = "Global",
  n = NULL,
  aggregated_col = NULL,
  max_iter = 500
)

BuildColumnToProteinDataset(peptideData, matAdj, columnName, proteinNames)

Add_Aggregated_rowData(obj, col, i.agg)

metacell_agg(aggregatedSE, originalSE, adj_mat, conds, protname_order)

select_topn(pepData, X, n = 10, funpept = "Mean")

getProteinsStats(X)

CountPep(X)

GetNbPeptidesUsed(pepData, X)

GetDetailedNbPeptidesUsed(pepData, X)

GetDetailedNbPeptides(X)

GraphPepProt(mat)

ExtractUniquePeptides(X)

innerAggregateIter(
  pepData,
  X,
  init.method = "Mean",
  method = "Mean",
  n = NULL,
  uniqueiter = FALSE,
  topn_fun = "Mean",
  max_iter = 500
)

innerSum(pepData, X)

innerMean(pepData, X)

innerMedian(pepData, X)

innerMedianpolish(pepData, X)

innerRobustsummary(pepData, X)

Arguments

Details

This function uses QFeatures::aggregateFeatures() to aggregate quantitative data.

Aggregation of quantitative data is performed using aggregateFeatures, or innerAggregateIter if Yes_Iterative_Redistribution or Yes_Simple_Redistribution is selected.

The handling of shared peptide is as follow :

• Yes_As_Specific : Shared peptides are used multiple times. Each peptide is duplicated as many times as the number of proteins in which they are present, and thus are considered as if they are specific to each protein.

• Yes_Simple_Redistribution : Intensity of shared peptides are redistributed proportionally to each protein. See innerAggregateIter for more information.

• Yes_Iterative_Redistribution : Intensity of shared peptides are redistributed proportionally to each protein. See innerAggregateIter for more information.

• No : No shared peptides are used. If a peptide contained only shared peptides, its intensity is set as 0 for every sample.

Available functions are :

• Sum : base::colSums()] or base::rowSums() if Yes_Iterative_Redistribution or Yes_Simple_Redistribution.

• Mean : base::colMeans()] or base::rowMeans() if Yes_Iterative_Redistribution or Yes_Simple_Redistribution.

• Median : matrixStats::mcolMedians()] or matrixStats::rowMedians() if Yes_Iterative_Redistribution or Yes_Simple_Redistribution.

• medianPolish : MsCoreUtils::medianPolish().

• robustSummary : MsCoreUtils::robustSummary().

Available functions are :

• Sum : base::rowSums()

• Mean : base::rowMeans()

• Median : matrixStats::rowMedians()

• medianPolish : MsCoreUtils::medianPolish(), not available for topn_fun. Note that this method takes significantly more time than the others, and is parallelized to be more efficient.

• robustSummary : MsCoreUtils::robustSummary(), not available for topn_fun. Note that this method takes significantly more time than the others, and is parallelized to be more efficient.

Value

A QFeatures object with an additional assay or a SummarizedExperiment object (or subclass thereof).

An instance of the QFeatures class

NA

A QFeatures with an aggregated assay added.

A vector

An instance of QFeatures class with aggregated rowData in specified assay.

A SummarizedExperiment containing the aggregated data.

An adjacency matrix with only the top n peptides selected.

A list

A vector of boolean which is the adjacency matrix but with NA values if they exist in the intensity matrix.

A data.frame

A list of two items

A data.frame

A histogram

A matrix containing the aggregated values.

A matrix containing the aggregated values.

A matrix containing the aggregated values.

A matrix containing the aggregated values.

A matrix containing the aggregated values.

A matrix containing the aggregated values.

Quantitative metadata aggregation

The function to aggregate the quantitative metadata is aggQmetadat().

Author(s)

Samuel Wieczorek, Manon Gaudin

Samuel Wieczorek

Manon Gaudin

Alexia Dorffer

Alexia Dorffer, Samuel Wieczorek

See Also

The QFeatures vignette provides an extended example and the Aggregation vignette, for a complete quantitative proteomics data processing pipeline.

Examples

NULL
data(subR25pept)
qMeta <- qMetacell(subR25pept, 1)
X <- QFeatures::adjacencyMatrix(subR25pept[[1]])
level <- typeDataset(subR25pept[[1]])
conds <- SummarizedExperiment::colData(subR25pept)$Condition
aggQmeta <- aggQmetacell(qMeta, X, level, conds)

data(subR25pept)

# Remove empty lines
filter_emptyline <- FunctionFilter("qMetacellWholeLine", 
cmd = 'delete', pattern = 'Missing MEC')
subR25pept <- filterFeaturesOneSE(object = subR25pept, 
i = length(subR25pept), name = "Filtered",
              filters = list(filter_emptyline))
# Remove proteins with no peptide associated in adjacency matrix
indx <- which(Matrix::colSums(
SummarizedExperiment::rowData(
subR25pept[[length(subR25pept)]])$adjacencyMatrix) != 0)
SummarizedExperiment::rowData(
subR25pept[[length(subR25pept)]])$adjacencyMatrix <- 
SummarizedExperiment::rowData(
subR25pept[[length(subR25pept)]])$adjacencyMatrix[, indx]
  
obj.agg <- RunAggregation(subR25pept, "Yes_As_Specific", "Sum", "allPeptides",
aggregated_col = c("Sequence", "Mass"))
obj.agg <- RunAggregation(subR25pept, "Yes_As_Specific", "Mean", "allPeptides",
aggregated_col = c("Sequence", "Mass"))
obj.agg <- RunAggregation(subR25pept, "Yes_As_Specific", "Sum", "topN", n = 4,
aggregated_col = c("Sequence", "Mass"))
obj.agg <- RunAggregation(subR25pept, "Yes_As_Specific", "Mean", "topN", n = 4,
aggregated_col = c("Sequence", "Mass"))

obj.agg <- RunAggregation(subR25pept, "No", "Sum", "allPeptides")
obj.agg <- RunAggregation(subR25pept, "No", "Sum", "topN", n = 4)

obj.agg <- RunAggregation(subR25pept, "Yes_Simple_Redistribution", "Sum", "allPeptides",
aggregated_col = c("Sequence", "Mass"))
obj.agg <- RunAggregation(subR25pept, "Yes_Iterative_Redistribution", "Sum", "topN", n = 4,
aggregated_col = c("Sequence", "Mass"))

library(QFeatures)

data(subR25pept)
protID <- parentProtId(subR25pept[[1]])
X <- QFeatures::adjacencyMatrix(subR25pept[[1]])

X.split <- DaparToolshed::splitAdjacencyMat(X)
X.shared <- X.split$Xshared
X.unique <- X.split$Xspec
data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
X.topn <- select_topn(SummarizedExperiment::assay(subR25pept[[1]]), X, n = 3)

data(subR25pept)
obj.last <- subR25pept[[1]]
X <- BuildAdjacencyMatrix(subR25pept[[1]])
getProteinsStats(X)


data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
CountPep(X)


library(QFeatures)
data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
GetNbPeptidesUsed(SummarizedExperiment::assay(subR25pept), X)


library(SummarizedExperiment)
data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
ll.n <- GetDetailedNbPeptidesUsed(SummarizedExperiment::assay(subR25pept), X)

data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
n <- GetDetailedNbPeptides(X)

data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
GraphPepProt(X)

data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
ExtractUniquePeptides(X)

data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
qdata.agg <- innerAggregateIter(SummarizedExperiment::assay(subR25pept[[1]]), X)

library(QFeatures)
data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
i.sum <- innerSum(SummarizedExperiment::assay(subR25pept[[1]]), X)


library(QFeatures)
data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
i.mean <- innerMean(SummarizedExperiment::assay(subR25pept), X)



library(QFeatures)
data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
i.mean <- innerMedian(SummarizedExperiment::assay(subR25pept[[1]]), X)



data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
i.mean <- innerMedianpolish(SummarizedExperiment::assay(subR25pept[[1]]), X)



data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
i.mean <- innerRobustsummary(SummarizedExperiment::assay(subR25pept[[1]]), X)

Description

This function aggregates the quantitative features of an assay, applying a summarization function (fun) to sets of features. The fcol variable name points to a rowData column that defines how to group the features during aggregate. This variable has to be an adjacency matrix. This function uses DaparToolshed::innerAggregateIter() to aggregate quantitative data.

The list of agregation methods can be obtained with the function aggregateMethods(). This function compiles both methods from the packages DaparToolshed and QFeatures.

Usage

aggregateRedistribution(object, ...)

## S4 method for signature 'QFeatures'
aggregateRedistribution(
  object,
  i,
  name = "newAssay",
  fcol,
  init.method = "Mean",
  method = "Mean",
  ponderation = "Global",
  n = NULL,
  uniqueiter = FALSE,
  max_iter = 500
)

## S4 method for signature 'SummarizedExperiment'
aggregateRedistribution(
  object,
  fcol,
  init.method = "Mean",
  method = "Mean",
  ponderation = "Global",
  n = NULL,
  uniqueiter = FALSE,
  conds,
  max_iter = 500
)

Arguments

Details

This function uses DaparToolshed::innerAggregateIter() to aggregate quantitative data.

Value

A QFeatures object with an additional assay or a SummarizedExperiment object (or subclass thereof).

Iterative aggregation function

NA

Quantitative metadata aggregation

The function to aggregate the quantitative metadata is aggQmetadat()

See Also

The QFeatures vignette provides an extended example and the Aggregation vignette, for a complete quantitative proteomics data processing pipeline.

Examples

NULL

Description

This function is a wrapper to the function adjust.p from the cp4p package. It returns the adjusted p-values corresponding to the p-values of the differential analysis. The adjusted p-values is computed with the function p.adjust{stats}.

Usage

diffAnaComputeAdjustedPValues(pval, pi0Method = 1)

Arguments

Value

The computed adjusted p-values

Author(s)

Samuel Wieczorek

Examples

data(subR25prot)
obj <- subR25prot
# Simulate imputation
obj <- NAIsZero(obj, 1)
allComp <- limmaCompleteTest(
SummarizedExperiment::assay(obj[[length(obj)]]), design_qf(obj), 
comp.type="OnevsOne")
diffAnaComputeAdjustedPValues(pval = allComp$P_Value[, 1])

Description

This function returns the FDR corresponding to the p-values of the differential analysis.

Usage

diffAnaComputeFDR(adj.pvals)

Arguments

Value

The computed FDR value (floating number)

Author(s)

Samuel Wieczorek

Examples

NULL

Description

#' Plots an interactive volcanoplot after the differential analysis. Typically, the log of Fold Change is represented on the X-axis and the log10 of the p-value is drawn on the Y-axis. When the th_pval and the th_logfc are set, two lines are drawn respectively on the y-axis and the X-axis to visually distinguish between differential and non differential data. With the use of the package plotly, a customizable tooltip appears when the user put the mouse's pointer over a point of the scatter plot.

Usage

diffAnaVolcanoplot_rCharts(
  df,
  th_pval = 1e-60,
  th_logfc = 0,
  conditions = NULL,
  pal = NULL
)

Arguments

Value

An interactive volcanoplot

Author(s)

Samuel Wieczorek

Examples

data(subR25prot)
obj <- subR25prot
# Simulate imputation
obj <- NAIsZero(obj, 1)
allComp <- limmaCompleteTest(
SummarizedExperiment::assay(obj[[length(obj)]]), 
design_qf(obj), 
comp.type="OnevsOne")
df <- data.frame(
x = allComp$logFC[[1]],
y = -log10(allComp$P_Value[[1]]),
index = as.character(rownames(obj[[1]]))
)
tooltipSlot <- c("Fasta_headers", "Sequence_length")
df <- cbind(df, SummarizedExperiment::rowData(obj[[1]])[, tooltipSlot])
colnames(df) <- gsub(".", "_", colnames(df), fixed = TRUE)
if (ncol(df) > 3) {
  colnames(df)[4:ncol(df)] <- paste0("tooltip_", 
                                     colnames(df)[4:ncol(df)])
}
cond <- c("25fmol", "10fmol")
diffAnaVolcanoplot_rCharts(
  df,
  th_pval = 2.5,
  th_logfc = 1,
  conditions = cond
)

Description

Display a CC

Usage

displayCCvisNet(g)

Arguments

Value

A plot

Author(s)

Thomas Burger, Samuel Wieczorek

Examples

data(subR25pept)
X <- QFeatures::adjacencyMatrix(subR25pept[[1]])
ll <- getPepProtCC(X)
g <- buildGraph(ll[[1]], X)
displayCCvisNet(g)

Description

The colors in the returned palette are always in the same order

Usage

ExtendPalette(n = 0, base = "Set1")

Arguments

Value

A vector composed of n color code.

Author(s)

Samuel Wieczorek

Examples

ExtendPalette(12)
nPalette <- 10
par(mfrow = c(nPalette, 1))
par(mar = c(0.5, 4.5, 0.5, 0.5))
for (i in seq_len(nPalette)) {
    pal <- ExtendPalette(n = i, base = "Dark2")
    barplot(seq_len(length(pal)), col = pal)
    print(pal)
}

Description

Extracts the FC and the FWER ajusted p-values and format them in a data.frame

Usage

formatHSDResults(post_hoc_models_summaries)

Arguments

Value

A data.frame()

Author(s)

Thomas Burger

Examples

NULL

Description

Format Limma results

Usage

formatLimmaResult(fit, conds, contrast, design.level)

Arguments

Value

A list of two dataframes : logFC and P_Value. The first one contains the logFC values of all the comparisons (one column for one comparison), the second one contains the pvalue of all the comparisons (one column for one comparison). The names of the columns for those two dataframes are identical and correspond to the description of the comparison.

Author(s)

Samuel Wieczorek

Examples

library(SummarizedExperiment)
data(subR25prot)
level <- 'protein'
metacell.mask <- matchMetacell(qMetacell(subR25prot[[1]]), 
c("Missing POV", "Missing MEC"), level)
# Simulate imputation
assay(subR25prot[[1]])[which(is.na(assay(subR25prot[[1]])))] <- 0
qData <- as.matrix(SummarizedExperiment::assay(subR25prot[[1]]))
sTab <- SummarizedExperiment::colData(subR25prot)
limma <- limmaCompleteTest(qData, sTab)

Description

Extract logFC and raw pvalues from multiple post-hoc models summaries

Usage

formatPHResults(post_hoc_models_summaries)

Arguments

Value

a list of 2 dataframes containing the logFC values and pvalues for each comparison.

Author(s)

Helene Borges

Examples

library(SummarizedExperiment)
data(subR25prot)
obj <- subR25prot
filter <- FunctionFilter('qMetacellOnConditions',
  cmd = 'delete',
  mode = 'AtLeastOneCond',
  pattern = c("Missing POV", "Missing MEC"),
  conds = design_qf(obj)$Condition,
  percent = TRUE,
  th = 0.8,
  operator = '>')
obj <- filterFeaturesOneSE(obj, name = "Filtered", filters = list(filter))
qdata <- SummarizedExperiment::assay(obj[[2]])
conds <- design_qf(obj)$Condition
anova_tests <- apply(qdata, 1, classic1wayAnova, conditions = as.factor(conds))
anova_tests <- t(anova_tests)

names(anova_tests) <- rownames(qdata)
tms <- lapply(
  anova_tests,
  function(x) {
    summary(multcomp::glht(x,
      linfct = multcomp::mcp(conditions = "Tukey")
    ),
      test = multcomp::adjusted("none")
    )
   }
)
res <- formatPHResults(tms)

Description

Extracts the FC and the raw p-values and format them in a data.frame

Usage

formatPHTResults(post_hoc_models_summaries)

Arguments

Value

A data.frame()

Author(s)

Thomas Burger

Examples

NULL

Description

#' fudge2LRT: heuristic to choose the value of the hyperparameter (fudge factor) used to regularize the variance estimator in the likelihood ratio statistic (as implemented in samLRT). We follow the heuristic described in [1] and adapt the code of the fudge2 function in the siggene R package. [1] Tusher, Tibshirani and Chu, Significance analysis of microarrays applied to the ionizing radiation response, PNAS 2001 98: 5116-5121, (Apr 24).

Usage

fudge2LRT(
  lmm.res.h0,
  lmm.res.h1,
  cc,
  n,
  p,
  s,
  alpha = seq(0, 1, 0.05),
  include.zero = TRUE
)

Arguments

Value

(same as the fudge2 function of siggene):

• s.zero: the value of the fudge factor s0.

• alpha.hat: the optimal quantile of the 's' values. If s0=0, 'alpha.hat' will not be returned.

• vec.cv: the vector of the coefficients of variations. Following Tusher et al. (2001), the optimal 'alpha' quantile is given by the quantile that leads to the smallest CV of the modified test statistics.

• msg: a character string summarizing the most important information about the fudge factor.

Author(s)

Thomas Burger, Laurent Jacob

Examples

NULL

Description

Builds a complete color palette for the conditions given in argument

Usage

GetColorsForConditions(conds, pal = NULL)

Arguments

Value

NA

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
GetColorsForConditions(design_qf(subR25pept)$Condition)
GetColorsForConditions(design_qf(subR25pept)$Condition, ExtendPalette(2))

Description

Get design level

Usage

getDesignLevel(sTab)

Arguments

Value

An integer

Examples

data(subR25pept)
sTab <- SummarizedExperiment::colData(subR25pept)
getDesignLevel(sTab)

Description

Wrapper for the paramshistory function.

Usage

GetHistory(obj.se, history)

Arguments

Value

A data.frame()

Author(s)

Samuel Wieczorek

Examples

data(subR25prot)
GetHistory(subR25prot[[1]])

Description

This function looks for the lines that respect the request in either all conditions or at least one condition.

Usage

GetIndices_BasedOnConditions(metacell.mask, type, conds, percent, op, th)

Arguments

Value

A vector of integer()

Examples

data(subR25pept)
level <- typeDataset(subR25pept[[1]])
pattern <- 'Missing'
metacell.mask <- matchMetacell(
metadata=qMetacell(subR25pept[[1]]), pattern=pattern, level=level)
type <- 'AllCond'
conds <- design_qf(subR25pept)$Condition
op <- '>='
th <- 0.5
percent <- TRUE
ind <- GetIndices_BasedOnConditions(metacell.mask, type, conds, percent, op, th)

Description

Delete the lines in the matrix of intensities and the metadata table given their indices.

Usage

GetIndices_FunFiltering(
  obj,
  conds,
  level,
  pattern = NULL,
  type = NULL,
  percent,
  op,
  th
)

Arguments

Value

An instance of class SummarizedExperiment that have been filtered.

Author(s)

Samuel Wieczorek

Examples

NA

Description

This function looks for the lines where each element respect the query.

Usage

GetIndices_WholeLine(metacell.mask)

Arguments

Value

A vector of integer()

Examples

data(subR25pept)
level <- 'peptide'
pattern <- "Missing POV"
metacell.mask <- matchMetacell(metadata = qMetacell(subR25pept[[1]]), 
pattern = pattern, level = level)
ind <- GetIndices_WholeLine(metacell.mask)

Description

This function looks for the lines that respect the request in either all conditions or at least one condition.

Usage

GetIndices_WholeMatrix(metacell.mask, op = "==", percent = FALSE, th = 0)

Arguments

Value

A vector of integer()

Examples

data(subR25pept)
level <- 'peptide'
pattern <- "Missing"
metacell.mask <- matchMetacell(
metadata = qMetacell(subR25pept[[1]]), pattern = pattern, level = level)
percent <- FALSE
th <- 3
op <- ">="
ind <- GetIndices_WholeMatrix(metacell.mask, op, percent, th)

Description

Returns the possible number of values in lines in the data

Usage

getListNbValuesInLines(object, conds, type = "WholeMatrix")

Arguments

Value

An integer

Author(s)

Samuel Wieczorek, Enora Fremy

Examples

data(subR25prot)
res <- getListNbValuesInLines(subR25prot[[1]])

Description

Number of each metacell tags

Usage

GetNbTags(obj)

Arguments

Value

An integer

Examples

library(DaparToolshed)
data(subR25pept, package = 'DaparToolshed')
GetNbTags(subR25pept[[1]])

Description

Returns the number of empty lines in a matrix.

Usage

getNumberOfEmptyLines(qData)

Arguments

Value

An integer

Author(s)

Samuel Wieczorek

Examples

library(QFeatures)
data(subR25prot)
qData <- SummarizedExperiment::assay(subR25prot[[1]])
getNumberOfEmptyLines(qData)

Description

Build the list of connex composant of the adjacency matrix

Usage

getPepProtCC(X)

Arguments

Value

A list of CC

Author(s)

Thomas Burger, Samuel Wieczorek

Examples

data(subR25pept)
X <- QFeatures::adjacencyMatrix(subR25pept[[1]])
ll <- getPepProtCC(X)

Description

The set of available softwares to convert from

Usage

GetSoftAvailables()

Value

A vecotr of charatcer

Examples

GetSoftAvailables()

Description

Computes the adjusted p-values on all the stacked contrasts using CP4P

Usage

globalAdjPval(x, pval.threshold = 1.05, method = 1, display = TRUE)

Arguments

Value

a proteins x contrasts table of adjusted p-values

Author(s)

Thomas Burger

Examples

data(subR25prot)
obj <- subR25prot[seq_len(5),]
globalAdjPval(testAnovaModels(
applyAnovasOnProteins(obj, 1), "TukeyHSD")$P_Value)

Description

This function show the density plots of Fold Change (the same as calculated by limma) for a list of the comparisons of conditions in a differential analysis.

Usage

hc_logFC_DensityPlot(df_logFC, th_logFC = 0, pal = NULL)

Arguments

Value

A plotly density plot

Author(s)

Samuel Wieczorek

Examples

library(SummarizedExperiment)
data(subR25pept)
# Simulate missing value imputation
SummarizedExperiment::assay(subR25pept[[1]])[which(is.na(assay(subR25pept[[1]])))] <- 0

qData <- as.matrix(SummarizedExperiment::assay(subR25pept[[1]]))
sTab <- SummarizedExperiment::colData(subR25pept)
limma <- limmaCompleteTest(qData, sTab)
pal <- ExtendPalette(2, "Dark2")
hc_logFC_DensityPlot(limma$logFC, th_logFC = 1, pal = pal)

Description

Display a heatmap for data with missing values

Usage

heatmapForMissingValues(
  x,
  col = NULL,
  srtCol = NULL,
  labCol = NULL,
  labRow = NULL,
  key = TRUE,
  key.title = NULL,
  main = NULL,
  ylab = NULL
)

Arguments

Value

A heatmap

Description

Plots a histogram of p-values

Usage

histPValue_HC(pval_ll, bins = 80, pi0 = 1)

Arguments

Value

A histogram of the p-values with pi0

Author(s)

Samuel Wieczorek

Examples

data(subR25prot)
obj <- subR25prot
# Simulate imputation
obj <- NAIsZero(obj, 1)
allComp <- limmaCompleteTest(
SummarizedExperiment::assay(obj[[length(obj)]]), 
design_qf(obj), 
comp.type="OnevsOne")
histPValue_HC(allComp$P_Value[1])

Description

This method is a variation to the function impute.pa() from the package imp4p.

Usage

imputePA2(
  tab,
  conditions,
  q.min = 0,
  q.norm = 3,
  eps = 0,
  distribution = "unif"
)

Arguments

Value

The object obj which has been imputed

Author(s)

Thomas Burger, Samuel Wieczorek

Examples

library(QFeatures)
utils::data(subR25pept)
qdata <- SummarizedExperiment::assay(subR25pept[[1]])
conds <- design_qf(subR25pept)$Condition
obj.imp <- imputePA2(qdata, conds, distribution = "beta")

Description

This function initializes the history.

Usage

InitializeHistory()

Value

An empty data.frame with 4 columns ('Process', 'Step', 'Parameter' and 'Value')

Examples

InitializeHistory()

Description

This function allows to identify differentially abundant peptide/protein

Usage

isDifferential(pvalue, logFC, thpvalue, thlogFC)

Arguments

Value

A vector indicating which peptide/protein is differentially abundant (1) or not (0).

Author(s)

Manon Gaudin

Examples

data(subR25prot)
obj <- subR25prot
# Simulate imputation
obj <- NAIsZero(obj, 1)
allComp <- limmaCompleteTest(
SummarizedExperiment::assay(obj[[length(obj)]]), 
design_qf(obj), 
comp.type="OnevsOne")
isDifferential(allComp$P_Value[, 1], allComp$logFC[, 1], 0.05, 0.5)

Description

Similar to the function is.na() but focused on the equality with the paramter 'type'.

Usage

isOfType(data, type)

Arguments

Value

A boolean dataframe

Author(s)

Samuel Wieczorek

Examples

library(QFeatures)
data(subR25prot)
obj <- subR25prot[[1]]
data <- qMetacell(obj)
isOfType(as.data.frame(data), "MEC")

Description

Check is a given set is a subset of another one.

Usage

isSubset(set1, set2)

Arguments

Value

A boolean

Examples

isSubset('a', letters)
isSubset(c('a', 'c', 't'), letters)
isSubset(c('a', 3, 't'), letters)
isSubset(3, letters)

Description

Removes one or more items from the dataset. This function is specific of the type of dataset.

Usage

Keep_Items_from_Dataset(dataset, range)

Arguments

Value

The dataset minus some items

Description

Compute the likelihood of the null hypothesis for the global model

Usage

LH0(X, y1, y2)

Arguments

Value

A list of likelihoods

Author(s)

Thomas Burger, Laurent Jacob

Examples

NULL

Description

Compute the likelihoods of the null hypothesis for the "local" component-wise model

Usage

LH0_lm(X, y1, y2)

Arguments

Value

A list of likelihoods with associated linear models

Author(s)

Thomas Burger, Laurent Jacob

Examples

NULL

Description

Compute the likelihood of the alternative hypothesis for the global model

Usage

LH1(X, y1, y2, j)

Arguments

Value

A list of likelihoods

Author(s)

Thomas Burger, Laurent Jacob

Examples

NULL

Description

Compute the likelihoods of the alternative hypothesis for the "local" component-wise model

Usage

LH1_lm(X, y1, y2, j)

Arguments

Value

A list of likelihoods with associated linear models

Author(s)

Thomas Burger, Laurent Jacob

Examples

NULL

Description

Computes a hierarchical differential analysis

Usage

limmaCompleteTest(qData, sTab, comp.type = "OnevsOne")

Arguments

Value

A list of two dataframes : logFC and P_Value. The first one contains the logFC values of all the comparisons (one column for one comparison), the second one contains the pvalue of all the comparisons (one column for one comparison). The names of the columns for those two dataframes are identical and correspond to the description of the comparison.

Author(s)

Hélène Borges, Thomas Burger, Quentin Giai-Gianetto, Samuel Wieczorek

Examples

data(subR25pept)
qData <- as.matrix(SummarizedExperiment::assay(subR25pept[[1]]))
sTab <- SummarizedExperiment::colData(subR25pept)
limma <- limmaCompleteTest(qData, sTab, comp.type = "anova1way")

Description

Builds the contrast matrix

Usage

makeContrast(design, condition, contrast = 1, design.level = 1)

Arguments

Value

A contrast matrix

Author(s)

Thomas Burger, Quentin Giai-Gianetto, Samuel Wieczorek

Examples

data(subR25pept)
design <- makeDesign(SummarizedExperiment::colData(subR25pept))
conds <- design_qf(subR25pept)$Condition
makeContrast(design, conds)

Description

Builds the design matrix

Usage

makeDesign(sTab)

Arguments

Value

A design matrix

Author(s)

Thomas Burger, Quentin Giai-Gianetto, Samuel Wieczorek

Examples

data(subR25pept)
makeDesign(SummarizedExperiment::colData(subR25pept))

Description

Builds the design matrix for designs of level 1

Usage

makeDesign1(sTab)

Arguments

Value

A design matrix

Author(s)

Thomas Burger, Quentin Giai-Gianetto, Samuel Wieczorek

Examples

data(subR25pept)
makeDesign1(SummarizedExperiment::colData(subR25pept))

Description

Builds the design matrix for designs of level 2

Usage

makeDesign2(sTab)

Arguments

Value

A design matrix

Author(s)

Thomas Burger, Quentin Giai-Gianetto, Samuel Wieczorek

Examples

data(subR25pept)
makeDesign2(SummarizedExperiment::colData(subR25pept))

Description

Builds the design matrix for designs of level 3

Usage

makeDesign3(sTab)

Arguments

Value

A design matrix

Author(s)

Thomas Burger, Quentin Giai-Gianetto, Samuel Wieczorek

Examples

data(subR25pept)
sTab <- cbind(SummarizedExperiment::colData(subR25pept), Tech.Rep = seq_len(6))
makeDesign3(sTab)

Description

Similar to the function is.na() but focused on the equality with the paramter 'type'.

Usage

matchMetacell(metadata, pattern = NULL, level)

Arguments

Value

A boolean dataframe

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
metadata <- qMetacell(subR25pept[[1]])
m <- matchMetacell(metadata, pattern = "Missing", level = "peptide")
m <- matchMetacell(metadata, pattern = 'Missing POV', level = "peptide")
m <- matchMetacell(metadata, pattern = c('Missing', 'Missing POV'), level = "peptide")

Description

Actually, this function uses the generic function to generate metacell info

Usage

Metacell_DIA_NN(qdata, conds, df, level = NULL)

Arguments

Value

NA

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
conds <- design_qf(subR25pept)$Condition
qdata <- SummarizedExperiment::assay(subR25pept[[1]])
df <- Metacell_DIA_NN(qdata, conds, df, level = "peptide")

Description

Initial conversion rules for maxquant |————|———————–|——–| | Quanti | Identification | Tag | |————|———————–|——–| | == 0 | whatever | 2.0 | | > 0 | 'By MS/MS' | 1.1 | | > 0 | 'By matching' | 1.2 | | > 0 | unknown col | 1.0 | |————|———————–|——–|

Usage

Metacell_maxquant(qdata, conds, df = NULL, level = NULL)

Arguments

Value

NA

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
conds <- design_qf(subR25pept)$Condition
qdata <- SummarizedExperiment::assay(subR25pept[[1]])
df2 <- Metacell_maxquant(qdata, conds, level = "peptide")

Description

In the quantitative columns, a missing value is identified by no value rather than a value equal to 0.

In these datasets, the metacell info is computed from the 'PSM count' columns.

Conversion rules Initial conversion rules for proline |————–|—————–|—–| | Quanti | PSM count | Tag | |————–|—————–|—–| | == 0 | N.A. | whatever | 2.0 | | > 0 | > 0 | 1.1 | | > 0 | == 0 | 1.2 | | > 0 | unknown col | 1.0 | |————–|—————–|—–|

Usage

Metacell_proline(qdata, conds, df = NULL, level = NULL)

Arguments

Value

NA

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
conds <- design_qf(subR25pept)$Condition
qdata <- SummarizedExperiment::assay(subR25pept[[1]])
df <- Metacell_proline(qdata, conds, level = "peptide")

Description

This method plots a bar plot which represents the distribution of the number of missing values (NA) per lines (ie proteins).

Plots a heatmap of the quantitative data. Each column represent one of the conditions in the object of class obj and the color is proportional to the mean of intensity for each line of the dataset. The lines have been sorted in order to vizualize easily the different number of missing values. A white square is plotted for missing values.

#' Plots a heatmap of the quantitative data. Each column represent one of the conditions in the object of class MsnSet and the color is proportional to the mean of intensity for each line of the dataset. The lines have been sorted in order to vizualize easily the different number of missing values. A white square is plotted for missing values.

This method shows density plots which represents the repartition of Partial Observed Values for each replicate in the dataset. The colors correspond to the different conditions (slot Condition in in the dataset of class MsnSet). The x-axis represent the mean of intensity for one condition and one entity in the dataset (i. e. a protein) whereas the y-axis count the number of observed values for this entity and the considered condition.

Usage

metacellPerLinesHisto_HC(
  obj,
  group,
  pattern = NULL,
  detailed = FALSE,
  indLegend = "auto",
  showValues = FALSE
)

metacellPerLinesHistoPerCondition_HC(
  obj,
  group,
  pattern = NULL,
  indLegend = "auto",
  showValues = FALSE,
  pal = NULL
)

metacellHisto_HC(
  obj,
  group = NULL,
  pattern = NULL,
  indLegend = "auto",
  showValues = FALSE,
  pal = NULL
)

wrapperMVImage(obj, group = NULL, pattern = "Missing MEC")

mvImage(obj, group)

hc_mvTypePlot2(obj, group, pal = NULL, pattern, title = NULL)

Arguments

Value

A bar plot

A heatmap

A heatmap

Density plots

Author(s)

Florence Combes, Samuel Wieczorek

Samuel Wieczorek, Alexia Dorffer

Samuel Wieczorek, Thomas Burger

Samuel Wieczorek

Examples

data(subR25prot)
grp <- design_qf(subR25prot)$Condition
metacellPerLinesHisto_HC(subR25prot[[1]], group = grp, pattern = "Missing POV")
metacellPerLinesHisto_HC(subR25prot[[1]])
metacellPerLinesHisto_HC(subR25prot[[1]], group = grp, pattern = "Quantified")
metacellPerLinesHisto_HC(subR25prot[[1]], group = grp, pattern = "Quant. by direct id")
metacellPerLinesHisto_HC(subR25prot[[1]], group = grp, pattern = "Quant. by recovery")
pattern <- c("Quantified", "Quant. by direct id", "Quant. by recovery")
metacellPerLinesHisto_HC(subR25prot[[1]], group = grp, pattern = pattern)


metacellPerLinesHistoPerCondition_HC(subR25prot[[1]], group = grp, pattern = "Missing POV")
metacellPerLinesHistoPerCondition_HC(subR25prot[[1]])
metacellPerLinesHistoPerCondition_HC(subR25prot[[1]], group = grp, pattern = "Quantified")
metacellPerLinesHistoPerCondition_HC(subR25prot[[1]], group = grp, pattern = "Quant. by direct id")
metacellPerLinesHistoPerCondition_HC(subR25prot[[1]], group = grp, pattern = "Quant. by recovery")
pattern <- c("Quantified", "Quant. by direct id", "Quant. by recovery")
metacellPerLinesHistoPerCondition_HC(subR25prot[[1]], group = grp, pattern = pattern)


metacellHisto_HC(subR25prot[[1]], group = grp, pattern = "Missing POV")
metacellHisto_HC(subR25prot[[1]])
metacellHisto_HC(subR25prot[[1]], group = grp, pattern = "Quantified")
metacellHisto_HC(subR25prot[[1]], group = grp, pattern = "Quant. by direct id")
metacellHisto_HC(subR25prot[[1]], group = grp, pattern = "Quant. by recovery")
pattern <- c("Quantified", "Quant. by direct id", "Quant. by recovery")
metacellHisto_HC(subR25prot[[1]], group = grp, pattern = pattern)



data(subR25pept)
pattern <- "Missing POV"
pal <- ExtendPalette(2, "Dark2")
metacellHisto_HC(subR25pept[[1]], pattern, showValues = TRUE, pal = pal)

data(subR25pept)
mvImage(subR25pept[[1]], design_qf(subR25pept)$Condition)

data(subR25pept)
pal <- ExtendPalette(length(unique(design_qf(subR25pept)$Condition)), "Dark2")
pattern <- "Missing MEC"
hc_mvTypePlot2(subR25pept[[1]], 
group = design_qf(subR25pept)$Condition, 
pattern = pattern, pal = pal)

Description

Lists the metacell scopes for filtering

Usage

MetacellFilteringScope()

Value

A vector of character()

Examples

MetacellFilteringScope()

Description

Methods available are:

• wrapperImputeDetQuant(): This method is a wrapper of the function impute.detQuant() for objects of class MSnSet

• wrapperImputeKNN(): Can impute only POV missing values. This method is a wrapper for objects of class QFeatures and imputes missing values with a fixed value. This function imputes the missing values condition by condition.

• wrapperImputeSLSA(): Imputation of peptides having no values in a biological condition. This method is a wrapper to the function impute.slsa() of the package imp4p adapted to an object of class MSnSet.

• wrapperImputeFixedValue(): This method is a wrapper to objects of class MSnSet and imputes missing values with a fixed value.

• wrapperImputePA(): Imputation of peptides having no values in a biological condition. This method is a wrapper to the function impute.pa of the package imp4p adapted to an object of class MSnSet.

Usage

findMECBlock(obj, grp)

reIntroduceMEC(obj, grp, MECIndex)

wrapperImputeKNN(obj = NULL, grp, K)

wrapperImputeFixedValue(obj, grp, fixVal = 0, na.type)

wrapperImputePA(obj = NULL, grp, q.min = 0.025)

wrapperImputeDetQuant(obj, qval = 0.025, factor = 1, na.type)

getQuantile4Imp(qdata, qval = 0.025, factor = 1)

wrapperImputeSLSA(obj = NULL, design = NULL)

Arguments

Value

A data.frame containing the indexes of LAPALA

A list of two vectors, respectively containing the imputation values and the rescaled imputation values

Utilities functions:

• findMECBlock()

• reIntroduceMEC()

• getQuantile4Imp(): Quantile imputation value definition. This method returns the q-th quantile of each column of an expression set, up to a s calling factor

Author(s)

Samuel Wieczorek

Examples

data(subR25prot)
obj <- subR25prot[[1]]
grp <- design_qf(subR25prot)$Condition
lapala <- findMECBlock(obj, grp)
na.type = c("Missing POV", "Missing MEC")
obj.imp.pov <- wrapperImputeDetQuant(obj, na.type = na.type)
obj.imp.pov <- reIntroduceMEC(obj, grp, lapala)

obj.imp.pov <- wrapperImputeKNN(obj, grp, 3)

obj.imp.pov <- wrapperImputeFixedValue(obj, grp, 0.001, na.type = "Missing POV")
obj.imp.mec <- wrapperImputeFixedValue(obj, grp, 0.001, na.type = "Missing MEC")
obj.imp.na <- wrapperImputeFixedValue(
obj, grp, 0.001, 
na.type = c("Missing MEC", "Missing POV"))

obj.imp.pov <- wrapperImputePA(obj, grp)

qdata <- SummarizedExperiment::assay(obj)
quant <- getQuantile4Imp(qdata)

Description

Set NA values to 0

Usage

NAIsZero(obj, i)

Arguments

Value

An instance of QFeatures class

Description

This function counts the number of empty lines (all elements are equal to NA).

Usage

nEmptyLines(df)

Arguments

Value

A integer(1)

Author(s)

Samuel Wieczorek

Examples

library(QFeatures)
data(subR25prot)
nEmptyLines(SummarizedExperiment::assay(subR25prot, 1))

Description

This function retrieves the indices of non-zero elements in sparse matrices of class dgCMatrix from package Matrix. This function is largely inspired from the package RINGO.

Usage

nonzero(x)

Arguments

Value

A two-column matrix

Author(s)

Samuel Wieczorek

Examples

library(Matrix)
mat <- Matrix(c(0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1),
    nrow = 5, byrow = TRUE, sparse = TRUE)
res <- nonzero(mat)

Description

Provides several methods to normalize quantitative data from a SummarizedExperiment object. They are organized in six main families : GlobalQuantileAlignement, sumByColumns, QuantileCentering, MeanCentering, LOESS, vsn For the first family, there is no type. For the five other families, two type categories are available : "Overall" which means that the value for each protein (ie line in the expression data tab) is computed over all the samples ; "within conditions" which means that the value for each protein (ie line in the SummarizedExperiment::assay() data tab) is computed condition by condition.

Usage

normalizeMethods(target = "all")

GlobalQuantileAlignment(qData)

SumByColumns(qData, conds = NULL, type = NULL, subset.norm = NULL)

QuantileCentering(
  qData,
  conds = NULL,
  type = "overall",
  subset.norm = NULL,
  quantile = 0.15
)

MeanCentering(
  qData,
  conds,
  type = "overall",
  subset.norm = NULL,
  scaling = FALSE
)

vsn(qData, conds, type = NULL)

LOESS(qData, conds, type = "overall", span = 0.7)

Arguments

Value

A vector of character()

A normalized numeric matrix

A normalized numeric matrix

A normalized numeric matrix

A normalized numeric matrix

A normalized numeric matrix

A normalized numeric matrix

Author(s)

Samuel Wieczorek, Thomas Burger, Helene Borges, Anais Courtier, Enora Fremy

Examples

## Get the list of methods
normalizeMethods()


data(subR25pept)
qData <- SummarizedExperiment::assay(subR25pept[[1]])
conds <- design_qf(subR25pept)$Condition



#normalized <- GlobalQuantileAlignment(qData)

normalized <- SumByColumns(qData, conds,
    type = "within conditions",
    subset.norm = seq_len(10)
)

normalized <- QuantileCentering(
SummarizedExperiment::assay(subR25pept), conds,
type = "within conditions", subset.norm = seq_len(10)
)

normalized <- MeanCentering(qData, conds, type = "overall")

normalized <- LOESS(qData, conds, type = "overall")

Description

This method is a wrapper that provides several methods to normalize quantitative data from objects of class QFeatures or SummarizedExperiment.

They are organized in six main families : GlobalQuantileAlignement, sumByColumns, QuantileCentering, MeanCentering, LOESS, vsn For the first family, there is no type. For the five other families, two type categories are available : "Overall" which means that the value for each protein (ie line in the expression data tab) is computed over all the samples ; "within conditions" which means that the value for each protein (ie line in the SummarizedExperiment::assay() data tab) is computed condition by condition. The available methods are described in normalizeMethods().

Usage

normalizeFunction(
  obj,
  method,
  conditions = NULL,
  type = "overall",
  subset.norm = NULL,
  quantile = 0.15,
  scaling = FALSE,
  span = 0.7
)

Arguments

Value

QFeatures including a new assay with normalized data or SummarizedExperiment with normalized data.

Author(s)

Manon Gaudin

Examples

data(subR25pept)
normalized <- normalizeFunction(subR25pept, method = 'GlobalQuantileAlignment')

Description

This function exports a MSnSet data object to a Excel file. Each of the three data.frames in the MSnSet object (ie experimental data, phenoData and metaData are respectively integrated into separate sheets in the Excel file).

The colored cells in the experimental data correspond to the original missing values which have been imputed.

Usage

readExcel(file, sheet = NULL)

listSheets(file)

write_Assay_To_Excel(wb, obj, i, n)

WriteHistory(wb, obj, n)

Write_SamplesData_to_Excel(wb, obj, n)

Write_RowData(wb, obj, i, n)

writeExcel(obj, filename)

Arguments

Value

A Excel file (.xlsx)

Author(s)

Samuel Wieczorek

Examples

library(QFeatures)
data(subR25prot)
df <- SummarizedExperiment::assay(subR25prot[[1]])
tags <- qMetacell(subR25prot[[1]])
colors <- list(
    "Missing POV" = "lightblue",
    "Missing MEC" = "orange",
    "Quant. by recovery" = "lightgrey",
    "Quant. by direct id" = "white",
    "Combined tags" = "red"
)
file <- tempfile('toto.xlsx')
writeExcel(subR25prot, filename = file)
unlink(file)

data(subR25pept)
file <- tempfile('foo.xlsx')
writeExcel(subR25pept, file)
unlink(file)

Description

Applies aov() on a vector of protein abundances using the design derived from the sample names (simple aov wrapper)

Usage

OWAnova(current_protein, conditions)

Arguments

Value

See aov()

Author(s)

Thomas Burger

Examples

protein_abundance <- rep(rnorm(3, mean= 18, sd=2), each=3) + rnorm(9)
groups <- c(rep("group1",3),rep("group2",3),rep("group3",3))
OWAnova(protein_abundance,groups)

Description

This function gives the list of metacell tags available.

• onlyPresent: In this case, the function gives the tags found in a dataset. In addition, and w.r.t to the hierarchy of tags, if all leaves of a node are present, then the tag corresponding to this node is added.

These names are common to all assays contained in the object. This is why they are stored in the global metadata. This function is used whenever it i s necessary to (re)detect MEC and POV (new dataset or when post processing protein qMetacell after aggregation)

Usage

paramshistory(object, ...)

## S4 method for signature 'QFeatures'
paramshistory(object, i, slotName = "paramshistory")

## S4 method for signature 'SummarizedExperiment'
paramshistory(object, slotName = "paramshistory")

paramshistory(object, i, slotName = "paramshistory") <- value

GetMetacellTags(object, ...)

## S4 method for signature 'QFeatures'
GetMetacellTags(object, i, ...)

## S4 method for signature 'SummarizedExperiment'
GetMetacellTags(object, ...)

## S4 method for signature 'data.frame'
GetMetacellTags(object, ...)

qMetacell(object, ...)

## S4 method for signature 'QFeatures'
qMetacell(object, i)

## S4 method for signature 'SummarizedExperiment'
qMetacell(object)

qMetacell(object, i, slotName = "qMetacell") <- value

GetUniqueTags(object, ...)

## S4 method for signature 'QFeatures'
GetUniqueTags(object, i)

## S4 method for signature 'SummarizedExperiment'
GetUniqueTags(object)

GetMetadataSlot(object, slotName = NULL)

GetRowdataSlot(object, slotName = NULL)

ConnectedComp(object, ...)

## S4 method for signature 'QFeatures'
ConnectedComp(object, i, slotName = "ConnectedComp")

## S4 method for signature 'SummarizedExperiment'
ConnectedComp(object, slotName = "ConnectedComp")

ConnectedComp(object, i, slotName = "ConnectedComp") <- value

typeDataset(object, ...)

## S4 method for signature 'QFeatures'
typeDataset(object, i, slotName = "typeDataset")

## S4 method for signature 'SummarizedExperiment'
typeDataset(object, slotName = "typeDataset")

typeDataset(object, i, slotName = "typeDataset") <- value

idcol(object, ...)

## S4 method for signature 'QFeatures'
idcol(object, i, slotName = "idcol")

## S4 method for signature 'SummarizedExperiment'
idcol(object, slotName = "idcol")

idcol(object, i, slotName = "idcol") <- value

parentProtId(object, ...)

## S4 method for signature 'QFeatures'
parentProtId(object, i, slotName = "parentProtId")

## S4 method for signature 'SummarizedExperiment'
parentProtId(object, slotName = "parentProtId")

parentProtId(object, i, slotName = "parentProtId") <- value

filename(object, ...)

## S4 method for signature 'QFeatures'
filename(object, slotName = "filename")

filename(object, slotName = "filename") <- value

analysis(object, ...)

## S4 method for signature 'QFeatures'
analysis(object, i, slotName = "analysis")

## S4 method for signature 'SummarizedExperiment'
analysis(object, slotName = "analysis")

analysis(object, i, slotName = "analysis") <- value

version(object, ...)

## S4 method for signature 'QFeatures'
version(object, slotName = "version")

version(object, slotName = "version") <- value

design_qf(object, ...)

## S4 method for signature 'QFeatures'
design_qf(object, slotName = "design")

design_qf(object, slotName = "design") <- value

mainAssay(object)

HypothesisTest(object, ...)

## S4 method for signature 'QFeatures'
HypothesisTest(object, i, slotName = "HypothesisTest")

## S4 method for signature 'SummarizedExperiment'
HypothesisTest(object, slotName = "HypothesisTest")

HypothesisTest(object, i) <- value

DifferentialAnalysis(object, ...)

## S4 method for signature 'QFeatures'
DifferentialAnalysis(object, i, slotName = "DifferentialAnalysis")

## S4 method for signature 'SummarizedExperiment'
DifferentialAnalysis(object, slotName = "DifferentialAnalysis")

DifferentialAnalysis(object, i) <- value

names_metacell(object, ...)

## S4 method for signature 'QFeatures'
names_metacell(object, i, slotName = "names_metacell")

## S4 method for signature 'SummarizedExperiment'
names_metacell(object, slotName = "names_metacell")

names_metacell(object, i, slotName = "names_metacell") <- value

Arguments

Details

Additional slots for Metadata for a SummarizedExperiment object:

• qMetacell: A data.frame()

• parentProtId: A character()

• idcol: A character()

• typeDataset: A character()

Value

A vector of tags.

NA

NA

NA

NA

NA

NA

NA

NA

Quantitative metadata

Default slotName is "qMetacell". The value is an adjacency matrix with row and column names. The matrix will be coerced to compressed, column-oriented sparse matrix (class dgCMatrix) as defined in the Matrix package, as generaled by the Matrix::sparseMatrix() constructor.

Author(s)

Samuel Wieczorek

Examples

data(subR25pept)
GetMetacellTags(subR25pept, 1, level="peptide")
GetMetacellTags(subR25pept, 1, level="peptide", onlyPresent=TRUE)

data(subR25pept)
design_qf(subR25pept)

Description

Parent name of a node

Usage

Parent(level, node = NULL)

Arguments

Value

NA

Description

PEptide based Protein differential Abundance test

Usage

pepaTest(X, y, n1, n2, global = FALSE, use.lm = FALSE)

Arguments

Value

A list of the following elements: llr: log likelihood ratio statistic (maximum likelihood version). llr.map: log likelihood ratio statistic (maximum a posteriori version). llr.pv: p-value for llr. llr.map.pv: p-value for llr.map. mse.h0: Mean squared error under H0 mse.h1: Mean squared error under H1 s: selected regularization hyperparameter for llr.map. wchi2: weight used to make llr.map chi2-distributed under H0.

Author(s)

Thomas Burger, Laurent Jacob

Examples

NA

Description

Get the list of pipelines available in the package

Usage

Pipelines()

Value

NA

Description

Checks if a package is available to load it

Usage

pkgsRequire(ll.deps)

Arguments

Value

NA

Author(s)

Samuel Wieczorek

Examples

NULL

Description

This plot compares the quantitative proteomics data between two assays. It can be used for example to compare the effect of the normalization process.

The comparison is made with the division operator.

Usage

plotCompareAssays(
  obj,
  i,
  j,
  info = NULL,
  pal.name = "Set1",
  subset.view = NULL,
  n = 100,
  type = "scatter"
)

Arguments

Value

A plot

Author(s)

Samuel Wieczorek, Enora Fremy

Examples

data(subR25prot)
obj <- subR25prot
obj <- normalizeFunction(obj, method = "MeanCentering")
plotCompareAssays(obj, 1, 2, n = 5)

Description

Jitter plot of CC

Usage

plotJitter(list.of.cc = NULL)

Arguments

Value

A plot

Author(s)

Thomas Burger

Examples

data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
ll <- getPepProtCC(X)
plotJitter(ll)

Description

Display a a jitter plot for CC

Usage

plotJitter_rCharts(df)

Arguments

Value

A plot

Author(s)

Thomas Burger, Samuel Wieczorek

Examples

data(subR25pept)
X <- BuildAdjacencyMatrix(subR25pept[[1]])
ll <- getPepProtCC(X)[seq_len(4)]
n.prot <- unlist(lapply(ll, function(x) {length(x$proteins)}))
n.pept <- unlist(lapply(ll, function(x) {length(x$peptides)}))
df <- tibble::tibble(
x = jitter(n.pept),
y = jitter(n.prot),
index = seq_len(length(ll))
)
plotJitter_rCharts(df)