Package 'flowCore'

Description

Provides S4 data structures and basic infrastructure and functions to deal with flow cytometry data.

Details

Define important flow cytometry data classes: flowFrame, flowSet and their accessors.

Provide important transformation, filter, gating, workflow, and summary functions for flow cytometry data analysis.

Most of flow cytometry related Bioconductor packages (such as flowStats, flowFP, flowQ, flowViz, flowMerge, flowClust) are heavily dependent on this package.

Author(s)

Maintainer: Florian Hahne <[email protected]>

Authors: B. Ellis, P. Haaland, F. Hahne, N. Le Meur, N. Gopalakrishnan

Description

Create the definition of the arcsinh Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x<-asinh(a+b*x)+c). The transformation would normally be used to convert to a linear valued parameter to the natural logarithm scale. By default a and b are both equal to 1 and c to 0.

Usage

arcsinhTransform(transformationId="defaultArcsinhTransform", a=1, b=1, c=0)

Arguments

Value

Returns an object of class transform.

Author(s)

B. Ellis

See Also

transform-class, transform, asinh

Other Transform functions: biexponentialTransform(), inverseLogicleTransform(), linearTransform(), lnTransform(), logTransform(), logicleTransform(), quadraticTransform(), scaleTransform(), splitScaleTransform(), truncateTransform()

Examples

samp <- read.FCS(system.file("extdata",
   "0877408774.B08", package="flowCore"))
  asinhTrans <- arcsinhTransform(transformationId="ln-transformation", a=1, b=1, c=1)
  translist <- transformList('FSC-H', asinhTrans) 
  dataTransform <- transform(samp, translist)

Description

Inverse hyperbolic sine transform class, which represents a transformation defined by the function:

$f(parameter,a,b)=sinh^{-1}(a*parameter)*b$

This definition is such that it can function as an inverse of sinht using the same definitions of the constants a and b.

Slots

.Data

Object of class "function".

a

Object of class "numeric" – non-zero constant.

b

Object of class "numeric" – non-zero constant.

parameters

Object of class "transformation" – flow parameter to be transformed

transformationId

Object of class "character" – unique ID to reference the transformation.

Objects from the Class

Objects can be created by calls to the constructor asinht(parameter,a,b,transformationId)

Extends

Class "singleParameterTransform", directly.

Class "transform", by class "singleParameterTransform", distance 2.

Class "transformation", by class "singleParameterTransform", distance 3.

Class "characterOrTransformation", by class "singleParameterTransform", distance 4.

Note

The inverse hyperbolic sin transformation object can be evaluated using the eval method by passing the data frame as an argument.The transformed parameters are returned as a matrix with a single column. (See example below)

Author(s)

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry V 1.5

See Also

sinht

Other mathematical transform classes: EHtrans-class, asinhtGml2-class, dg1polynomial-class, exponential-class, hyperlog-class, hyperlogtGml2-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",  package="flowCore"))
  asinh1<-asinht(parameters="FSC-H",a=2,b=1,transformationId="asinH1")
  transOut<-eval(asinh1)(exprs(dat))

Description

Inverse hyperbolic sin transformation as parameterized in Gating-ML 2.0.

Details

asinhtGml2 is defined by the following function:

$bound(f, boundMin, boundMax) = max(min(f,boundMax),boundMin))$

where

$f(parameter, T, M, A) = (asinh(parameter * sinh(M * ln(10)) / T) +A * ln(10)) / ((M + A) * ln(10))$

This transformation is equivalent to Logicle(T, 0, M, A) (i.e., with W=0). It provides an inverse hyperbolic sine transformation that maps a data value onto the interval [0,1] such that:

• The top of scale value (i.e., T ) is mapped to 1.

• Large data values are mapped to locations similar to an (M + A)-decade logarithmic scale.

• A decades of negative data are brought on scale.

In addition, if a boundary is defined by the boundMin and/or boundMax parameters, then the result of this transformation is restricted to the [boundMin,boundMax] interval. Specifically, should the result of the f function be less than boundMin, then let the result of this transformation be boundMin. Analogically, should the result of the f function be more than boundMax, then let the result of this transformation be boundMax. The boundMin parameter shall not be greater than the boundMax parameter.

Slots

.Data

Object of class function.

T

Object of class numeric – positive constant (top of scale value).

M

Object of class numeric – positive constant (desired number of decades).

A

Object of class numeric – non-negative constant that is less than or equal to M (desired number of additional negative decades).

parameters

Object of class "transformation" – flow parameter to be transformed.

transformationId

Object of class "character" – unique ID to reference the transformation.

boundMin

Object of class numeric – lower bound of the transformation, default -Inf.

boundMax

Object of class numeric – upper bound of the transformation, default Inf.

Objects from the Class

Objects can be created by calls to the constructor

asinhtGml2(parameter, T, M, A, transformationId, boundMin, boundMax)

Extends

Class singleParameterTransform, directly.

Class transform, by class singleParameterTransform, distance 2.

Class transformation, by class singleParameterTransform, distance 3.

Class characterOrTransformation, by class singleParameterTransform, distance 4.

Note

The inverse hyperbolic sin transformation object can be evaluated using the eval method by passing the data frame as an argument. The transformed parameters are returned as a matrix with a single column. (See example below)

Author(s)

Spidlen, J.

References

Gating-ML 2.0: International Society for Advancement of Cytometry (ISAC) standard for representing gating descriptions in flow cytometry. http://flowcyt.sourceforge.net/gating/20141009.pdf

See Also

asinht, transform-class, transform

Other mathematical transform classes: EHtrans-class, asinht-class, dg1polynomial-class, exponential-class, hyperlog-class, hyperlogtGml2-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

myDataIn <- read.FCS(system.file("extdata", "0877408774.B08", 
    package="flowCore"))
myASinH1 <- asinhtGml2(parameters = "FSC-H", T = 1000, M = 4.5, 
    A = 0, transformationId="myASinH1")
transOut <- eval(myASinH1)(exprs(myDataIn))

Description

The 'biexponential' is an over-parameterized inverse of the hyperbolic sine. The function to be inverted takes the form biexp(x) = a*exp(b*(x-w))-c*exp(-d*(x-w))+f with default parameters selected to correspond to the hyperbolic sine.

Usage

biexponentialTransform(transformationId="defaultBiexponentialTransform", 
                       a = 0.5, b = 1, c = 0.5, d = 1, f = 0, w = 0, 
                       tol = .Machine$double.eps^0.25, maxit = as.integer(5000))

Arguments

Value

Returns values giving the inverse of the biexponential within a certain tolerance. This function should be used with care as numerical inversion routines often have problems with the inversion process due to the large range of values that are essentially 0. Do not be surprised if you end up with population splitting about w and other odd artifacts.

Author(s)

B. Ellis, N Gopalakrishnan

See Also

transform

Other Transform functions: arcsinhTransform(), inverseLogicleTransform(), linearTransform(), lnTransform(), logTransform(), logicleTransform(), quadraticTransform(), scaleTransform(), splitScaleTransform(), truncateTransform()

Examples

# Construct some "flow-like" data which tends to be hetereoscedastic.
data(GvHD)
biexp  <- biexponentialTransform("myTransform")

after.1 <- transform(GvHD, transformList('FSC-H', biexp))

biexp  <- biexponentialTransform("myTransform",w=10)
after.2 <- transform(GvHD, transformList('FSC-H', biexp))

opar = par(mfcol=c(3, 1))
plot(density(exprs(GvHD[[1]])[, 1]), main="Original")
plot(density(exprs(after.1[[1]])[, 1]), main="Standard Transform")
plot(density(exprs(after.2[[1]])[, 1]), main="Shifted Zero Point")

Description

Class and constructor for data-driven filter objects that discard margin events.

Usage

boundaryFilter(x, tolerance=.Machine$double.eps, side=c("both", "lower",
"upper"), filterId="defaultBoundaryFilter")

Arguments

Details

Flow cytomtery instruments usually operate on a given data range, and the limits of this range are stored as keywords in the FSC files. Depending on the amplification settings and the dynamic range of the measured signal, values can occur that are outside of the measurement range, and most instruments will simply pile those values at the minimum or maximum range limit. The boundaryFilter removes these values, either for a single parameter, or for a combination of parameters. Note that it is often desirable to treat boundary events on a per-parameter basis, since their values might be uninformative for one particular channel, but still be useful in all of the other channels.

The constructor boundaryFilter is a convenience function for object instantiation. Evaluating a boundaryFilter results in a single sub-populations, an hence in an object of class filterResult.

Value

Returns a boundaryFilter object for use in filtering flowFrames or other flow cytometry objects.

Slots

tolerance

Object of class "numeric". The machine tolerance used to decide whether an event is on the measurement boundary. Essentially, this is done by evaluating x>minRange+tolerance & x<maxRange-tolerance.

side

Object of class "character". The margin on which to evaluate the filter. Either upper for the upper margin or lower for the lower margin or both for both margins.

Extends

Class "parameterFilter", directly.

Class "concreteFilter", by class parameterFilter, distance 2.

Class "filter", by class parameterFilter, distance 3.

Objects from the Class

Objects can be created by calls of the form new("boundaryFilter", ...) or using the constructor boundaryFilter. Using the constructor is the recommended way.

Methods

%in%

signature(x = "flowFrame", table = "boundaryFilter"): The workhorse used to evaluate the filter on data. This is usually not called directly by the user, but internally by calls to the filter methods.

show

signature(object = "boundaryFilter"): Print information about the filter.

Author(s)

Florian Hahne

See Also

flowFrame, flowSet, filter for evaluation of boundaryFilters and Subset for subsetting of flow cytometry data sets based on that.

Examples

## Loading example data
dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))

## Create directly. Most likely from a command line
boundaryFilter("FSC-H", filterId="myBoundaryFilter")

## To facilitate programmatic construction we also have the following
bf <- boundaryFilter(filterId="myBoundaryFilter", x=c("FSC-H"))

## Filtering using boundaryFilter
fres <- filter(dat, bf)
fres
summary(fres)

## We can subset the data with the result from the filtering operation.
Subset(dat, fres)

## A boundaryFilter on the lower margins of several channels
bf2 <- boundaryFilter(x=c("FSC-H", "SSC-H"), side="lower")

Description

A simple union class of character and numeric. Objects will be created internally whenever necessary and the user should not need to explicitly interact with this class.

Objects from the Class

A virtual Class: No objects may be created from it.

Examples

showClass("characterOrNumeric")

Description

A simple union class of character and parameters. Objects will be created internally whenever necessary and the user should not need to explicitly interact with this class.

Objects from the Class

A virtual Class: No objects may be created from it.

Examples

showClass("characterOrParameters")

Description

A simple union class of character and transformation. Objects will be created internally whenever necessary and the user should not need to explicitly interact with this class.

Objects from the Class

A virtual Class: No objects may be created from it.

Examples

showClass("characterOrTransformation")

Description

Fix the offset when its values recorded in header and TEXT don't agree

Usage

checkOffset(offsets, x, ignore.text.offset = FALSE, ...)

Arguments

Value

the updated offsets

Description

These functions manage the relations that allow coercing an object to a given class.

Arguments

Details

The function supplied as the third argument is to be called to implement as(x, to) when x has class from. Need we add that the function should return a suitable object with class to.

Author(s)

F. Hahne, B. Ellis

Examples

samp1 <- read.FCS(system.file("extdata","0877408774.E07", package="flowCore"))
 samp2 <- read.FCS(system.file("extdata","0877408774.B08",package="flowCore"))
 samples <-list("sample1"=samp1,"sample2"=samp2)
 experiment <- as(samples,"flowSet")

Description

Coerce the list of the keywords into a character Also flatten spillover matrix into a string

Usage

collapse_desc(d, collapse.spill = TRUE)

Arguments

Value

a list of strings

Examples

data(GvHD)
fr <- GvHD[[1]]
collapse_desc(keyword(fr))

Description

Emission spectral overlap can be corrected by subtracting the amount of spectral overlap from the total detected signals. This compensation process can be described by using spillover matrices.

Details

The compensatedParameter class allows for compensation of specific parameters the user is interested in by creating compensatedParameter objects and evaluating them. This allows for use of compensatedParameter in gate definitions.

Slots

.Data

Object of class "function".

parameters

Object of class "character" – the flow parameters to be compensated.

spillRefId

Object of class "character" – the name of the compensation object (The compensation object contains the spillover Matrix).

searchEnv

Object of class "environment" -environment in which the compensation object is defined.

transformationId

Object of class "character" – a unique Id to reference the compensatedParameter object.

Objects from the Class

Objects can be created by calls to the constructor of the form compensatedParameter(parameters,spillRefId,transformationId,searchEnv).

Extends

Class "transform", directly. Class "transformation", by class "transform", distance 2. Class "characterOrTransformation", by class "transform", distance 3.

Note

The transformation object can be evaluated using the eval method by passing the data frame as an argument. The transformed parameters are returned as a matrix with a single column. (See example below)

Author(s)

Gopalakrishnan N,F.Hahne

See Also

compensation

Examples

samp   <- read.flowSet(path=system.file("extdata", "compdata", "data", package="flowCore"))
cfile <- system.file("extdata","compdata","compmatrix", package="flowCore")
comp.mat <- read.table(cfile, header=TRUE, skip=2, check.names = FALSE)
comp.mat

## create a compensation object 
comp <- compensation(comp.mat,compensationId="comp1")
## create a compensated parameter object 
cPar1<-compensatedParameter(c("FL1-H","FL3-H"),"comp",searchEnv=.GlobalEnv)
compOut<-eval(cPar1)(exprs(samp[[1]]))

Description

Class and methods to compensate for spillover between channels by applying a spillover matrix to a flowSet or a flowFrame assuming a simple linear combination of values.

Usage

compensation(..., spillover, compensationId="defaultCompensation")

compensate(x, spillover, ...)

Arguments

Details

The essential premise of compensation is that some fluorochromes may register signals in detectors that do not correspond to their primary detector (usually a photomultiplier tube). To compensate for this fact, some sort of standard is used to obtain the background signal (no dye) and the amount of signal on secondary channels for each fluorochrome relative to the signal on their primary channel.

To calculate the spillover percentage we use either the mean or the median (more often the latter) of the secondary signal minus the background signal for each dye to obtain n by n matrix, S, of so-called spillover values, expressed as a percentage of the primary channel. The observed values are then considered to be a linear combination of the true fluorescence and the spillover from each other channel so we can obtain the true values by simply multiplying by the inverse of the spillover matrix.

The spillover matrix can be obtained through several means. Some flow cytometers provide a spillover matrix calculated during acquisition, possibly by the operator, that is made available in the metadata of the flowFrame. While there is a theoretical standard keyword $SPILL it can also be found in the SPILLOVER or SPILL keyword depending on the cytometry. More commonly the spillover matrix is calculated using a series of compensation cells or beads collected before the experiment. If you have set of FCS files with one file per fluorochrome as well as an unstained FCS file you can use the spillover method for flowSets to automatically calculate a spillover matrix.

The compensation class is essentially a wrapper around a matrix that allows for transformed parameters and method dispatch.

Value

A compensation object for the constructor.

A flowFrame or flowSet for the compensate methods.

Slots

spillover

Object of class matrix; the spillover matrix.

compensationId

Object of class character. An identifier for the object.

parameters

Object of class parameters. The flow parameters for which the compensation is defined. This can also be objects of class transform, in which case the compensation is performed on the compensated parameters.

Objects from the Class

Objects should be created using the constructor compensation(). See the Usage and Arguments sections for details.

Methods

compensate

signature(x = "flowFrame", spillover = "compensation"): Apply the compensation defined in a compensation object on a flowFrame. This returns a compensated flowFrame.

Usage:

compensate(flowFrame, compensation)

compensate

signature(x = "flowFrame", spillover = "matrix"): Apply a compensation matrix to a flowFrame. This returns a compensated flowFrame.

Usage:

compensate(flowFrame, matrix)

compensate

signature(x = "flowFrame", spillover = "data.frame"):Try to coerce the data.frame to a matrix and apply that to a flowFrame. This returns a compensated flowFrame.

Usage:

compensate(flowFrame, data.frame)

identifier, identifier<-

signature(object = "compensation"): Accessor and replacement methods for the compensationId slot.

Usage:

identifier(compensation)

identifier(compensation) <- value

parameters

signature(object = "compensation"): Get the parameter names of the compensation object. This method also tries to resolve all transforms and transformReferences before returning the parameters as character vectors. Unresolvable references return NA.

Usage:

parameters(compensation)

show

signature(object = "compensation"): Print details about the object.

Usage:

This method is automatically called when the object is printed on the screen.

Author(s)

F.Hahne, B. Ellis, N. Le Meur

See Also

spillover

Examples

## Read sample data and a sample spillover matrix
samp   <- read.flowSet(path=system.file("extdata", "compdata", "data",
          package="flowCore")) 
cfile <- system.file("extdata","compdata","compmatrix", package="flowCore")
comp.mat <- read.table(cfile, header=TRUE, skip=2, check.names = FALSE)
comp.mat

## compensate using the spillover matrix directly
summary(samp)
samp <- compensate(samp, comp.mat)
summary(samp)

## create a compensation object and compensate using that
comp <- compensation(comp.mat)
compensate(samp, comp)

## demo the sample-specific compensation
## create a list of comps (each element could be a 
## different compensation tailored for the specific sample)
comps <- sapply(sampleNames(samp), function(sn)comp, simplify = FALSE)
# the names of comps must be matched to sample names of the flowset
compensate(samp, comps)

Description

This class represents the logical complement of a single filter, which is itself a filter that can be incorporated in to further set operations. complementFilters are constructed using the prefix unary set operator "!" with a single filter operand.

Slots

filters

Object of class "list", containing the component filters.

filterId

Object of class "character" referencing the filter applied.

Extends

Class "filter", directly.

Author(s)

B. Ellis

See Also

filter, setOperationFilter

Other setOperationFilter classes: intersectFilter-class, setOperationFilter-class, subsetFilter-class, unionFilter-class

Description

The concreteFilter serves as a base class for all filters that actually implement a filtering process. At the moment this includes all filters except filterReference, the only non-concrete filter at present.

Slots

filterId

The identifier associated with this class.

Objects from the Class

Objects of this class should never be created directly. It serves only as a point of inheritance.

Extends

Class "filter", directly.

Author(s)

B. Ellis

See Also

parameterFilter

Description

Reverse the application of a compensation matrix on a flowFrame

Usage

## S4 method for signature 'flowFrame,matrix'
decompensate(x, spillover)

## S4 method for signature 'flowFrame,compensation'
decompensate(x, spillover)

Arguments

Value

a decompensated flowFrame

Examples

library(flowCore)
f = list.files(system.file("extdata",
   "compdata",
   "data",
   package="flowCore"),
 full.name=TRUE)[1]
f = read.FCS(f)
spill = read.csv(system.file("extdata",
       "compdata", "compmatrix",
        package="flowCore"), 
        ,sep="\t",skip=2)
colnames(spill) = gsub("\\.","-",colnames(spill))
f.comp = compensate(f,spill)
f.decomp = decompensate(f.comp,as.matrix(spill))
sum(abs(f@exprs-f.decomp@exprs))
all.equal(decompensate(f.comp,spill)@exprs,decompensate(f.comp,as.matrix(spill))@exprs)
all.equal(f@exprs,decompensate(f.comp,spill)@exprs)

Description

dg1polynomial allows for scaling,linear combination and translation within a single transformation defined by the function

$f(parameter_1,...,parameter_n,a_1,...,a_n,b) = b + \Sigma_{i=1}^n a_i*parameter_i$

Slots

.Data

Object of class "function".

parameters

Object of class "parameters" –the flow parameters that are to be transformed.

a

Object of class "numeric" – coefficients of length equal to the number of flow parameters.

b

Object of class "numeric" – coefficient of length 1 that performs the translation.

transformationId

Object of class "character" unique ID to reference the transformation.

Objects from the Class

Objects can be created by using the constructor dg1polynomial(parameter,a,b,transformationId).

Extends

Class "transform", directly.

Class "transformation", by class "transform", distance 2.

Class "characterOrTransformation", by class "transform", distance 3.

Note

The transformation object can be evaluated using the eval method by passing the data frame as an argument.The transformed parameters are returned as a matrix with a single column.(See example below)

Author(s)

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry V 1.5

See Also

ratio,quadratic,squareroot

Other mathematical transform classes: EHtrans-class, asinht-class, asinhtGml2-class, exponential-class, hyperlog-class, hyperlogtGml2-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
  package="flowCore"))
  dg1<-dg1polynomial(c("FSC-H","SSC-H"),a=c(1,2),b=1,transformationId="dg1")
  transOut<-eval(dg1)(exprs(dat))

Description

Returns a vector or array of values obtained by applying a function to the margins of a flowFrame. This is equivalent of running apply on the output of exprs(flowFrame).

Usage

each_col(x, FUN, ...)
each_row(x, FUN, ...)

Arguments

Author(s)

B. Ellis, N. LeMeur, F. Hahne

See Also

apply

Examples

samp <- read.FCS(system.file("extdata", "0877408774.B08", package="flowCore"),
transformation="linearize")
each_col(samp, summary)

Description

EH transformation of a parameter is defined by the function

$EH(parameter,a,b)= 10^{(\frac{parameter}{a})} + \frac{b*parameter}{a}-1, parameter>=0$

$-10^{(\frac{-parameter}{a})} + \frac{b*parameter}{a}+1, parameter<0$

Slots

.Data

Object of class "function".

a

Object of class "numeric" – numeric constant greater than zero.

b

Object of class "numeric" – numeric constant greater than zero.

parameters

Object of class "transformation" – flow parameter to be transformed.

transformationId

Object of class "character" – unique ID to reference the transformation.

Objects from the Class

Objects can be created by calls to the constructor EHtrans(parameters,a,b,transformationId)

Extends

Class "singleParameterTransform", directly.

Class "transform", by class "singleParameterTransform", distance 2.

Class "transformation", by class "singleParameterTransform", distance 3.

Class "characterOrTransformation", by class "singleParameterTransform", distance 4.

Note

The transformation object can be evaluated using the eval method by passing the data frame as an argument.The transformed parameters are returned as a matrix with a single column. (See example below)

Author(s)

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry V 1.5

See Also

hyperlog

Other mathematical transform classes: asinht-class, asinhtGml2-class, dg1polynomial-class, exponential-class, hyperlog-class, hyperlogtGml2-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
                  package="flowCore"))
  eh1<-EHtrans("FSC-H",a=1250,b=4,transformationId="eh1")
  transOut<-eval(eh1)(exprs(dat))

Description

Class and constructor for n-dimensional ellipsoidal filter objects.

Usage

ellipsoidGate(..., .gate, mean, distance=1, filterId="defaultEllipsoidGate")

Arguments

Details

A convenience method to facilitate the construction of a ellipsoid filter objects. Ellipsoid gates in n dimensions (n >= 2) are specified by a a covarinace matrix and a vector of mean values giving the center of the ellipse.

This function is designed to be useful in both direct and programmatic usage. In the first case, simply describe the covariance matrix through named arguments. To use this function programmatically, you may pass a covarince matrix and a mean vector directly, in which case the parameter names are the colnames of the matrix.

Value

Returns a ellipsoidGate object for use in filtering flowFrames or other flow cytometry objects.

Slots

mean

Objects of class "numeric". Vector giving the location of the center of the ellipse in n dimensions.

cov

Objects of class "matrix". The covariance matrix defining the shape of the ellipse.

distance

Objects of class "numeric". The Mahalanobis distance defining the size of the ellipse.

parameters

Object of class "character", describing the parameter used to filter the flowFrame.

filterId

Object of class "character", referencing the filter.

Extends

Class "parameterFilter", directly.

Class "concreteFilter", by class parameterFilter, distance 2.

Class "filter", by class parameterFilter, distance 3.

Objects from the Class

Objects can be created by calls of the form new("ellipsoidGate", ...) or by using the constructor ellipsoidGate. Using the constructor is the recommended way.

Methods

%in%

signature(x = "flowFrame", table = "ellipsoidGate"): The workhorse used to evaluate the filter on data. This is usually not called directly by the user, but internally by calls to the filter methods.

show

signature(object = "ellipsoidGate"): Print information about the filter.

Note

See the documentation in the flowViz package for plotting of ellipsoidGates.

Author(s)

F.Hahne, B. Ellis, N. LeMeur

See Also

flowFrame, polygonGate, rectangleGate, polytopeGate, filter for evaluation of rectangleGates and split and Subsetfor splitting and subsetting of flow cytometry data sets based on that.

Other Gate classes: polygonGate-class, polytopeGate-class, quadGate-class, rectangleGate-class

Examples

## Loading example data
dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))

## Defining the gate
cov <- matrix(c(6879, 3612, 3612, 5215), ncol=2,
dimnames=list(c("FSC-H", "SSC-H"), c("FSC-H", "SSC-H")))
mean <- c("FSC-H"=430, "SSC-H"=175)
eg <- ellipsoidGate(filterId= "myEllipsoidGate", .gate=cov, mean=mean)

## Filtering using ellipsoidGates
fres <- filter(dat, eg)
fres
summary(fres)

## The result of ellipsoid filtering is a logical subset
Subset(dat, fres)

## We can also split, in which case we get those events in and those
## not in the gate as separate populations
split(dat, fres)

##ellipsoidGate can be converted to polygonGate by interpolation
pg <- as(eg, "polygonGate")
pg

Description

Of the negative values for each channel specified, the median of the specified quantiles are used.

Usage

estimateMedianLogicle(flow_set, channels, m = 4.5, q = 0.05)

Arguments

Value

TODO

Description

Exponential transform class, which represents a transformation given by the function

$f(parameter,a,b)=e^{parameter/b}*\frac{1}{a}$

Slots

.Data

Object of class "function".

a

Object of class "numeric" – non-zero constant.

b

Object of class "numeric"- non-zero constant.

parameters

Object of class "transformation" – flow parameter to be transformed.

transformationId

Object of class "character" – unique ID to reference the transformation

Objects from the Class

Objects can be created by calls to the constructorexponential(parameters,a,b).

Extends

Class "singleParameterTransform", directly.

Class "transform", by class "singleParameterTransform", distance 2.

Class "transformation", by class "singleParameterTransform", distance 3.

Class "characterOrTransformation", by class "singleParameterTransform", distance 4.

Note

The exponential transformation object can be evaluated using the eval method by passing the data frame as an argument.The transformed parameters are returned as a matrix with a single column

Author(s)

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry V 1.5

See Also

logarithm

Other mathematical transform classes: EHtrans-class, asinht-class, asinhtGml2-class, dg1polynomial-class, hyperlog-class, hyperlogtGml2-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
  package="flowCore"))
  exp1<-exponential(parameters="FSC-H",a=1,b=37,transformationId="exp1")
  transOut<-eval(exp1)(exprs(dat))

Description

A filter holding an expression that can be evaluated to a logical vector or a vector of factors.

Usage

expressionFilter(expr, ..., filterId="defaultExpressionFilter")
char2ExpressionFilter(expr, ..., filterId="defaultExpressionFilter")

Arguments

Details

The expression is evaluated in the environment of the flow cytometry values, hence the parameters of a flowFrame can be accessed through regular R symbols. The convenience function char2ExpressionFilter exists to programmatically construct expressions.

Value

Returns a expressionFilter object for use in filtering flowFrames or other flow cytometry objects.

Slots

expr

The expression that will be evaluated in the context of the flow cytometry values.

args

An environment providing additional parameters.

deparse

A character scalar of the deparsed expression.

filterId

The identifier of the filter.

Extends

Class "concreteFilter", directly.

Class "filter", by class concreteFilter, distance 2.

Objects from the Class

Objects can be created by calls of the form new("expressionFilter", ...), using the expressionFilter constructor or, programmatically, from a character string using the char2ExpressionFilter function.

Methods

%in%

signature(x = "flowFrame", table = "expressionFilter"): The workhorse used to evaluate the gate on data. This is usually not called directly by the user, but internally by calls to the filter methods.

show

signature(object = "expressionFilter"): Print information about the gate.

Author(s)

F. Hahne, B. Ellis

See Also

flowFrame, filter for evaluation of sampleFilters and split and Subsetfor splitting and subsetting of flow cytometry data sets based on that.

Examples

## Loading example data
dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))

#Create the filter
ef <- expressionFilter(`FSC-H` > 200, filterId="myExpressionFilter")
ef

## Filtering using sampeFilters
fres <- filter(dat, ef)
fres
summary(fres)

## The result of sample filtering is a logical subset
newDat <- Subset(dat, fres)
all(exprs(newDat)[,"FSC-H"] > 200)

## We can also split, in which case we get those events in and those
## not in the gate as separate populations
split(dat, fres)

## Programmatically construct an expression
dat <- dat[,-8]
r <- range(dat)
cn <- paste("`", colnames(dat), "`", sep="")
exp <- paste(cn, ">", r[1,], "&", cn, "<", r[2,], collapse=" & ")
ef2 <- char2ExpressionFilter(exp, filterId="myExpressionFilter")
ef2
fres2 <- filter(dat, ef2)
fres2
summary(fres2)

Description

Transforms FCS data using the iplogicle function from FCSTrans by Quian et al. The core functionality of FCSTrans has been imported to produce transformed FCS data rescaled and truncated as produced by FCSTrans. The w parameter is estimated by iplogicle automatically, then makes a call to iplogicore which in turn uses the logicle transform code of Wayne Moore.

Usage

FCSTransTransform(transformationId = "defaultFCSTransTransform", 
                  channelrange = 2^18, channeldecade = 4.5, 
                  range = 4096, cutoff = -111, w = NULL, rescale = TRUE)

Arguments

Details

For the details of the FCSTrans transformation, we recommend the excellent Supplementary File that accompanies Quian et al. (2012): http://onlinelibrary.wiley.com/doi/10.1002/cyto.a.22037/suppinfo

Author(s)

Wayne Moore, N Gopalakrishnan

References

Y Quian, Y Liu, J Campbell, E Thompson, YM Kong, RH Scheuermann; FCSTrans: An open source software system for FCS file conversion and data transformation. Cytometry A, 2012

See Also

inverseLogicleTransform, estimateLogicle , logicleTransform

Examples

data(GvHD)
samp <- GvHD[[1]] 
## User defined logicle function
lgcl <- transformList(c('FL1-H', 'FL2-H'), FCSTransTransform())
after <- transform(samp, lgcl)

Description

There are two notions of intersection in flowCore. First, there is the usual intersection boolean operator & that has been overridden to allow the intersection of two filters or of a filter and a list for convenience. There is also the %&% or %subset% operator that takes an intersection, but with subset semantics rather than simple intersection semantics. In other words, when taking a subset, calculations from summary and other methods are taken with respect to the right hand filter. This primarily affects calculations, which are ordinarily calculated with respect to the entire population as well as data-driven gating procedures which will operate only on elements contained by the right hand filter. This becomes especially important when using filters such as norm2Filter

Usage

e1 %&% e2
e1 %subset% e2

Arguments

Author(s)

B. Ellis

Description

The filter class is the virtual base class for all filter/gating objects in flowCore. In general you will want to subclass or create a more specific filter.

Slots

filterId

A character vector that identifies this filter. This is typically user specified but can be automatically deduced by certain filter operations, particularly boolean and set operations.

Objects from the Class

All filter objects in flowCore should be instantiated through their constructors. These are functions that share the same name with the respective filter classes. E.g., rectangleGate() is the constructor function for rectangular gates, and kmeansFilter() creates objects of class kmeansFilter. Usually these constructors can deal with various different inputs, allowing to utilize the same function in different programmatic or interactive settings. For all filters that operate on specific flow parameters (i.e., those inheriting from parameterFilter), the parameters need to be passed to the constructor, either as names or colnames of additional input arguments or explicitly as separate arguments. See the documentation of the respective filter classes for details. If parameters are explicitly defined as separate arguments, they may be of class character, in which case they will be evaluated literally as colnames in a flowFrame, or of class transform, in which case the filtering is performed on a temporarily transformed copy of the input data. See here for details.

Methods

%in%

Used in the usual way this returns a vector of values that identify which events were accepted by the filter. A single filter may encode several populations so this can return either a logical vector, a factor vector or a numeric vector of probabilities that the event is accepted by the filter. Minimally, you must implement this method when creating a new type of filter

&, |, !

Two filters can be composed using the usual boolean operations returning a filter class of a type appropriate for handling the operation. These methods attempt to guess an appropriate filterId for the new filter

%subset%, %&%

Defines a filter as being a subset of another filter. For deterministic filters the results will typically be equivalent to using an \& operation to compose the two filters, though summary methods will use subset semantics when calculating proportions. Additionally, when the filter is data driven, such as norm2Filter, the subset semantics are applied to the data used to fit the filter possibly resulting in quite different, and usually more desirable, results.

%on%

Used in conjunction with a transformList to create a transformFilter. This filter is similar to the subset filter in that the filtering operation takes place on transformed values rather than the original values.

filter

A more formal version of %in%, this method returns a filterResult object that can be used in subsequent filter operations as well as providing more metadata about the results of the filtering operation. See the documenation for filter methods for details.

summarizeFilter

When implementing a new filter this method is used to update the filterDetails slot of a filterResult. It is optional and typically only needs to be implemented for data-driven filters.

Author(s)

B. Ellis, P.D. Haaland and N. LeMeur

See Also

transform, filter

Description

Membership methods must be defined for every object of type filter with respect to a flowFrame object. The operation is considered to be general and may return a logical, numeric or factor vector that will be handled appropriately. The ability to handle logical matrices as well as vectors is also planned but not yet implemented.

Usage

x %in% table

Arguments

Value

Vector of type logical, numeric or factor depending on the arguments

Author(s)

F.Hahne, B. Ellis

Description

These methods link filter descriptions to a particular set of flow cytometry data allowing for the lightweight calculation of summary statistics common to flow cytometry analysis.

Usage

filter(x, filter, method = c("convolution", "recursive"), 
sides = 2L, circular = FALSE, init = NULL)

Arguments

Details

The filter method conceptually links a filter description, represented by a filter object, to a particular flowFrame. This is accomplished via the filterResult object, which tracks the linked frame as well as caching the results of the filtering operation itself, allowing for fast calculation of certain summary statistics such as the percentage of events accepted by the filter. This method exists chiefly to allow the calculation of these statistics without the need to first Subset a flowFrame, which can be quite large.

When applying on a flowSet, the filter argument can either be a single filter object, in which case it is recycled for all frames in the set, or a named list of filter objects. The names are supposed to match the frame identifiers (i.e., the output of sampleNames(x) of the flowSet. If some frames identifiers are missing, the particular frames are skipped during filtering. Accordingly, all filters in the filter list that can't be mapped to the flowSet are ignored. Note that all filter objects in the list must be of the same type, e.g. rectangleGates.

Value

A filterResult object or a filterResultList object if x is a flowSet. Note that filterResult objects are themselves filters, allowing them to be used in filter expressions or Subset operations.

Author(s)

F Hahne, B. Ellis, N. Le Meur

See Also

Subset, filter, filterResult

Examples

## Filtering a flowFrame
samp <- read.FCS(system.file("extdata","0877408774.B08", package="flowCore"))
rectGate <- rectangleGate(filterId="nonDebris","FSC-H"=c(200,Inf))
fr <- filter(samp,rectGate)
class(fr)
summary(fr)

## filtering a flowSet
data(GvHD)
foo <- GvHD[1:3]
fr2 <- filter(foo, rectGate)
class(fr2)
summary(fr2)

## filtering a flowSet using different filters for each frame
rg2 <- rectangleGate(filterId="nonDebris","FSC-H"=c(300,Inf))
rg3 <- rectangleGate(filterId="nonDebris","FSC-H"=c(400,Inf))
flist <- list(rectGate, rg2, rg3)
names(flist) <- sampleNames(foo)
fr3 <- filter(foo, flist)

Description

This operator is used to construct a transformFilter that first applies a transformList to the data before applying the filter operation. You may also apply the operator to a flowFrame or flowSet to obtain transformed values specified in the list.

Usage

e1 %on% e2

Arguments

Author(s)

B. Ellis

Examples

samp <- read.FCS(system.file("extdata","0877408774.B08", package="flowCore"))
plot(transform("FSC-H"=log, "SSC-H"=log) %on% samp)


rectangle <- rectangleGate(filterId="rectangleGateI","FSC-H"=c(4.5, 5.5))
sampFiltered <- filter(samp, rectangle %on% transform("FSC-H"=log, "SSC-H"=log))
res <- Subset(samp, sampFiltered)

plot(transform("FSC-H"=log, "SSC-H"=log) %on% res)

Description

A filtering operation captures details about its metadata and stores it in a filterDetails slot in a filterResult object that is accessed using the filterDetails method. Each set of metadata is indexed by the filterId of the filter allowing for all the metadata in a complex filtering operation to be recovered after the final filtering.

Methods

filterDetails(result = "filterResult", filterId = "missing")

When no particular filterId is specified all the details are returned

filterDetails(result = "filterResult", filterId = "ANY")

You can also obtain a particular subset of details

Author(s)

B. Ellis, P.D. Haaland and N. LeMeur

Description

Container for a list of filter objects. The class mainly exists for method dispatch.

Usage

filterList(x, filterId=identifier(x[[1]]))

Arguments

Value

A filterList object for the constructor.

Slots

.Data

Object of class "list". The class directly extends list, and this slot holds the list data.

filterId

Object of class "character". The identifier for the object.

Objects from the Class

Objects are created from regular lists using the constructor filterList.

Extends

Class "list", from data part.

Methods

show

signature(object = "filterList"): Print details about the object.

identifier, identifier<-

signature(object = "filterList"): Accessor and replacement method for the object's filterId slot.

Author(s)

Florian Hahne

See Also

filter,

Examples

f1 <- rectangleGate(FSC=c(100,200), filterId="testFilter")
f2 <- rectangleGate(FSC=c(200,400))
fl <- filterList(list(a=f1, b=f2))
fl
identifier(fl)

Description

A reference to another filter inside a reference. Users should generally not be aware that they are using this class.

Slots

name

The R name of the referenced filter.

env

The environment where the filter must live.

filterId

The filterId, not really used since you always resolve.

Objects from the Class

Objects are generally not created by users so there is no constructor function.

Extends

Class "filter", directly.

Author(s)

B. Ellis

Description

Container to store the result of applying a filter on a flowFrame object

Slots

frameId

Object of class "character" referencing the flowFrame object filtered. Used for sanity checking.

filterDetails

Object of class "list" describing the filter applied.

filterId

Object of class "character" referencing the filter applied.

Extends

Class "filter", directly.

Methods

==

test equality

Author(s)

B. Ellis, N. LeMeur

See Also

filter, "logicalFilterResult", "multipleFilterResult", "randomFilterResult"

Examples

showClass("filterResult")

Description

Container to store the result of applying a filter on a flowSet object

Slots

.Data

Object of class "list". The class directly extends list, and this slot holds the list data.

frameId

Object of class "character" The IDs of the flowFrames in the filtered flowSet.

filterDetails

Object of class "list". Since filterResultList inherits from filterResult, this slot has to be set. It contains only the input filter.

filterId

Object of class "character". The identifier for the object.

Objects from the Class

Objects are created by applying a filter on a flowSet. The user doesn't have to deal with manual object instantiation.

Extends

Class "list", from data part. Class "filterResult", directly. Class "concreteFilter", by class "filterResult", distance 2. Class "filter", by class "filterResult", distance 3.

Methods

[

signature(x = "filterResultList", i = "ANY"): Subset to filterResultList.

[[

signature(x = "filterResultList", i = "ANY"): Subset to individual filterResult.

names

signature(x = "filterResultList"): Accessor to the frameId slot.

parameters

signature(object = "filterResultList"): Return parameters on which data has been filtered.

show

signature(object = "filterResultList"): Print details about the object.

split

signature(x = "flowSet", f = "filterResultList"): Split a flowSet based on the results in the filterResultlIst. See split for details.

summary

signature(object = "filterResultList"): Summarize the filtering operation. This creates a filterSummaryList object.

Author(s)

Florian Hahne

See Also

filter, filterResult, logicalFilterResult, multipleFilterResult, randomFilterResult

Examples

library(flowStats)
## Loading example data and creating a curv1Filter
data(GvHD)
dat <- GvHD[1:3]
c1f <- curv1Filter(filterId="myCurv1Filter", x=list("FSC-H"), bwFac=2)

## applying the filter
fres <- filter(dat, c1f)
fres

## subsetting the list
fres[[1]]
fres[1:2]

## details about the object
parameters(fres)
names(fres)
summary(fres)

## splitting based on the filterResults
split(dat, fres)

Description

The filters class is the container for a list of filter objects.

The filtersList class is the container for a list of filters objects.

Usage

filters(x)

filtersList(x)

Arguments

Details

The filters class mainly exists for displaying multiple filters/gates on one single panel(flowFrame) of xyplot. Note that it is different from filterList class which is to be applied to a flowSet. In other words, filter objects of a fliterList are to be applied to different flowFrames. However,all of filter objects of a filters object are for one single flowFrame, more specifically for one pair of projections(parameters).So these filters should share the common parameters.

And filtersList is a list of filters objects, which are to be applied to a flowSet.

Value

A filters or filtersList object from the constructor

Slots

.Data

Object of class "list". The class directly extends list, and this slot holds the list data.

Extends

Class "list"

Objects from the Class

Objects are created from regular lists using the constructors filters and filtersList:

filters(x)

filtersList(x)

Author(s)

Mike Jiang

See Also

filter, filterList

Description

Class and methods to handle the summary information of a gating operation.

Usage

## S4 method for signature 'filterResult'
summary(object, ...)

Arguments

Details

Calling summary on a filterResult object prints summary information on the screen, but also creates objects of class filterSummary for computational access.

Value

An object of class filterSummary for the summary constructor, a named list for the subsetting operators. The $ operator returns a named vector of the respective value, where each named element corresponds to one sub-population.

Slots

name

Object of class "character" The name(s) of the populations created in the filtering operation. For a logicalFilterResult this is just a single value; the name of the link{filter}.

true

Object of class "numeric". The number of events within the population(s).

count

Object of class "numeric". The total number of events in the gated flowFrame.

p

Object of class "numeric" The percentage of cells in the population(s).

Objects from the Class

Objects are created by calling summary on a link{filterResult} object. The user doesn't have to deal with manual object instantiation.

Methods

[[

signature(x = "filterSummary", i = "numeric"): Subset the filterSummary to a single population. This only makes sense for multipleFilterResults. The output is a list of summary statistics.

[[

signature(x = "filterSummary", i = "character"): see above

$

signature(x = "filterSummary", name = "ANY"): A list-like accessor to the slots and more. Valid values are n and count (those are identical), true and in (identical), false and out (identical), name, p and q (1-p).

coerce

signature(from = "filterSummary", to = "data.frame"): Coerce object to data.frame.

length

signature(x = "filterSummary"): The number of populations in the fitlerSummary.

names

signature(x = "filterSummary"): The names of the populations in the filterSummary.

print

signature(x = "filterSummary"): Print details about the object.

show

signature(object = "filterSummary"): Print details about the object.

toTable

signature(x = "filterSummary"): Coerce object to data.frame.

Author(s)

Florian Hahne, Byron Ellis

See Also

filterResult, logicalFilterResult, multipleFilterResult, flowFrame filterSummaryList

Examples

library(flowStats)

## Loading example data, creating and applying a curv1Filter
dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))
c1f <- curv1Filter(filterId="myCurv1Filter", x=list("FSC-H"), bwFac=2)
fres <- filter(dat, c1f)

## creating and showing the summary
summary(fres)
s <- summary(fres)

## subsetting
s[[1]]
s[["peak 2"]]

##accessing details
s$true
s$n
toTable(s)

Description

Class and methods to handle summary statistics for from filtering operations on whole flowSets.

Arguments

Details

Calling summary on a filterResultList object prints summary information on the screen, but also creates objects of class filterSummaryList for computational access.

Value

An object of class filterSummaryList.

Slots

.Data

Object of class "list". The class directly extends list, and this slot holds the list data.

Usage

summary(object, ...)

Objects from the Class

Objects are created by calling summary on a link{filterResultList} object. The user doesn't have to deal with manual object instantiation.

Extends

Class "list", from .Data part.

Methods

toTable

signature(x = "filterSummaryList"): Coerce object to data.frame. Additional factors are added to indicate list items in the original object.

Author(s)

Florian Hahne

See Also

filterResult, filterResultList, logicalFilterResult, multipleFilterResult, flowFrame filterSummary

Examples

library(flowStats)

## Loading example data, creating and applying a curv1Filter
data(GvHD)
dat <- GvHD[1:3]
c1f <- curv1Filter(filterId="myCurv1Filter", x=list("FSC-H"), bwFac=2)
fres <- filter(dat, c1f)

## creating and showing the summary
summary(fres)
s <- summary(fres)

## subsetting
s[[1]]

##accessing details
toTable(s)

Description

This class represents the data contained in a FCS file or similar data structure. There are three parts of the data:

1. a numeric matrix of the raw measurement values with rows=events and columns=parameters

2. annotation for the parameters (e.g., the measurement channels, stains, dynamic range)

3. additional annotation provided through keywords in the FCS file

Details

Objects of class flowFrame can be used to hold arbitrary data of cell populations, acquired in flow-cytometry.

FCS is the Data File Standard for Flow Cytometry, the current version is FCS 3.0. See the vignette of this package for additional information on using the object system for handling of flow-cytometry data.

Slots

exprs

Object of class matrix containing the measured intensities. Rows correspond to cells, columns to the different measurement channels. The colnames attribute of the matrix is supposed to hold the names or identifiers for the channels. The rownames attribute would usually not be set.

parameters

An AnnotatedDataFrame containing information about each column of the flowFrame. This will generally be filled in by read.FCS or similar functions using data from the FCS keywords describing the parameters.

description

A list containing the meta data included in the FCS file.

Creating Objects

Objects can be created using
new("flowFrame",
exprs = ...., Object of class matrix
parameters = ...., Object of class AnnotatedDataFrame
description = ...., Object of class list
)

or the constructor flowFrame, with mandatory arguments exprs and optional arguments parameters and description.

flowFrame(exprs, parameters, description=list())

To create a flowFrame directly from an FCS file, use function read.FCS. This is the recommended and safest way of object creation, since read.FCS will perform basic data quality checks upon import. Unless you know exactly what you are doing, creating objects using new or the constructor is discouraged.

Methods

There are separate documentation pages for most of the methods listed here which should be consulted for more details.

[

Subsetting. Returns an object of class flowFrame. The subsetting is applied to the exprs slot, while the description slot is unchanged. The syntax for subsetting is similar to that of data.frames. In addition to the usual index vectors (integer and logical by position, character by parameter names), flowFrames can be subset via filterResult and filter objects.

Usage:

flowFrame[i,j]

flowFrame[filter,]

flowFrame[filterResult,]

Note that the value of argument drop is ignored when subsetting flowFrames.

$

Subsetting by channel name. This is similar to subsetting of columns of data.frames, i.e., frame$FSC.H is equivalent to frame[, "FSC.H"]. Note that column names may have to be quoted if they are no valid R symbols (e.g. frame$"FSC-H").

exprs, exprs<-

Extract or replace the raw data intensities. The replacement value must be a numeric matrix with colnames matching the parameter definitions. Implicit subsetting is allowed (i.e. less columns in the replacement value compared to the original flowFrame, but all have to be defined there).

Usage:

exprs(flowFrame)

exprs(flowFrame) <- value

head, tail

Show first/last elements of the raw data matrix

Usage:

head(flowFrame)

tail(flowFrame)

description, description<-

Extract the whole list of annotation keywords and their corresponding values or replace values by keyword (description<- is equivalent to keyword<-). Usually one would only be interested in a subset of keywords, in which case the keyword method is more appropriate. The optional hideInternal parameter can be used to exclude internal FCS parameters starting with $.

Usage:

description(flowFrame)

description(flowFrame) <- value

keyword, keyword<-

Extract ore replace one or more entries from the description slot by keyword. Methods are defined for character vectors (select a keyword by name), functions (select a keyword by evaluating a function on their content) and for lists (a combination of the above). See keyword for details.

Usage:

keyword(flowFrame)

keyword(flowFrame, character)

keyword(flowFrame, list)

keyword(flowFrame) <- list(value)

parameters, parameters<-

Extract parameters and return an object of class AnnotatedDataFrame, or replace such an object. To access the actual parameter annotation, use pData(parameters(frame)). Replacement is only valid with AnnotatedDataFrames containing all varLabels name, desc, range, minRange and maxRange, and matching entries in the name column to the colnames of the exprs matrix. See parameters for more details.

Usage:

parameters(flowFrame)

parameters(flowFrame) <- value

show

Display details about the flowFrame object.

summary

Return descriptive statistical summary (min, max, mean and quantile) for each channel

Usage:

summary(flowFrame)

plot

Basic plots for flowFrame objects. If the object has only a single parameter this produces a histogram. For exactly two parameters we plot a bivariate density map (see smoothScatter and for more than two parameters we produce a simple splom plot. To select specific parameters from a flowFrame for plotting, either subset the object or specify the parameters as a character vector in the second argument to plot. The smooth parameters lets you toggle between density-type smoothScatter plots and regular scatterplots. This simple method still uses the legacy flowViz package. For far more sophisticated plotting of flow cytometry data, see the ggcyto package.

Usage:

plot(flowFrame, ...)

plot(flowFrame, character, ...)

plot(flowFrame, smooth=FALSE, ...)

ncol, nrow, dim

Extract the dimensions of the data matrix.

Usage:

ncol(flowFrame)

nrow(flowFrame)

dim(flowFrame)

featureNames, colnames, colnames<-

. colnames and featureNames are synonyms, they extract parameter names (i.e., the colnames of the data matrix) . For colnames there is also a replacement method. This will update the name column in the parameters slot as well.

Usage:

featureNames(flowFrame)

colnames(flowFrame)

colnames(flowFrame) <- value

names

Extract pretty formated names of the parameters including parameter descriptions.

Usage:

names(flowFrame)

identifier

Extract GUID of a flowFrame. Returns the file name if no GUID is available. See identifier for details.

Usage:

identifier(flowFrame)

range

Get instrument or actual data range of the flowFame. Note that instrument dynamic range is not necessarily the same as the range of the actual data values, but the theoretical range of values the measurement instrument was able to capture. The values of the dynamic range will be transformed when using the transformation methods forflowFrames.

parameters:

x: flowFrame object.

type: Range type. either "instrument" or "data". Default is "instrument"

Usage:

range(x, type = "data")

each_row, each_col

Apply functions over rows or columns of the data matrix. These are convenience methods. See each_col for details.

Usage:

each_row(flowFrame, function, ...)

each_col(flowFrame, function, ...)

transform

Apply a transformation function on a flowFrame object. This uses R's transform function by treating the flowFrame like a regular data.frame. flowCore provides an additional inline mechanism for transformations (see %on%) which is strictly more limited than the out-of-line transformation described here.

Usage:

transform(flowFrame, translist, ...)

filter

Apply a filter object on a flowFrame object. This returns an object of class filterResult, which could then be used for subsetting of the data or to calculate summary statistics. See filter for details.

Usage:

filter(flowFrame, filter)

split

Split flowFrame object according to a filter, a filterResult or a factor. For most types of filters, an optional flowSet=TRUE parameter will create a flowSet rather than a simple list. See split for details.

Usage:

split(flowFrame, filter, flowSet=FALSE, ...)

split(flowFrame, filterResult, flowSet=FALSE, ...)

split(flowFrame, factor, flowSet=FALSE, ...)

Subset

Subset a flowFrame according to a filter or a logical vector. The same can be done using the standard subsetting operator with a filter, filterResult, or a logical vector as first argument.

Usage:

Subset(flowFrame, filter)

Subset(flowFrame, logical)

cbind2

Expand a flowFrame by the data in a numeric matrix of the same length. The matrix must have column names different from those of the flowFrame. The additional method for numerics only raises a useful error message.

Usage:

cbind2(flowFrame, matrix)

cbind2(flowFrame, numeric)

compensate

Apply a compensation matrix (or a compensation object) on a flowFrame object. This returns a compensated flowFrame.

Usage:

compensate(flowFrame, matrix) compensate(flowFrame, data.frame)

decompensate

Reverse the application of a compensation matrix (or a compensation object) on a flowFrame object. This returns a decompensated flowFrame.

Usage:

decompensate(flowFrame, matrix) decompensate(flowFrame, data.frame)

spillover

Extract spillover matrix from description slot if present. It is equivalent to keyword(x, c("spillover", "SPILL", "$SPILLOVER")) Thus will simply return a list of keywords value for "spillover", "SPILL" and "$SPILLOVER".

Usage:

spillover(flowFrame)

==

Test equality between two flowFrames

<, >, <=, >=

These operators basically treat the flowFrame as a numeric matrix.

initialize(flowFrame):

Object instantiation, used by new; not to be called directly by the user.

Author(s)

F. Hahne, B. Ellis, P. Haaland and N. Le Meur

See Also

flowSet, read.FCS

Examples

## load example data
data(GvHD)
frame <- GvHD[[1]]

## subsetting
frame[1:4,]
frame[,3]
frame[,"FSC-H"]
frame$"SSC-H"

## accessing and replacing raw values
head(exprs(frame))
exprs(frame) <- exprs(frame)[1:3000,]
frame
exprs(frame) <- exprs(frame)[,1:6]
frame

## access FCS keywords
head(keyword(frame))
keyword(frame, c("FILENAME", "$FIL"))

## parameter annotation
parameters(frame)
pData(parameters(frame))

## summarize frame data
summary(frame)

## plotting
plot(frame)
if(require(flowViz)){
plot(frame)
plot(frame, c("FSC-H", "SSC-H"))
plot(frame[,1])
plot(frame, c("FSC-H", "SSC-H"), smooth=FALSE)
}

## frame dimensions
ncol(frame)
nrow(frame)
dim(frame)

## accessing and replacing parameter names
featureNames(frame)
all(featureNames(frame) == colnames(frame))
colnames(frame) <- make.names(colnames(frame))
colnames(frame)
parameters(frame)$name
names(frame)

## accessing a GUID
identifier(frame)
identifier(frame) <- "test"

##  range of a frame
range(frame) #instrument range
range(frame, type = "data") #actual data range
range(frame)$FSC.H

## iterators
head(each_row(frame, mean))
head(each_col(frame, mean))

## transformation
opar <- par(mfcol=c(1:2))
if(require(flowViz))
plot(frame, c("FL1.H", "FL2.H"))
frame <- transform(frame, transformList(c("FL1.H", "FL2.H"), log))
if(require(flowViz))
plot(frame, c("FL1.H", "FL2.H"))
par(opar)
range(frame)

## filtering of flowFrames
rectGate <- rectangleGate(filterId="nonDebris","FSC.H"=c(200,Inf))
fres <- filter(frame, rectGate)
summary(fres)

## splitting of flowFrames
split(frame, rectGate)
split(frame, rectGate, flowSet=TRUE)
split(frame, fres)
f <- cut(exprs(frame$FSC.H), 3)
split(frame, f)

## subsetting according to filters and filter results
Subset(frame, rectGate)
Subset(frame, fres)
Subset(frame, as.logical(exprs(frame$FSC.H) < 300))
frame[rectGate,]
frame[fres,]

## accessing the spillover matrix
try(spillover(frame))

## check equality
frame2 <- frame
frame == frame2
exprs(frame2) <- exprs(frame)*2
frame == frame2

Description

This is a simple helper function for splitting a flowSet in to a list of its constituent flowFrames.

Usage

flowSet_to_list(fs)

Arguments

Value

a list of flowFrames

Description

This class is a container for a set of flowFrame objects

Slots

frames

An environment containing one or more flowFrame objects.

phenoData

An AnnotatedDataFrame containing the phenotypic data for the whole data set. Each row corresponds to one of the flowFrames in the frames slot. The sampleNames of phenoData (see below) must match the names of the flowFrame in the frames environment.

Creating Objects

Objects can be created using
new('flowSet',
frames = ...., # environment with flowFrames
phenoData = .... # object of class AnnotatedDataFrame
colnames = .... # object of class character
)

or via the constructor flowSet, which takes arbitrary numbers of flowFrames, either as a list or directly as arguments, along with an optional AnnotatedDataFrame for the phenoData slot and a character scalar for the name by which the object can be referenced.

flowSet(..., phenoData)

Alternatively, flowSets can be coerced from list and environment objects.

as(list("A"=frameA,"B"=frameB),"flowSet")

The safest and easiest way to create flowSets directly from FCS files is via the read.flowSet function, and there are alternative ways to specify the files to read. See the separate documentation for details.

Methods

[, [[

Subsetting. x[i] where i is a scalar, returns a flowSet object, and x[[i]] a flowFrame object. In this respect the semantics are similar to the behavior of the subsetting operators for lists. x[i, j] returns a flowSet for which the parameters of each flowFrame have been subset according to j, x[[i,j]] returns the subset of a single flowFrame for all parameters in j. Similar to data frames, valid values for i and j are logicals, integers and characters.

Usage:

flowSet[i]

flowSet[i,j]

flowSet[[i]]

$

Subsetting by frame name. This will return a single flowFrame object. Note that names may have to be quoted if they are no valid R symbols (e.g. flowSet$"sample 1"

colnames, colnames<-

Extract or replace the colnames slot.

Usage:

colnames(flowSet)

colnames(flowSet) <- value

identifier, identifier<-

Extract or replace the name item from the environment.

Usage:

identifier(flowSet)

identifier(flowSet) <- value

phenoData, phenoData<-

Extract or replace the AnnotatedDataFrame from the phenoData slot.

Usage:

phenoData(flowSet)

phenoData(flowSet) <- value

pData, pData<-

Extract or replace the data frame (or columns thereof) containing actual phenotypic information from the phenoData slot.

Usage:

pData(flowSet)

pData(flowSet)$someColumn <- value

varLabels, varLabels<-

Extract and set varLabels in the AnnotatedDataFrame of the phenoData slot.

Usage:

varLabels(flowSet)

varLabels(flowSet) <- value

sampleNames

Extract and replace sample names from the phenoData object. Sample names correspond to frame identifiers, and replacing them will also replace the GUID slot for each frame. Note that sampleName need to be unique.

Usage:

sampleNames(flowSet)

sampleNames(flowSet) <- value

keyword

Extract or replace keywords specified in a character vector or a list from the description slot of each frame. See keyword for details.

Usage:

keyword(flowSet, list(keywords))

keyword(flowSet, keywords)

keyword(flowSet) <- list(foo="bar")

length

number of flowFrame objects in the set.

Usage:

length(flowSet)

show

display object summary.

summary

Return descriptive statistical summary (min, max, mean and quantile) for each channel of each flowFrame

Usage:

summary(flowSet)

fsApply

Apply a function on all frames in a flowSet object. Similar to sapply, but with additional parameters. See separate documentation for details.

Usage:

fsApply(flowSet, function, ...)

fsApply(flowSet, function, use.exprs=TRUE, ...)

compensate

Apply a compensation matrix on all frames in a flowSet object. See separate documentation for details.

Usage:

compensate(flowSet, matrix)

transform

Apply a transformation function on all frames of a flowSet object. See separate documentation for details.

Usage:

transform(flowSet, ...)

filter

Apply a filter object on a flowSet object. There are methods for filters and lists of filters. The latter has to be a named list, where names of the list items are matching sampleNames of the flowSet. See filter for details.

Usage:

filter(flowSet, filter)

filter(flowSet, list(filters))

split

Split all flowSet objects according to a filter, filterResult or a list of such objects, where the length of the list has to be the same as the length of the flowSet. This returns a list of flowFrames or an object of class flowSet if the flowSet argument is set to TRUE. Alternatively, a flowSet can be split into separate subsets according to a factor (or any vector that can be coerced into factors), similar to the behaviour of split for lists. This will return a list of flowSets. See split for details.

Usage:

split(flowSet, filter)

split(flowSet, filterResult)

split(flowSet, list(filters))

split(flowSet, factor)

Subset

Returns a flowSet of flowFrames that have been subset according to a filter or filterResult, or according to a list of such items of equal length as the flowSet.

Usage:

Subset(flowSet, filter)

Subset(flowSet, filterResult)

Subset(flowSet, list(filters))

rbind2

Combine two flowSet objects, or one flowSet and one flowFrame object.

Usage:

rbind2(flowSet, flowSet)

rbind2(flowSet, flowFrame)

spillover

Compute spillover matrix from a compensation set. See separate documentation for details.

Important note on storage and performance

The bulk of the data in a flowSet object is stored in an environment, and is therefore not automatically copied when the flowSet object is copied. If x is an object of class flowSet, then the code

y <- x

will create an object y that contains copies of the phenoData and administrative data in x, but refers to the same environment with the actual fluorescence data. See below for how to create proper copies.

The reason for this is performance. The pass-by-value semantics of function calls in R can result in numerous copies of the same data object being made in the course of a series of nested function calls. If the data object is large, this can result in considerable cost of memory and performance. flowSet objects are intended to contain experimental data in the order of hundreds of Megabytes, which can effectively be treated as read-only: typical tasks are the extraction of subsets and the calculation of summary statistics. This is afforded by the design of the flowSet class: an object of that class contains a phenoData slot, some administrative information, and a reference to an environment with the fluorescence data; when it is copied, only the reference is copied, but not the potentially large set of fluorescence data themselves.

However, note that subsetting operations, such as y <- x[i] do create proper copies, including a copy of the appropriate part of the fluorescence data, as it should be expected. Thus, to make a proper copy of a flowSet x, use y <- x[seq(along=x)]

Author(s)

F. Hahne, B. Ellis, P. Haaland and N. Le Meur

See Also

flowFrame, read.flowSet

Examples

## load example data and object creation
data(GvHD)

## subsetting to flowSet
set <- GvHD[1:4]
GvHD[1:4,1:2]
sel <- sampleNames(GvHD)[1:2]
GvHD[sel, "FSC-H"]
GvHD[sampleNames(GvHD) == sel[1], colnames(GvHD[1]) == "SSC-H"]

## subsetting to flowFrame
GvHD[[1]]
GvHD[[1, 1:3]]
GvHD[[1, "FSC-H"]]
GvHD[[1, colnames(GvHD[1]) == "SSC-H"]]
GvHD$s5a02

## constructor
flowSet(GvHD[[1]], GvHD[[2]])
pd <- phenoData(GvHD)[1:2,]
flowSet(s5a01=GvHD[[1]], s5a02=GvHD[[2]],phenoData=pd)

## colnames
colnames(set)
colnames(set) <- make.names(colnames(set))

## object name
identifier(set)
identifier(set) <- "test"

## phenoData
pd <- phenoData(set)
pd
pd$test <- "test"
phenoData(set) <- pd
pData(set)
varLabels(set)
varLabels(set)[6] <- "Foo"
varLabels(set)

## sampleNames
sampleNames(set)
sampleNames(set) <- LETTERS[1:length(set)]
sampleNames(set)

## keywords
keyword(set, list("transformation"))

## length
length(set)

## compensation
samp <- read.flowSet(path=system.file("extdata","compdata","data",
package="flowCore"))
cfile <- system.file("extdata","compdata","compmatrix", package="flowCore")
comp.mat <- read.table(cfile, header=TRUE, skip=2, check.names = FALSE)
comp.mat
summary(samp[[1]])
samp <- compensate(samp, as.matrix(comp.mat))
summary(samp[[1]])

## transformation
opar <- par(mfcol=c(1:2))
plot(set[[1]], c("FL1.H", "FL2.H"))
set <- transform(set, transformList(c("FL1.H", "FL2.H"), log))
plot(set[[1]], c("FL1.H", "FL2.H"))
par(opar)

## filtering of flowSets
rectGate <- rectangleGate(filterId="nonDebris", FSC.H=c(200,Inf))
fres <- filter(set, rectGate)
class(fres)
summary(fres[[1]])
rectGate2 <- rectangleGate(filterId="nonDebris2", SSC.H=c(300,Inf))
fres2 <- filter(set, list(A=rectGate, B=rectGate2, C=rectGate, D=rectGate2))

## Splitting frames of a flowSet
split(set, rectGate)
split(set[1:2], rectGate, populatiuon="nonDebris2+")
split(set, c(1,1,2,2))

## subsetting according to filters and filter results
Subset(set, rectGate)
Subset(set, filter(set, rectGate))
Subset(set, list(A=rectGate, B=rectGate2, C=rectGate, D=rectGate2))

## combining flowSets
rbind2(set[1:2], set[3:4])
rbind2(set[1:3], set[[4]])
rbind2(set[[4]], set[1:2])

Description

Append data columns to a flowFrame

Usage

fr_append_cols(fr, cols)

Arguments

Details

It is used to add extra data columns to the existing flowFrame. It handles keywords and parameters properly to ensure the new flowFrame can be written as a valid FCS through the function write.FCS .

Value

A flowFrame

Author(s)

Mike Jiang

Examples

data(GvHD)
  tmp <- GvHD[[1]]
  
  kf <- kmeansFilter("FSC-H"=c("Pop1","Pop2","Pop3"), filterId="myKmFilter")
  fres <- filter(tmp, kf)
  cols <- as.integer(fres@subSet)
  cols <- matrix(cols, dimnames = list(NULL, "km"))
  tmp <- fr_append_cols(tmp, cols)
  
  tmpfile <- tempfile()
  write.FCS(tmp, tmpfile)

Description

fsApply, like many of the apply-style functions in R, acts as an iterator for flowSet objects, allowing the application of a function to either the flowFrame or the data matrix itself. The output can then be reconstructed as either a flowSet, a list, or a matrix depending on options and the type of objects returned.

Usage

fsApply(x, FUN, ..., simplify=TRUE, use.exprs=FALSE)

Arguments

Author(s)

B. Ellis

See Also

apply, sapply

Examples

fcs.loc <- system.file("extdata",package="flowCore")
file.location <- paste(fcs.loc, dir(fcs.loc), sep="/")
samp <- read.flowSet(file.location[1:3]) 

#Get summary information about each sample.
fsApply(samp,summary)

#Obtain the median of each parameter in each frame.
fsApply(samp,each_col,median)

Description

This function tries best to guess the flow parameter based on the keyword supplied by name It first does a complete word match(case insensitive) between name and flow channels and markers. If there are duplcated matches, throw the error. If no matches, it will try the partial match.

Usage

getChannelMarker(frm, name, ...)

Arguments

Value

an one-row data.frame that contains "name"(i.e. channel) and "desc"(i.e. stained marker) columns.

Description

Retrieve a data frame of index sorted data and sort indices from an FCS file.

Details

The input FCS file should already be compensated. Index sorting permits association of cell-level fluorescence intensities with downstream data collection on the sorted cells. Cells are sorted into a plate with X,Y coordinates, and those coordinates are stored in the FCS file.

This function will extract the data frame of flow data and the X,Y coordinates for the cell-level data, which can be written to a text file, or concatenated with sample-level information and analyzed in R. The coordinates are names 'XLoc','YLoc', and a 'name' column is also prepended with the FCS file name.

Value

Matrix of fluorescence intensities and sort indices for plate location. When no index sorting data is available, invisibly returns 0. Test for 0 to check success.

Methods

getIndexSort(x = "flowFrame")

Return a matrix of fluorescence intensities and indices into the sorting plate for each cell.

Author(s)

G. Finak

Examples

samp <- read.FCS(system.file("extdata","0877408774.B08", package="flowCore"))
 # This will return a message that no index sorting data is available
 getIndexSort(samp)

Description

A flow cytometry high throughput screening was used to identify biomarkers that would predict the development of GvHD. The GvHD dataset is an extract of a collection of weekly peripheral blood samples obtained from patients following allogenic blood and marrow transplant. Samples were taken at various time points before and after graft.

Usage

data(GvHD)

Format

The format is an object of class flowSet composed of 35 flowFrames. Each flowFrame corresponds to one sample at one time point. The phenodata lists:

Patient

The patient Id code

Visit

The number of visits to the hospital

Days

The number of days since the graft. Negative values correpond to days before the graft.

Grade

Grade of the cancer

Details

This GvHD dataset represents the measurements of one biomarker (leukocyte) for 5 patients over 7 visits (7 time points). The blood samples were labeled with four different fluorescent probes to identify the biomarker and the fluorescent intensity was determined for at least ten thousand cells per sample.

Source

Complete dataset available at http://www.ficcs.org/software.html#Data_Files, the Flow Informatics and Computational Cytometry Society website (FICCS)

References

Rizzieri DA et al. J Clin Oncol. 2007 Jan 16; [Epub ahead of print] PMID: 17228020

Description

Hyperlog transformation of a parameter is defined by the function

$f(parameter,a,b)=root{EH(y,a,b)-parameter}$

where EH is a function defined by

$EH(y,a,b) = 10^{(\frac{y}{a})} + \frac{b*y}{a}-1, y>=0$

$EH(y,a,b)= -10^{(\frac{-y}{a})} + \frac{b*y}{a}+1, y<0$

Slots

.Data

Object of class "function".

a

Object of class "numeric" – numeric constant treater than zero.

b

Object of class "numeric" numeric constant greater than zero.

parameters

Object of class "transformation" – flow parameter to be transformed.

transformationId

Object of class "character" – unique ID to reference the transformation.

Objects from the Class

Objects can be created by calls to the constructor hyperlog(parameter,a,b,transformationId)

Extends

Class "singleParameterTransform", directly.

Class "transform", by class "singleParameterTransform", distance 2.

Class "transformation", by class "singleParameterTransform", distance 3.

Class "characterOrTransformation", by class "singleParameterTransform", distance 4.

Note

The transformation object can be evaluated using the eval method by passing the data frame as an argument.The transformed parameters are returned as a matrix with a single column. (See example below)

Author(s)

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry V 1.5

See Also

EHtrans

Other mathematical transform classes: EHtrans-class, asinht-class, asinhtGml2-class, dg1polynomial-class, exponential-class, hyperlogtGml2-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
  package="flowCore"))
  hlog1<-hyperlog("FSC-H",a=1,b=1,transformationId="hlog1")
  transOut<-eval(hlog1)(exprs(dat))

Description

Hyperlog transformation parameterized according to Gating-ML 2.0.

Details

hyperlogtGml2 is defined by the following function:

$bound(hyperlog, boundMin, boundMax) = max(min(hyperlog,boundMax),boundMin))$

where

$hyperlog(x, T, W, M, A) = root(EH(y, T, W, M, A) - x)$

and $EH$ is defined as:

$EH(y, T, W, M, A) = ae^{by} + cy - f$

where

• x is the value that is being transformed (an FCS dimension value). Typically, x is less than or equal to T, although the transformation function is also defined for x greater than T.

• y is the result of the transformation.

• T is greater than zero and represents the top of scale value.

• M is greater than zero and represents the number of decades that the true logarithmic scale approached at the high end of the Hyperlog scale would cover in the plot range.

• W is positive and not greater than half of M and represents the number of such decades in the approximately linear region.

• A is the number of additional decades of negative data values to be included. A shall be greater than or equal to $-W$, and less than or equal to $M - 2W$

• root is a standard root finding algorithm (e.g., Newton's method) that finds y such as $B(y, T, W, M, A) = x$.

and $a$, $b$, $c$ and $f$ are defined by means of $T$, $W$, $M$, $A$, $w$, $x0$, $x1$, $x2$, $e0$, $ca$ and $fa$ as:

$w = W/(M+A)$

$x2 = A/(M+A)$

$x1 = x2 + w$

$x0 = x2 + 2*w$

$b = (M + A)*ln(10)$

$e0 = e^{b*x0}$

$ca= e0/w$

$fa = e^{b*x1} + ca*x1$

$a = T / (e^b + ca - fa)$

$c = ca * a$

$f = fa * a$

In addition, if a boundary is defined by the boundMin and/or boundMax parameters, then the result of this transformation is restricted to the [boundMin,boundMax] interval. Specifically, should the result of the hyperlog function be less than boundMin, then let the result of this transformation be boundMin. Analogically, should the result of the hyperlog function be more than boundMax, then let the result of this transformation be boundMax. The boundMin parameter shall not be greater than the boundMax parameter.

Slots

.Data

Object of class function.

T

Object of class numeric – positive constant (top of scale value).

M

Object of class numeric – positive constant (desired number of decades).

W

Object of class numeric – positive constant that is not greater than half of M (the number of such decades in the approximately linear region)

A

Object of class numeric – a constant that is greater than or equal to -W, and also less than or equal to M-2W. (A represents the number of additional decades of negative data values to be included.)

parameters

Object of class "transformation" – flow parameter to be transformed.

transformationId

Object of class "character" – unique ID to reference the transformation.

boundMin

Object of class numeric – lower bound of the transformation, default -Inf.

boundMax

Object of class numeric – upper bound of the transformation, default Inf.

Objects from the Class

Objects can be created by calls to the constructor

hyperlogtGml2(parameter, T, M, W, A, transformationId, boundMin, boundMax)

Extends

Class singleParameterTransform, directly.

Class transform, by class singleParameterTransform, distance 2.

Class transformation, by class singleParameterTransform, distance 3.

Class characterOrTransformation, by class singleParameterTransform, distance 4.

Note

That hyperlogtGml2 transformation brings "reasonable" data values to the scale of $[0,1]$. The transformation is somewhat similar to logicletGml2. (See Gating-ML 2.0 for detailed comparison)

The hyperlog transformation object can be evaluated using the eval method by passing the data frame as an argument. The transformed parameters are returned as a matrix with a single column. (See example below)

Author(s)

Spidlen, J., Moore, W.

References

Gating-ML 2.0: International Society for Advancement of Cytometry (ISAC) standard for representing gating descriptions in flow cytometry. http://flowcyt.sourceforge.net/gating/20141009.pdf

See Also

hyperlog, logicleTransform, transform-class, transform

Other mathematical transform classes: EHtrans-class, asinht-class, asinhtGml2-class, dg1polynomial-class, exponential-class, hyperlog-class, invsplitscale-class, lintGml2-class, logarithm-class, logicletGml2-class, logtGml2-class, quadratic-class, ratio-class, ratiotGml2-class, sinht-class, splitscale-class, squareroot-class, unitytransform-class

Examples

myDataIn  <- read.FCS(system.file("extdata", "0877408774.B08", 
    package="flowCore"))
myHyperLg <- hyperlogtGml2(parameters = "FSC-H", T = 1023, M = 4.5, 
    W = 0.5, A = 0, transformationId="myHyperLg")
transOut  <- eval(myHyperLg)(exprs(myDataIn))

Description

Retrieve the GUID (globally unique identifier) of a flowFrame that was generated by the cytometer or the identifier of a filter or filterResult given by the analyst.

Usage

identifier(object)

Arguments

Details

GUID or Globally Unique Identifier is a pseudo-random number used in software applications. While each generated GUID is not guaranteed to be unique, the total number of unique keys (2\^128) is so large that the probability of the same number being generated twice is very small.

Note that if no GUID has been recorded along with the FCS file, the name of the file is returned.

Value

Character vector representing the GUID or the name of the file.

Methods

identifier(object = "filter")

Return identifier of a filter object.

identifier(object = "filterReference")

Return identifier of a filterReference object.

identifier(object = "filterResult")

Return identifier of a filterResult object.

identifier(object = "transform")

Return identifier of a transform object.

identifier(object = "flowFrame")

Return GUID from the description slot of a flowFrame object or, alternatively, the name of the input FCS file in case none can be found. For flowFrame objects there also exists a replacement method.

Author(s)

N. LeMeur

Examples

samp <- read.FCS(system.file("extdata","0877408774.B08", package="flowCore"))
 identifier(samp)

Description

This class represents the intersection of two filters, which is itself a filter that can be incorporated in to further set operations. intersectFilters are constructed using the binary set operator "&" with operands consisting of a single filter or list of filters.

Slots

filters

Object of class "list", containing the component filters.

filterId

Object of class "character" referencing the filter applied.

Extends

Class "filter", directly.

Author(s)

B. Ellis

See Also

filter, setOperationFilter

Other setOperationFilter classes: complementFilter-class, setOperationFilter-class, subsetFilter-class, unionFilter-class

Description

inverseLogicleTransform can be use to compute the inverse of the Logicle transformation. The parameters w, t, m, a for calculating the inverse are obtained from the 'trans' input passed to the 'inverseLogicleTransform' function. (The inverseLogicleTransform method makes use of the C++ implementation of the inverse logicle transform contributed by Wayne Moore et al.)

Usage

inverseLogicleTransform(trans,transformationId,...)

Arguments

Author(s)

Wayne Moore, N. Gopalakrishnan

References

Parks D.R., Roederer M., Moore W.A.(2006) A new "logicle" display method avoids deceptive effects of logarithmic scaling for low signals and compensated data. CytometryA, 96(6):541-51.

See Also

logicleTransform

Other Transform functions: arcsinhTransform(), biexponentialTransform(), linearTransform(), lnTransform(), logTransform(), logicleTransform(), quadraticTransform(), scaleTransform(), splitScaleTransform(), truncateTransform()

Examples

data(GvHD)
samp <- GvHD[[1]] 

#########inverse the transform object###############
logicle  <- logicleTransform(t = 10000, w = 0.5, m = 4.5 , a =0 ,"logicle")
## transform FL1-H parameter using logicle transformation
after <- transform(samp, transformList('FL1-H', logicle))

## Inverse transform the logicle transformed data to retrieve the original data
invLogicle <- inverseLogicleTransform(trans = logicle)
before <- transform (after, transformList('FL1-H', invLogicle))

#########inverse the transformList object###############
translist <- estimateLogicle(samp, c("FL1-H", "FL2-H"))
after <- transform(samp, translist)
## Inverse 
invLogicle <- inverseLogicleTransform(translist)
before <- transform (after, invLogicle)

Description

As its name suggests, the inverse split scale transformation class represents the inverse transformation of a split scale transformation that has a logarithmic scale at high values and a linear scale at low values.

Details

The inverse split scale transformation is defined by the function

$f(parameter,r,maxValue,transitionChannel) \frac{(parameter-b)}{a}, parameter<=t*a + b$

$f(parameter,r,maxValue,transitionChannel) = \frac{10^{parameter*\frac{d}{r}}}{c}, parameter > t*a+b$