Class "EHtrans"

Description

EH transformation of a parameter is defined by the function

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

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

Seealso

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

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

Gopalakrishnan N, F.Hahne

References

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

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))

Computes a transform using the 'iplogicle' function

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

Seealso

inverseLogicleTransform , estimateLogicle , logicleTransform

Author

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

Examples

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

Extract of a Graft versus Host Disease monitoring experiment (Rizzieri et al., 2007)

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.

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: list(" ", list(list("Patient"), list("The patient Id code ")), " ", list(list("Visit"), list("The number of visits to the hospital")), " ", list(list("Days"), list("The number of days since the graft. Negative values correpond to ", "days before the graft.")), " ", list(list("Grade"), list("Grade of the cancer")), " ")

Usage

data(GvHD)

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.

References

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

Subset a flowFrame or a flowSet

Description

An equivalent of a subset function for flowFrame or a flowSet object. Alternatively, the regular subsetting operators can be used for most of the topics documented here.

Usage

Subset(x, subset, ...)

Arguments

Details

The Subset method is the recommended method for obtaining a flowFrame that only contains events consistent with a particular filter. It is functionally equivalent to frame[as(filter(frame,subset),"logical"),] when used in the flowFrame context. Used in the flowSet context, it is equivalent to using fsApply to apply the filtering operation to each flowFrame .

Additionally, using Subset on a flowSet can also take a named list as the subset. In this case, the names of the list object should correspond to the sampleNames of the flowSet, allowing a different filter to be applied to each frame. If not all of the names are used or excess names are present, a warning will be generated but the valid filters will be applied for the rare instances where this is the intended operation. Note that a filter operation will generate a list of filterResult objects that can be used directly with Subset in this manner.

Value

Depending on the original context, either a flowFrame or a flowSet .

Seealso

split , subset

Author

B. Ellis

Examples

sample <- read.flowSet(path=system.file("extdata", package="flowCore"),
pattern="0877408774")
result <- filter(sample, rectangleGate("FSC-H"=c(-Inf, 1024)))
result
Subset(sample,result)

Create the definition of an arcsinh transformation function (base specified by user) to be applied on a data set

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 .

Seealso

transform-class , transform , asinh

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

Author

B. Ellis

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)

Class asinhtGml2

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.

Seealso

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

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

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

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))

Class "asinht"

Description

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

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

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

Seealso

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

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

Gopalakrishnan N, F.Hahne

References

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

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))

Compute a transform using the 'biexponential' function

Description

The 'biexponential' is an over-parameterized inverse of the hyperbolic sine. The function to be inverted takes the form biexp(x) = aexp(b(x-w))-cexp(-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.

Seealso

transform

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

Author

B. Ellis, N Gopalakrishnan

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")

Class "boundaryFilter"

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 flowFrame s or other flow cytometry objects.

Seealso

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

Author

Florian Hahne

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")

Class "characterOrNumeric"

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.

Examples

showClass("characterOrNumeric")

Class "characterOrParameters"

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.

Examples

showClass("characterOrParameters")

Class "characterOrTransformation"

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.

Examples

showClass("characterOrTransformation")

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

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

Convert an object to another class

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

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")

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

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))

Class "compensatedParameter"

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.

Seealso

compensation

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

Gopalakrishnan N,F.Hahne

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]]))

Class "compensation"

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(list(), spillover, compensationId="defaultCompensation")
compensate(x, spillover, list())

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.

Seealso

spillover

Author

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

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)

Class complementFilter

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. complementFilter s are constructed using the prefix unary set operator "!" with a single filter operand.

Seealso

filter , setOperationFilter

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

Author

B. Ellis

Class "concreteFilter"

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.

Seealso

parameterFilter

Author

B. Ellis

Decompensate a flowFrame

Description

Reverse the application of a compensation matrix on a flowFrame

Usage

list(list("decompensate"), list("flowFrame,matrix"))(x, spillover)
list(list("decompensate"), list("flowFrame,data.frame"))(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="  ",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)

Class "dg1polynomial"

Description

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

$$f(parameter1,...,parameter_n,a_1,...,a_n,b) = b + Sigma{i=1}^na_i*parameter_i$$

Seealso

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

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

Gopalakrishnan N, F.Hahne

References

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

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))

Methods to apply functions over flowFrame margins

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

Seealso

apply

Author

B. Ellis, N. LeMeur, F. Hahne

Examples

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

Class "ellipsoidGate"

Description

Class and constructor for n-dimensional ellipsoidal filter objects.

Usage

ellipsoidGate(list(), .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 flowFrame s or other flow cytometry objects.

Seealso

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

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

Note

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

Author

F.Hahne, B. Ellis, N. LeMeur

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

Estimates a common logicle transformation for a flowSet.

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

Class "exponential"

Description

Exponential transform class, which represents a transformation given by the function $$f(parameter,a,b)=e^{parameter/b}*rac{1}{a}$$

Seealso

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

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

Gopalakrishnan N, F.Hahne

References

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

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))

Class "expressionFilter"

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 flowFrame s or other flow cytometry objects.

Seealso

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

Author

F. Hahne, B. Ellis

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)

Obtain details about a filter operation

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.

Author

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

Class "filterList"

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.

Seealso

filter ,

Author

Florian Hahne

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)

Class filterReference

Description

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

Author

B. Ellis

Class "filterResultList"

Description

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

Seealso

filter , filterResult , logicalFilterResult , multipleFilterResult , randomFilterResult

Author

Florian Hahne

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)

Class "filterResult"

Description

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

Seealso

filter , " , " , "

Author

B. Ellis, N. LeMeur

Examples

showClass("filterResult")

Class "filterSummaryList"

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 .

Seealso

filterResult , filterResultList , logicalFilterResult , multipleFilterResult , flowFrame filterSummary

Author

Florian Hahne

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)

Class "filterSummary"

Description

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

Usage

list(list("summary"), list("filterResult"))(object, list())

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.

Seealso

filterResult , logicalFilterResult , multipleFilterResult , flowFrame filterSummaryList

Author

Florian Hahne, Byron Ellis

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)

Take the intersection of two filters

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

B. Ellis

A class for representing filtering operations to be applied to flow data.

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.

Seealso

transform , filter

Author

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

Filter-specific membership methods

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

F.Hahne, B. Ellis

filter out $PnX keywords

Description

filter out $PnX keywords

Usage

filter_keywords(kw, par.id)

Arguments

Value

a filtered list

Examples

data(GvHD)
fr <- GvHD[[1]]
kw <- description(fr)
kw <- filter_keywords(kw, c(1,3,5))

Filter FCS files

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.

Seealso

Subset , filter , filterResult

Author

F Hahne, B. Ellis, N. Le Meur

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)

Methods for Function %on% in Package flowCore' ## Description This operator is used to construct atransformFilterthat first applies atransformListto the data before applying thefilteroperation. You may also apply the operator to aflowFrameorflowSetto obtain transformed values specified in the list. ## Usage ```r e1 %on% e2 ``` ## Arguments |Argument |Description| |------------- |----------------| |e1| a filter , transform , or transformList object| |e2` | a transform , transformList , flowFrame , or flowSet object| ## Author B. Ellis ## Examples r 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)

Class "filters" and "filtersList"

Description

The filters class is the container for a list of filter objects. list() list() 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. list() list() 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

Seealso

filter , filterList

Author

Mike Jiang

flowCore: Basic structures for flow cytometry data

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.

list(list("ll"), list(" Package: ", list(), " flowCore ", list(), " Type: ", list(), " Package ", list(), " Version: ", list(), " 1.11.20 ", list(), " Date: ", list(), " 2009-09-16 ", list(), " License: ", list(), " Artistic-2.0", list(), " "))

Author

Maintainer: Florian Hahne fhahne@fhcrc.org

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

'flowFrame': a class for storing observed quantitative properties for a population of cells from a FACS run

Description

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

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

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

• 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.

Seealso

flowSet , read.FCS

Author

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

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(description(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

'flowSet': a class for storing flow cytometry raw data from quantitative cell-based assays

Description

This class is a container for a set of flowFrame objects

Seealso

flowFrame , read.flowSet

Author

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

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])

Append data columns to a flowFrame

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

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)

Apply a Function over values in a flowSet

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, list(), simplify=TRUE, use.exprs=FALSE)

Arguments

Seealso

apply , sapply

Author

B. Ellis

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)

get channel and marker information from a flowFrame that matches to the given keyword

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.

Extract Index Sorted Data from an FCS File

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.

Author

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)

Class "hyperlog"

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^{(rac{y}{a})} +rac{b*y}{a}-1, y>=0$$

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

Seealso

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

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

Gopalakrishnan N, F.Hahne

References

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

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))

Class hyperlogtGml2

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:

$$ca= e0/w$$

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.

Seealso

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

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

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

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))

Retrieve the GUID of flowCore objects

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.

Author

N. LeMeur

Examples

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

Class intersectFilter

Description

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

Seealso

filter , setOperationFilter

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

Author

B. Ellis

Computes the inverse of the transform defined by the 'logicleTransform' function or the transformList generated by 'estimateLogicle' function

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

Seealso

logicleTransform

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

Author

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.

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)

Class "invsplitscale"

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) rac{(parameter-b)}{a}, parameter<=t*a + b$$

$$f(parameter,r,maxValue,transitionChannel) = rac{10^{parameterrac{d}{r}}}{c}, parameter > ta+b$$

where

$$b=rac{transitionChannel}{2}$$

$$d=rac{2log_{10}(e)r}{transitionChannel} + log_{10}(maxValue)$$

$$t=10^{log_{10}t}$$

$$a= rac{transitionChannel}{2*t}$$

$$log_{10}ct=rac{(at+b)d}{r}$$

$$c=10^{log_{10}ct}$$

Seealso

splitscale

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

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

Gopalakrishnan N,F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",package="flowCore"))
sp1<-invsplitscale("FSC-H",r=512,maxValue=2000,transitionChannel=512)
transOut<-eval(sp1)(exprs(dat))

Methods to retrieve keywords of a flowFrame

Description

Accessor and replacement methods for items in the description slot (usually read in from a FCS file header). It lists the keywords and its values for a flowFrame specified by a character vector. Additional methods for function and lists exists for more programmatic access to the keywords.

Usage

keyword(object, keyword, ...)

Arguments

Details

The keyword methods allow access to the keywords stored in the FCS files, either for a flowFrame or for a list of frames in a flowSet . The most simple use case is to provide a character vector or a list of character strings of keyword names. A more sophisticated version is to provide a function which has to take one mandatory argument, the value of this is the flowFrame . This can be used to query arbitrary information from the flowFrames description slot or even the raw data. The function has to return a single character string. The list methods allow to combine functional and direct keyword access. The replacement method takes a named character vector or a named list as input. R's usual recycling rules apply when replacing keywords for a whole flowSet

Seealso

description

Author

N LeMeur,F Hahne,B Ellis

Examples

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

keyword(samp, "FCSversion")

keyword(samp, function(x,...) paste(keyword(x, "SAMPLE ID"), keyword(x,
"GUID"), sep="_"))

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

data(GvHD)
keyword(GvHD, list("GUID", cellnumber=function(x) nrow(x)))

keyword(GvHD) <- list(sample=sampleNames(GvHD))

Class "kmeansFilter"

Description

A filter that performs one-dimensional k-means (Lloyd-Max) clustering on a single flow parameter.

Usage

kmeansFilter(list(), filterId="defaultKmeansFilter")

Arguments

Details

The one-dimensional k-means filter is a multiple population filter capable of operating on a single flow parameter. It takes a parameter argument associated with two or more populations and results in the generation of an object of class multipleFilterResult . Populations are considered to be ordered such that the population with the smallest mean intensity will be the first population in the list and the population with the highest mean intensity will be the last population listed.

Value

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

Seealso

flowFrame , flowSet , filter for evaluation of kmeansFilters and split for splitting of flow cytometry data sets based on the result of the filtering operation.

Note

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

Author

F. Hahne, B. Ellis, N. LeMeur

Examples

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

## Create the filter
kf <- kmeansFilter("FSC-H"=c("Pop1","Pop2","Pop3"), filterId="myKmFilter")

## Filtering using kmeansFilters
fres <- filter(dat, kf)
fres
summary(fres)
names(fres)

## The result of quadGate filtering are multiple sub-populations
## and we can split our data set accordingly
split(dat, fres)

## We can limit the splitting to one or several sub-populations
split(dat, fres, population="Pop1")
split(dat, fres, population=list(keep=c("Pop1","Pop2")))

Create the definition of a linear transformation function to be applied on a data set

Description

Create the definition of the linear Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x <- a*x+b

Usage

linearTransform(transformationId="defaultLinearTransform", a = 1, b = 0)

Arguments

Value

Returns an object of class transform .

Seealso

transform-class , transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , lnTransform , logTransform , logicleTransform , quadraticTransform , scaleTransform , splitScaleTransform , truncateTransform

Author

N. LeMeur

Examples

samp <- read.FCS(system.file("extdata",
"0877408774.B08", package="flowCore"))
linearTrans <- linearTransform(transformationId="Linear-transformation", a=2, b=0)
dataTransform <- transform(samp, transformList('FSC-H' ,linearTrans))

Class lintGml2

Description

Linear transformation as parameterized in Gating-ML 2.0.

Details

lintGml2 is defined by the following function:

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

$$f(parameter, T, A) = (parameter + A) / (T + A)$$

This transformation provides a linear display that maps scale values from the $[-A, T]$ interval to the $[0, 1]$ interval. However, it is defined for all $x in R$ including outside of the $[-A, T]$ interval.

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.

Seealso

linearTransform , transform-class , transform

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

Note

The linear 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

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

Examples

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

Create the definition of a ln transformation function (natural logarthim) to be applied on a data set

Description

Create the definition of the ln Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x<-log(x)*(r/d). The transformation would normally be used to convert to a linear valued parameter to the natural logarithm scale. Typically r and d are both equal to 1.0. Both must be positive.

Usage

lnTransform(transformationId="defaultLnTransform", r=1, d=1)

Arguments

Value

Returns an object of class transform .

Seealso

transform-class , transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , logTransform , logicleTransform , quadraticTransform , scaleTransform , splitScaleTransform , truncateTransform

Author

B. Ellis and N. LeMeur

Examples

data(GvHD)
lnTrans <- lnTransform(transformationId="ln-transformation", r=1, d=1)
ln1 <- transform(GvHD, transformList('FSC-H', lnTrans))

opar = par(mfcol=c(2, 1))
plot(density(exprs(GvHD[[1]])[ ,1]), main="Original")
plot(density(exprs(ln1[[1]])[ ,1]), main="Ln Transform")

Create the definition of a log transformation function (base specified by user) to be applied on a data set

Description

Create the definition of the log Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x<-log(x,logbase)*(r/d). The transformation would normally be used to convert to a linear valued parameter to the natural logarithm scale. Typically r and d are both equal to 1.0. Both must be positive. logbase = 10 corresponds to base 10 logarithm.

Usage

logTransform(transformationId="defaultLogTransform", logbase=10, r=1, d=1)

Arguments

Value

Returns an object of class transform .

Seealso

transform-class , transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , lnTransform , logicleTransform , quadraticTransform , scaleTransform , splitScaleTransform , truncateTransform

Author

B. Ellis, N. LeMeur

Examples

samp <- read.FCS(system.file("extdata",
"0877408774.B08", package="flowCore"))
logTrans <- logTransform(transformationId="log10-transformation", logbase=10, r=1, d=1)
trans <- transformList('FSC-H', logTrans)
dataTransform <- transform(samp, trans)

Class "logarithm"

Description

Logartithmic transform class, which represents a transformation defined by the function

Details

$$f(parameter,a,b)= ln(aprarameter)b ~~~~a*parameter>0$$

$$0~~~~a*parameter<=0$$

Seealso

exponential, quadratic

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

Note

The logarithm 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

Gopalakrishnan N, F.Hahne

References

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

Examples

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

Class "logicalFilterResult"

Description

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

Seealso

filter

Author

B. Ellis

Examples

showClass("logicalFilterResult")

Computes a transform using the 'logicle_transform' function

Description

Logicle transformation creates a subset of biexponentialTransform hyperbolic sine transformation functions that provides several advantages over linear/log transformations for display of flow cytometry data. (The logicleTransform method makes use of the C++ implementation of the logicle transform contributed by Wayne Moore et al.)

Usage

logicleTransform(transformationId="defaultLogicleTransform", w = 0.5, t = 262144,
                 m = 4.5, a = 0)
                 estimateLogicle(x, channels,...)

Arguments

Seealso

inverseLogicleTransform , estimateLogicle

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , lnTransform , logTransform , quadraticTransform , scaleTransform , splitScaleTransform , truncateTransform

Author

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.

Examples

data(GvHD)
samp <- GvHD[[1]]
## User defined logicle function
lgcl <- logicleTransform( w = 0.5, t= 10000, m =4.5)
trans <- transformList(c("FL1-H", "FL2-H"), lgcl)
after <- transform(samp, trans)
invLgcl <- inverseLogicleTransform(trans = lgcl)
trans <- transformList(c("FL1-H", "FL2-H"), invLgcl)
before <- transform (after,  trans)

## Automatically estimate the logicle transformation based on the data
lgcl <- estimateLogicle(samp, channels = c("FL1-H", "FL2-H", "FL3-H", "FL2-A", "FL4-H"))
## transform  parameters using the estimated logicle transformation
after <- transform(samp, lgcl)

Class logicletGml2

Description

Logicle transformation as published by Moore and Parks.

Details

logicletGml2 is defined by the following function:

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

where $$logicle(x, T, W, M, A) = root(B(y, T, W, M, A) - x)$$ and $B$ is a modified biexponential function:

$$B(y, T, W, M, A) = ae^{by} - ce^{-dy} - 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 Logicle scale would cover in the plot range.

• W is non-negative and not greater than half of M and represents the number of such decades in the approximately linear region. The choice of $W = M/2$ specifies a scale that is essentially linear over the whole range except for a small region of large data values. For situations in which values of W approaching $M/2$ might be chosen, ordinary linear display scales will usually be more appropriate. The choice of $W = 0$ gives essentially the hyperbolic sine function.

• 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$ , $d$ and $f$ are defined by means of $T$ , $W$ , $M$ , $A$ , $w$ , $x0$ , $x1$ , $x2$ , $ca$ and $fa$ as:

and $d$ is a constant so that $$2(ln(d) - ln(b)) + w(d + b) = 0$$ given $b$ and $w$ , and

The Logicle scale is the inverse of a modified biexponential function. It provides a Logicle display that maps scale values onto the $[0,1]$ interval such that the data value $T$ is mapped to 1, large data values are mapped to locations similar to an (M + A)-decade logarithmic scale, and A decades of negative data are brought on scale. For implementation purposes, it is recommended to follow guidance in Moore and Parks publication.

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 logicle function be less than boundMin, then let the result of this transformation be boundMin. Analogically, should the result of the logicle 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.

Seealso

logicleTransform , transform-class , transform

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

Note

Please note that logicletGml2 and logicleTransform are similar transformations; however, the Gating-ML 2.0 compliant logicletGml2 brings "reasonable" data values to the scale of $[0,1]$ while the logicleTransform scales these values to $[0,M]$ .

The logicle 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

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

Moore, WA and Parks, DR. Update for the logicle data scale including operational code implementations. Cytometry A., 2012:81A(4):273-277.

Parks, DR and Roederer, M and Moore, WA. A new "Logicle" display method avoids deceptive effects of logarithmic scaling for low signals and compensated data. Cytometry A., 2006:69(6):541-551.

Examples

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

Class logtGml2

Description

Log transformation as parameterized in Gating-ML 2.0.

Details

logtGml2 is defined by the following function:

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

$$f(parameter, T, M) = (1/M) * log10(x/T) + 1$$

This transformation provides a logarithmic display that maps scale values from the $(0, T]$ interval to the $(-Inf, 1]$ interval such that the data value T is mapped to 1 and M decades of data are mapped into the interval. Also, the limit for x going to 0 is -Inf.

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.

Seealso

logTransform , transform-class , transform

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

Note

The log 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

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

Examples

myDataIn <- read.FCS(system.file("extdata", "0877408774.B08",
package="flowCore"))
myLogTr1 <- logtGml2(parameters = "FSC-H", T = 1023, M = 4.5,
transformationId="myLogTr1")
transOut <- eval(myLogTr1)(exprs(myDataIn))

Class "manyFilterResult"

Description

The result of a several related, but possibly overlapping filter results. The usual creator of this object will usually be a filter operation on a flowFrame object.

Seealso

filterResult

Author

B. Ellis

Examples

showClass("manyFilterResult")

get or update the marker names

Description

marker names corresponds to the 'desc' column of the phenoData of the flowFrame.

Usage

markernames(object, ...)
list(list("markernames"), list("flowFrame"))(object)
markernames(object) <- value
list(list("markernames"), list("flowFrame"))(object) <- value
list(list("markernames"), list("flowSet"))(object)
list(list("markernames"), list("flowSet"))(object) <- value

Arguments

Details

When extract marker names from a flowSet, it throws the warning if the marker names are not all the same across samples.

Value

marker names as a character vector. The marker names for FSC,SSC and Time channels are automatically excluded in the returned value. When object is a flowSet and the marker names are not consistent across flowFrames, it returns a list of unique marker sets.

Examples

data(GvHD)
fr <- GvHD[[1]]
markernames(fr)

chnls <- c("FL1-H", "FL3-H")
markers <- c("CD15", "CD14")
names(markers) <- chnls
markernames(fr) <- markers
markernames(fr)

fs <- GvHD[1:3]
markernames(fs)

Class "multipleFilterResult"

Description

Container to store the result of applying filter on set of flowFrame objects

Seealso

filterResult

Author

B. Ellis

Examples

showClass("multipleFilterResult")

Class "norm2Filter"

Description

Class and constructors for a filter that fits a bivariate normal distribution to a data set of paired values and selects data points according to their standard deviation from the fitted distribution.

Usage

norm2Filter(x, y, method="covMcd", scale.factor=1, n=50000,
filterId="defaultNorm2Filter")

Arguments

Details

The filter fits a bivariate normal distribution to the data and selects all events within the Mahalanobis distance multiplied by the scale.factor argument. The constructor norm2Filter is a convenience function for object instantiation. Evaluating a curv2Filter results in an object of class logicalFilterResult . Accordingly, norm2Filters can be used to subset and to split flow cytometry data sets.

Value

Returns a norm2Filter object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

cov.rob , CovMcd , filter for evaluation of norm2Filters and split and Subset for splitting and subsetting of flow cytometry data sets based on that.

Note

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

Author

F. Hahne

Examples

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

## Create directly. Most likely from a command line
norm2Filter("FSC-H", "SSC-H", filterId="myCurv2Filter")

## To facilitate programmatic construction we also have the following
n2f <- norm2Filter(filterId="myNorm2Filter", x=list("FSC-H", "SSC-H"),
scale.factor=2)
n2f <- norm2Filter(filterId="myNorm2Filter", x=c("FSC-H", "SSC-H"),
scale.factor=2)

## Filtering using norm2Filter
fres <- filter(dat, n2f)
fres
summary(fres)

## The result of norm2 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)

Class "normalization"

Description

Class and methods to normalize a a flowSet using a potentially complex normalization function.

Usage

normalization(parameters, normalizationId="defaultNormalization",
              normFunction, arguments=list())
normalize(data, x,...)

Arguments

Details

Data normalization of a flowSet is a rather fuzzy concept. The idea is to have a rather general function that takes a flowSet and a list of parameter names as input and applies any kind of normalization to the respective data columns. The output of the function has to be a flowSet again. Although we don't formally check for it, the dimensions of the input and of the output set should remain the same. Additional arguments may be passed to the normalization function via the arguments list. Internally we evaluate the function using do.call and one should check its documentation for details.

Currently, the most prominent example for a normalization function is warping, as provided by the flowStats package.

Value

A normalization object for the constructor.

A flowSet for the normalize methods.

Author

F. Hahne

Class "nullParameter"

Description

A class used internally for coercing transforms to characters for a return value when a coercion cannot be performed. The user should never need to interact with this class.

Class "parameterFilter"

Description

A concrete filter that acts on a set of parameters.

Author

B. Ellis

Class "parameterTransform"

Description

Link a transformation to particular flow parameters

Author

Byron Ellis

Class "parameters"

Description

A representation of flow parameters that allows for referencing.

Author

Nishant Gopalakrishnan

Obtain information about parameters for flow cytometry objects.

Description

Many different objects in flowCore are associated with one or more parameters. This includes filter , flowFrame and parameterFilter objects that all either describe or use parameters.

Usage

parameters(object, list())

Arguments

Value

When applied to a flowFrame object, the result is an AnnotatedDataFrame describing the parameters recorded by the cytometer. For other objects it will usually return a vector of names used by the object for its calculations.

Author

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

Examples

samp <- read.FCS(system.file("extdata","0877408774.B08", package="flowCore"))
parameters(samp)
print(samp@parameters@data)

Class "polygonGate"

Description

Class and constructor for 2-dimensional polygonal filter objects.

Usage

polygonGate(list(), .gate, boundaries, filterId="defaultPolygonGate")

Arguments

Details

Polygons are specified by the coordinates of their vertices in two dimensions. The constructor is designed to be useful in both direct and programmatic usage. It takes either a list or a named matrix with 2 columns and at least 3 rows containing these coordinates. Alternatively, vertices can be given as named arguments, in which case the function tries to convert the values into a matrix.

Value

Returns a polygonGate object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

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

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

Note

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

Author

F.Hahne, B. Ellis N. Le Meur

Examples

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

## Defining the gate
sqrcut <- matrix(c(300,300,600,600,50,300,300,50),ncol=2,nrow=4)
colnames(sqrcut) <- c("FSC-H","SSC-H")
pg <- polygonGate(filterId="nonDebris", boundaries= sqrcut)
pg

## Filtering using polygonGates
fres <- filter(dat, pg)
fres
summary(fres)

## The result of polygon 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)

Define filter boundaries

Description

Convenience methods to facilitate the construction of filter objects

Usage

polytopeGate(list(), .gate, b, filterId="defaultPolytopeGate")

Arguments

Details

These functions are designed to be useful in both direct and programmatic usage.

For rectangle gate in n dimensions, if n=1 the gate correspond to a range gate. If n=2, the gate is a rectangle gate. To use this function programmatically, you may either construct a list or you may construct a matrix with n columns and 2 rows. The first row corresponds to the minimal value for each parameter while the second row corresponds to the maximal value for each parameter. The names of the parameters are taken from the column names as in the third example.

Rectangle gate objects can also be multiplied together using the * operator, provided that both gate have orthogonal axes.

For polygon gate, the boundaries are specified as vertices in 2 dimensions, for polytope gate objects as vertices in n dimensions.

Polytope gate objects will represent the convex polytope determined by the vertices and parameter b which together specify the polytope as an intersection of half-spaces represented as a system of linear inequalities, $Axle b$

For quadrant gates, the boundaries are specified as a named list or vector of length two.

Value

Returns a rectangleGate or polygonGate object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

flowFrame , filter

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

Author

F.Hahne, B. Ellis N. Le Meur

Class "quadGate"

Description

Class and constructors for quadrant-type filter objects.

Usage

quadGate(list(), .gate, filterId="defaultQuadGate")

Arguments

Details

quadGates are defined by two parameters, which specify a separation of a two-dimensional parameter space into four quadrants. The quadGate function is designed to be useful in both direct and programmatic usage.

For the interactive use, these parameters can be given as additional named function arguments, where the names correspond to valid parameter names in a flowFrame or flowSet . For a more programmatic approach, a named list or numeric vector of the gate boundaries can be passed on to the function as argument .gate .

Evaluating a quadGate results in four sub-populations, and hence in an object of class multipleFilterResult . Accordingly, quadGates can be used to split flow cytometry data sets.

Value

Returns a quadGate object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

flowFrame , flowSet , filter for evaluation of quadGates and split for splitting of flow cytometry data sets based on that.

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

Note

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

Author

F.Hahne, B. Ellis N. Le Meur

Examples

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

## Create directly. Most likely from a command line
quadGate(filterId="myQuadGate1", "FSC-H"=100, "SSC-H"=400)

## To facilitate programmatic construction we also have the following
quadGate(filterId="myQuadGate2", list("FSC-H"=100, "SSC-H"=400))
## FIXME: Do we want this?
##quadGate(filterId="myQuadGate3", .gate=c("FSC-H"=100, "SSC-H"=400))

## Filtering using quadGates
qg <- quadGate(filterId="quad", "FSC-H"=600, "SSC-H"=400)
fres <- filter(dat, qg)
fres
summary(fres)
names(fres)

## The result of quadGate filtering are multiple sub-populations
## and we can split our data set accordingly
split(dat, fres)

## We can limit the splitting to one or several sub-populations
split(dat, fres, population="FSC-H-SSC-H-")
split(dat, fres, population=list(keep=c("FSC-H-SSC-H-",
"FSC-H-SSC-H+")))

Create the definition of a quadratic transformation function to be applied on a data set

Description

Create the definition of the quadratic Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x <- ax^2 + bx + c

Usage

quadraticTransform(transformationId="defaultQuadraticTransform", a = 1, b = 1, c = 0)

Arguments

Value

Returns an object of class transform .

Seealso

transform-class , transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , lnTransform , logTransform , logicleTransform , scaleTransform , splitScaleTransform , truncateTransform

Author

N. Le Meur

Examples

samp <- read.FCS(system.file("extdata",
"0877408774.B08", package="flowCore"))
quadTrans <- quadraticTransform(transformationId="Quadratic-transformation", a=1, b=1, c=0)
dataTransform <- transform(samp, transformList('FSC-H', quadTrans))

Class "quadratic"

Description

Quadratic transform class which represents a transformation defined by the function $$f(parameter,a)=a*parameter^2$$

Seealso

dg1polynomial,ratio,squareroot

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

Note

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

Author

Gopalakrishnan N, F.Hahne

References

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

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))
quad1<-quadratic(parameters="FSC-H",a=2,transformationId="quad1")
transOut<-eval(quad1)(exprs(dat))

Class "randomFilterResult"

Description

Container to store the result of applying a filter on a flowFrame object, with the population membership considered to be stochastic rather than absolute. Currently not utilized.

Seealso

filter

Author

B. Ellis

Class "ratio"

Description

ratio transform calculates the ratio of two parameters defined by the function $$f(parameter_1,parameter_2)=rac{parameter_1}{parameter_2}$$

Seealso

dg1polynomial,quadratic,squareroot

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

Note

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

Author

Gopalakrishnan N, F.Hahne

References

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

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))
rat1<-ratio("FSC-H","SSC-H",transformationId="rat1")
transOut<-eval(rat1)(exprs(dat))

Class "ratiotGml2"

Description

Ratio transformation as parameterized in Gating-ML 2.0.

Details

ratiotGml2 is defined by the following function:

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

$$f(p1, p2, A, B, C) = A * (p1 - B) / (p2 - C)$$

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.

Seealso

ratio , transform-class , transform

Other mathematical transform classes: EHtrans-class , 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 , sinht-class , splitscale-class , squareroot-class , unitytransform-class

Note

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

Author

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

Examples

myDataIn <- read.FCS(system.file("extdata", "0877408774.B08",
package="flowCore"))
myRatioT <- ratiotGml2("FSC-H", "SSC-H", pA = 2, pB = 3,
pC = -10, transformationId = "myRatioT")
transOut <- eval(myRatioT)(exprs(myDataIn))

Read an FCS file

Description

Check validity and Read Data File Standard for Flow Cytometry

Usage

isFCSfile(files)
read.FCS(filename, transformation="linearize", which.lines=NULL,
         alter.names=FALSE, column.pattern=NULL, invert.pattern = FALSE,
         decades=0, ncdf = FALSE, min.limit=NULL, 
         truncate_max_range = TRUE, dataset=NULL, emptyValue=TRUE, 
         channel_alias = NULL, ...)

Arguments

Details

The function isFCSfile determines whether its arguments are valid FCS files.

The function read.FCS works with the output of the FACS machine software from a number of vendors (FCS 2.0, FCS 3.0 and List Mode Data LMD). However, the FCS 3.0 standard includes some options that are not yet implemented in this function. If you need extensions, please let me know. The output of the function is an object of class flowFrame .

For specifications of FCS 3.0 see http://www.isac-net.org and the file ../doc/fcs3.html in the doc directory of the package.

The which.lines arguments allow you to read a subset of the record as you might not want to read the thousands of events recorded in the FCS file. It is mainly used when there is not enough memory to read one single FCS (which probably will not happen). It will probably take more time than reading the entire FCS (due to the multiple disk IO).

Value

isFCSfile returns a logical vector.

read.FCS returns an object of class flowFrame that contains the data in the exprs slot, the parameters monitored in the parameters slot and the keywords and value saved in the header of the FCS file.

Seealso

read.flowSet

Author

F. Hahne, N.Le Meur

Examples

## a sample file
fcsFile <- system.file("extdata", "0877408774.B08", package="flowCore")

## read file and linearize values
samp <-  read.FCS(fcsFile, transformation="linearize")
exprs(samp[1:3,])
description(samp)[3:6]
class(samp)

## Only read in lines 2 to 5
subset <- read.FCS(fcsFile, which.lines=2:5, transformation="linearize")
exprs(subset)

## Read in a random sample of 100 lines
subset <- read.FCS(fcsFile, which.lines=100, transformation="linearize")
nrow(subset)

#manually supply the alias vs channel options mapping as a data.frame
map <- data.frame(alias = c("A", "B")
, channels = c("FL2", "FL4")
)
fr <- read.FCS(fcsFile, channel_alias = map)
fr

Read the TEXT section of a FCS file

Description

Read (part of) the TEXT section of a Data File Standard for Flow Cytometry that contains FACS keywords.

Usage

read.FCSheader(files, path = ".", keyword = NULL, emptyValue = TRUE)

Arguments

Details

The function read.FCSheader works with the output of the FACS machine software from a number of vendors (FCS 2.0, FCS 3.0 and List Mode Data LMD). The output of the function is the TEXT section of the FCS files. The user can specify some keywords to limit the output to the information of interest.

Value

A list of character vectors. Each element of the list correspond to one FCS file.

Seealso

link[flowCore]{read.flowSet} , link[flowCore]{read.FCS}

Author

N.Le Meur

Examples

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

samp <- read.FCSheader(system.file("extdata",
"0877408774.B08", package="flowCore"), keyword=c("$DATE", "$FIL"))
samp

Read a set of FCS files

Description

Read one or several FCS files: Data File Standard for Flow Cytometry

Usage

read.flowSet(files=NULL, path=".", pattern=NULL, phenoData,
             descriptions,name.keyword, alter.names=FALSE,
             transformation = "linearize", which.lines=NULL,
             column.pattern = NULL, invert.pattern = FALSE, decades=0, sep="    ",
             as.is=TRUE, name, ncdf=FALSE, dataset=NULL, min.limit=NULL,
             truncate_max_range = TRUE, emptyValue=TRUE, 
             ignore.text.offset = FALSE, channel_alias = NULL, list())

Arguments

Details

There are four different ways to specify the file from which data is to be imported:

First, if the argument phenoData is present and is of class AnnotatedDataFrame , then the file names are obtained from its sample names (i.e. row names of the underlying data.frame). Also column name will be generated based on sample names if it is not there. This column is mainly used by visualization methods in flowViz. Alternatively, the argument phenoData can be of class character , in which case this function tries to read a AnnotatedDataFrame object from the file with that name by calling read.AnnotatedDataFrame .

In some cases the file names are not a reasonable selection criterion and the user might want to import files based on some keywords within the file. One or several keyword value pairs can be given as the phenoData argument in form of a named list.

Third, if the argument phenoData is not present and the argument files is not NULL , then files is expected to be a character vector with the file names.

Fourth, if neither the argument phenoData is present nor files is not NULL , then the file names are obtained by calling dir(path, pattern) .

Value

An object of class flowSet .

Author

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

Examples

fcs.loc <- system.file("extdata",package="flowCore")
file.location <- paste(fcs.loc, dir(fcs.loc), sep="/")

samp <- read.flowSet(file.location[1:3])

Class "rectangleGate"

Description

Class and constructor for n-dimensional rectangular filter objects.

Usage

rectangleGate(list(), .gate, filterId="defaultRectangleGate")

Arguments

Details

This class describes a rectangular region in n dimensions, which is a Cartesian product of n orthogonal intervals in these dimensions. n=1 corresponds to a range gate, n=2 to a rectangle gate, n=3 corresponds to a box region and n>3 to a hyper-rectangular regions. Intervals may be open on one side, in which case the value for the boundary is supposed to be Inf or -Inf , respectively. rectangleGates are inclusive, that means that events on the boundaries are considered to be in the gate.

The constructor is designed to be useful in both direct and programmatic usage. To use it programmatically, you may either construct a named list or you may construct a matrix with n columns and 2 rows. The first row corresponds to the minimal value for each parameter while the second row corresponds to the maximal value for each parameter. The names of the parameters are taken from the column names or from the list names, respectively. Alternatively, the boundaries of the rectangleGate can be given as additional named arguments, where each of these arguments should be a numeric vector of length 2 ; the function tries to collapse these boundary values into a matrix.

Note that boundaries of rectangleGates where min > max are syntactically valid, however when evaluated they will always be empty.

rectangleGate objects can also be multiplied using the * operator, provided that both gates have orthogonal axes. This results in higher-dimensional rectangleGates . The inverse operation of subsetting by parameter name(s) is also available.

Evaluating a rectangleGate generates an object of class logicalFilterResult . Accordingly, rectangleGates can be used to subset and to split flow cytometry data sets.

Value

Returns a rectangleGate object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

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

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

Note

See the documentation in the flowViz package for details on plotting of rectangleGates .

Author

F.Hahne, B. Ellis N. Le Meur

Examples

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

#Create directly. Most likely from a command line
rectangleGate(filterId="myRectGate", "FSC-H"=c(200, 600), "SSC-H"=c(0, 400))

#To facilitate programmatic construction we also have the following
rg <- rectangleGate(filterId="myRectGate", list("FSC-H"=c(200, 600),
"SSC-H"=c(0, 400)))
mat <- matrix(c(200, 600, 0, 400), ncol=2, dimnames=list(c("min", "max"),
c("FSC-H", "SSC-H")))
rg <- rectangleGate(filterId="myRectGate", .gate=mat)

## Filtering using rectangleGates
fres <- filter(dat, rg)
fres
summary(fres)

## The result of rectangle 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)

## Multiply rectangle gates
rg1 <- rectangleGate(filterId="FSC-", "FSC-H"=c(-Inf, 50))
rg2 <- rectangleGate(filterId="SSC+", "SSC-H"=c(50, Inf))
rg1 * rg2

## Subset rectangle gates
rg["FSC-H"]

##2d rectangleGate can be coerced to polygonGate
as(rg, "polygonGate")

Simplified geometric rotation of gates

Description

Rotate a Gate-type filter object through a specified angle

Usage

list(list("rotate_gate"), list("default"))(obj, deg = NULL, rot_center = NULL, ...)

Arguments

Details

This method allows for 2-dimensional geometric rotation of filter types defined by simple geometric gates ( ellipsoidGate , and polygonGate ). The method is not defined for rectangleGate or quadGate objects, due to their definition as having 1-dimensional boundaries. Further, keep in mind that the 2-dimensional rotation takes place in the plane where the dimensions of the two variables are evenly linearly scaled. Displaying a rotated ellipse in a plot where the axes are not scaled evenly may make it appear that the ellipse has been distorted even though this is not the case.

The angle provided in the deg argument should be in degrees rather than radians. By default, the rotation will be performed around the center of an ellipsoidGate or the centroid of the area encompassed by a polygonGate . The rot_center argument allows for specification of a different center of rotation for polygonGate objects (it is not yet implemented for ellipsoidGate objects) but it is usually simpler to perform a rotation and a translation individually than to manually specify the composition as a rotation around a shifted center.

Value

A Gate-type filter object of the same type as gate , with the rotation applied

Examples

#' # Rotates the original gate 15 degrees counter-clockwise
rotated_gate <- rotate_gate(original_gate, deg = 15)
# Rotates the original gate 270 degrees counter-clockwise
rotated_gate <- rotate_gate(original_gate, 270)

Class "sampleFilter"

Description

This non-parameter filter selects a number of events from the primary flowFrame .

Usage

sampleFilter(size, filterId="defaultSampleFilter")

Arguments

Details

Selects a number of events without replacement from a flowFrame .

Value

Returns a sampleFilter object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

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

Author

B. Ellis, F.Hahne

Examples

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

#Create the filter
sf <- sampleFilter(filterId="mySampleFilter", size=500)
sf

## Filtering using sampleFilters
fres <- filter(dat, sf)
fres
summary(fres)

## The result of sample 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)

Create the definition of a scale transformation function to be applied on a data set

Description

Create the definition of the scale Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x = (x-a)/(b-a). The transformation would normally be used to convert to a 0-1 scale. In this case, b would be the maximum possible value and a would be the minimum possible value.

Usage

scaleTransform(transformationId="defaultScaleTransform", a, b)

Arguments

Value

Returns an object of class transform .

Seealso

transform-class , transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , lnTransform , logTransform , logicleTransform , quadraticTransform , splitScaleTransform , truncateTransform

Author

P. Haaland

Examples

samp <- read.FCS(system.file("extdata",
"0877408774.B08", package="flowCore"))
scaleTrans <- scaleTransform(transformationId="Truncate-transformation", a=1, b=10^4)
dataTransform <- transform(samp, transformList('FSC-H', scaleTrans))

Simplified geometric scaling of gates

Description

Scale a Gate-type filter object in one or more dimensions

Usage

list(list("scale_gate"), list("default"))(obj, scale = NULL, ...)

Arguments

Details

This method allows uniform or non-uniform geometric scaling of filter types defined by simple geometric gates ( quadGate , rectangleGate , ellipsoidGate , and polygonGate ) Note that these methods are for manually altering the geometric definition of a gate. To easily transform the definition of a gate with an accompanyging scale transformation applied to its underlying data, see rescale_gate .

The scale argument passed to scale_gate should be either a scalar or a vector of the same length as the number of dimensions of the gate. If it is scalar, all dimensions will be multiplicatively scaled uniformly by the scalar factor provided. If it is a vector, each dimension will be scaled by its corresponding entry in the vector.

The scaling behavior of scale_gate depends on the type of gate passed to it. For rectangleGate and quadGate objects, this amounts to simply scaling the values of the 1-dimensional boundaries. For polygonGate objects, the values of scale will be used to determine scale factors in the direction of each of the 2 dimensions of the gate ( scale_gate is not yet defined for higher-dimensional polytopeGate objects). Important: For ellipsoidGate objects, scale determines scale factors for the major and minor axes of the ellipse, in that order . Scaling by a negative factor will result in a reflection in the corresponding dimension.

Value

A Gate-type filter object of the same type as gate , with the scaling applied

Examples

# Scales both dimensions by a factor of 5
scaled_gate <- scale_gate(original_gate, 5)

# Shrinks the gate in the first dimension by factor of 1/2
# and expands it in the other dimension by factor of 3
scaled_gate <- scale_gate(original_gate, c(0.5,3))

Class "setOperationFilter"

Description

This is a Superclass for the unionFilter, intersectFilter, complementFilter and subsetFilter classes, which all consist of two or more component filters | and are constructed using set operators ( & , | , ! , and| %&% or %subset% respectively).

Seealso

filter

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

Author

B. Ellis

Simplified geometric translation of gates

Description

Shift a Gate-type filter object in one or more dimensions

Usage

list(list("shift_gate"), list("default"))(obj, dx = NULL, dy = NULL,
  center = NULL, ...)

Arguments

Details

This method allows for geometric translation of filter types defined by simple geometric gates ( rectangleGate , quadGate , ellipsoidGate , or polygonGate ). The method provides two approaches to specify a translation. For rectangleGate objects, this will shift the min and max bounds by the same amount in each specified dimension. For quadGate objects, this will simply shift the divinding boundary in each dimension. For ellipsoidGate objects, this will shift the center (and therefore all points of the ellipse). For polgonGate objects, this will simply shift all of the points defining the polygon.

The method allows two different approaches to shifting a gate. Through the dx and/or dy arguments, a direct shift in each dimension can be provided. Alternatively, through the center argument, the gate can be directly moved to a new location in relation to the old center of the gate. For quadGate objects, this center is the intersection of the two dividing boundaries (so the value of the boundary slot). For rectangleGate objects, this is the center of the rectangle defined by the intersections of the centers of each interval. For ellipsoidGate objects, it is the center of the ellipsoid, given by the mean slot. For polygonGate objects, the centroid of the old polygon will be calculated and shifted to the new location provided by center and all other points on the polygon will be shifted by relation to the centroid.

Value

A Gate-type filter object of the same type as gate , with the translation applied

Examples

# Moves the entire gate +500 in its first dimension and 0 in its second dimension
shifted_gate <- shift_gate(original_gate, dx = 500)

#Moves the entire gate +250 in its first dimension and +700 in its second dimension
shifted_gate <- shift_gate(original_gate, dx = 500, dy = 700)

# Same as previous
shifted_gate <- shift_gate(original_gate, c(500,700))

# Move the gate based on shifting its center to (700, 1000)
shifted_gate <- shift_gate(original_gate, center = c(700, 1000))

Class "singleParameterTransform"

Description

A transformation that operates on a single parameter

Author

F Hahne

Examples

showClass("singleParameterTransform")

Class "sinht"

Description

Hyperbolic sin transform class, which represents a transformation defined by the function:

$$f(parameter,a,b)=sinh(parameter/b)/a$$

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

Seealso

asinht

Other mathematical transform classes: EHtrans-class , 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 , splitscale-class , squareroot-class , unitytransform-class

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

Gopalakrishnan N, F.Hahne

References

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

Examples

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

Compute a spillover matrix from a flowSet

Description

Spillover information for a particular experiment is often obtained by running several tubes of beads or cells stained with a single color that can then be used to determine a spillover matrix for use with compensate . list() list() When matching stain channels in x with the compensation controls, we provide a few options. If ordered , we assume the ordering of the channels in the flowSet object is the same as the ordering of the compensation-control samples. If regexpr , we use a regular expression to match the channel names with the names of each of the compensation control flowFrame s (that is, sampleNames(x) , which will typically be the filenames passed to read.FCS ). By default, we must "guess" based on the largest statistic for the compensation control (i.e., the row). list() list() Additionally, matching of channels to compensation control files can be accomplished using the spillover_match method, which allows the matches to be specified using a csv file. The flowSet returned by the spillover_match method should then be used as the x argument to spillover with prematched = TRUE .

Usage

list(list("spillover"), list("flowSet"))(x, unstained = NULL, fsc = "FSC-A", 
                              ssc = "SSC-A", patt = NULL, method = "median", 
                              stain_match = c("intensity", "ordered", "regexpr"),
                              useNormFilt=FALSE, prematched = FALSE)

Arguments

Details

The algorithm used is fairly simple. First, using the scatter parameters, we restrict ourselves to the most closely clustered population to reduce the amount of debris. The selected statistic is then calculated on all appropriate parameters and the unstained values swept out of the matrix. Every sample is then normalized to [0,1] with respect to the maximum value of the sample, giving the spillover in terms of a proportion of the primary channel intensity.

Value

A matrix for each of the parameters

Seealso

compensate , spillover_match

Author

B. Ellis, J. Wagner

References

C. B. Bagwell & E. G. Adams (1993). Fluorescence spectral overlap compensation for any number of flow cytometry parameters. in: Annals of the New York Academy of Sciences, 677:167-184.

Construct a flowSet for use with spillover by matching channel names to compensation control filenames

Description

Spillover information for a particular experiment is often obtained by running several tubes of beads or cells stained with a single color that can then be used to determine a spillover matrix for use with compensate . list() list() This method facilitates construction of a flowSet of compensation control flowFrame s using a simple file linking filenames to channels. This resulting flowSet can then be used with spillover using the option prematched = TRUE . list() list() Matching stain channels to compensation controls is done via a csv file ( matchfile ) with columns 'filename' and 'channel'. The 'channel' entries should exactly match the channel names in the FCS files. The 'filename' should be the FCS file name of each compensation control which should also be the corresponding sample name in the flowSet . There should also be one unstained control with the 'channel' entry of 'unstained'. list() list() The method also allows for x to be missing if path is provided, pointing to a directory containing the control FCS files. list() list()

Usage

list(list("spillover_match"), list("flowSet"))(x, fsc = "FSC-A", ssc = "SSC-A",
                                    matchfile = NULL, path)
list(list("spillover_match"), list("missing"))(x, fsc = "FSC-A", ssc = "SSC-A",
  matchfile, path)

Arguments

Value

A flowSet with the sample names of its flowFrames corresponding to the channels specified by the matchfile.

Seealso

compensate , spillover

Author

B. Ellis, J. Wagner

Compute the split-scale transformation describe by FL. Battye

Description

The split scale transformation described by Francis L. Battye [B15] (Figure 13) consists of a logarithmic scale at high values and a linear scale at low values with a fixed transition point chosen so that the slope (first derivative) of the transform is continuous at that point. The scale extends to the negative of the transition value that is reached at the bottom of the display.

Usage

splitScaleTransform(transformationId="defaultSplitscaleTransform",
                    maxValue=1023, transitionChannel=64, r=192)

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.

Seealso

transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , lnTransform , logTransform , logicleTransform , quadraticTransform , scaleTransform , truncateTransform

Author

N. LeMeur

References

Battye F.L. A Mathematically Simple Alternative to the Logarithmic Transform for Flow Cytometric Fluorescence Data Displays. http://www.wehi.edu.au/cytometry/Abstracts/AFCG05B.html.

Examples

data(GvHD)
ssTransform  <- splitScaleTransform("mySplitTransform")
after.1 <- transform(GvHD, transformList('FSC-H', ssTransform))

opar = par(mfcol=c(2, 1))
plot(density(exprs(GvHD[[1]])[, 1]), main="Original")
plot(density(exprs(after.1[[1]])[, 1]), main="Split-scale Transform")

Methods to split flowFrames and flowSets according to filters

Description

Divide a flow cytometry data set into several subset according to the results of a filtering operation. There are also methods available to split according to a factor variable.

Details

The splitting operation in the context of flowFrame s and flowSet s is the logical extension of subsetting. While the latter only returns the events contained within a gate, the former splits the data into the groups of events contained within and those not contained within a particular gate. This concept is extremely useful in applications where gates describe the distinction between positivity and negativity for a particular marker.

The flow data structures in flowCore can be split into subsets on various levels:

flowFrame : row-wise splitting of the raw data. In most cases, this will be done according to the outcome of a filtering operation, either using a filter that identifiers more than one sub-population or by a logical filter, in which case the data is split into two populations: "in the filter" and "not in the filter". In addition, the data can be split according to a factor (or a numeric or character vector that can be coerced into a factor).

flowSet : can be either split into subsets of flowFrame s according to a factor or a vector that can be coerced into a factor, or each individual flowFrame into subpopulations based on the filter s or filterResult s provided as a list of equal length.

Splitting has a special meaning for filters that result in multipleFilterResult s or manyFilterResult s, in which case simple subsetting doesn't make much sense (there are multiple populations that are defined by the gate and it is not clear which of those should be used for the subsetting operation). Accordingly, splitting of multipleFilterResults creates multiple subsets. The argument population can be used to limit the output to only one or some of the resulting subsets. It takes as values a character vector of names of the populations of interest. See the documentation of the different filter classes on how population names can be defined and the respective default values. For splitting of logicalFilterResult s, the population argument can be used to set the population names since there is no reasonable default other than the name of the gate. The content of the argument prefix will be prepended to the population names and '+' or '-' are finally appended allowing for more flexible naming schemes.

The default return value for any of the split methods is a list, but the optional logical argument flowSet can be used to return a flowSet instead. This only applies when splitting flowFrame s, splitting of flowSet s always results in lists of flowSet objects.

Author

F Hahne, B. Ellis, N. Le Meur

Examples

data(GvHD)
qGate <- quadGate(filterId="qg", "FSC-H"=200, "SSC-H"=400)

## split a flowFrame by a filter that creates
## a multipleFilterResult
samp <- GvHD[[1]]
fres <- filter(samp, qGate)
split(samp, qGate)

## return a flowSet rather than a list
split(samp, fres, flowSet=TRUE)

## only keep one population
names(fres)
##split(samp, fres, population="FSC-Height+SSC-Height+")


## split the whole set, only keep two populations
##split(GvHD, qGate, population=c("FSC-Height+SSC-Height+",
##"FSC-Height-SSC-Height+"))

## now split the flowSet according to a factor
split(GvHD, pData(GvHD)$Patient)

Class "splitscale"

Description

The split scale transformation class defines a transformation that has a logarithmic scale at high values and a linear scale at low values. The transition points are chosen so that the slope of the transformation is continuous at the transition points.

Details

The split scale transformation is defined by the function

$$f(parameter,r,maxValue,transitionChannel) = a*parameter+ b, parameter<=t$$

$$(parameter,r,maxValue,transitionChannel) = log_{10}(cparameter)rac{r}{d}, parameter > t$$ where,

$$b=rac{transitionChannel}{2}$$

$$d=rac{2log_{10}(e)r}{transitionChannel} + log_{10}(maxValue)$$

$$t=10^{log_{10}t}$$

$$a= rac{transitionChannel}{2*t}$$

$$log_{10}ct=rac{(at+b)d}{r}$$

$$c=10^{log_{10}ct}$$

Seealso

invsplitscale

Other mathematical transform classes: EHtrans-class , 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 , squareroot-class , unitytransform-class

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

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",package="flowCore"))
sp1<-splitscale("FSC-H",r=768,maxValue=10000,transitionChannel=256)
transOut<-eval(sp1)(exprs(dat))

Class "squareroot"

Description

Square root transform class, which represents a transformation defined by the function |$$f(parameter,a)= qrt{ |{rac{parameter}{a}|}}$$|

Seealso

dg1polynomial, ratio, quadratic

Other mathematical transform classes: EHtrans-class , 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 , unitytransform-class

Note

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

Author

Gopalakrishnan N, F.Hahne

References

Gating-ML Candidate Recommendation for Gating Description in Flow Cytometry

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))
sqrt1<-squareroot(parameters="FSC-H",a=2,transformationId="sqrt1")
transOut<-eval(sqrt1)(exprs(dat))

Class subsetFilter

Description

This class represents the action of applying a filter on the subset of data resulting from another filter. This is itself a filter that can be incorporated in to further set operations. This is similar to an intersectFilter, with behavior only differing if the component filters are data-driven.

Details

subsetFilter s are constructed using the equivalent binary set operators "%&%" or "%subset%" . The operator is not symmetric, as the filter on the right-hand side will take the subset of the filter on the left-hand side as input. Left-hand side operands can be a filter or list of filters, while the right-hand side operand must be a single filter.

Seealso

filter , setOperationFilter

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

Author

B. Ellis

Methods for function summarizeFilter

Description

Internal methods to populate the filterDetails slot of a filterResult object.

Usage

summarizeFilter(result, filter)

Arguments

Class "timeFilter"

Description

Define a filter that removes stretches of unusual data distribution within a single parameter over time. This can be used to correct for problems during data acquisition like air bubbles or clods.

Usage

timeFilter(..., bandwidth=0.75, binSize, timeParameter,
filterId="defaultTimeFilter")

Arguments

Details

Clods and disturbances in the laminar flow of a FACS instrument can cause temporal aberrations in the data acquisition that lead to artifactual values. timeFilters try to identify such stretches of disturbance by computing local variance and location estimates and to remove them from the data.

Value

Returns a timeFilter object for use in filtering flowFrame s or other flow cytometry objects.

Seealso

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

Note

See the documentation of timeLinePlot in the flowViz package for details on visualizing temporal problems in flow cytometry data.

Author

Florian Hahne

Examples

## Loading example data
data(GvHD)
dat <- GvHD[1:10]

## create the filter
tf <- timeFilter("SSC-H", bandwidth=1, filterId="myTimeFilter")
tf

## Visualize problems
library(flowViz)
timeLinePlot(dat, "SSC-H")

## Filtering using timeFilters
fres <- filter(dat, tf)
fres[[1]]
summary(fres[[1]])
summary(fres[[7]])

## The result of rectangle filtering is a logical subset
cleanDat <- Subset(dat, fres)

## Visualizing after cleaning up
timeLinePlot(cleanDat, "SSC-H")

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

par(mfcol=c(1,3))
plot(exprs(dat[[7]])[, "SSC-H"], pch=".")
plot(exprs(cleanDat[[7]])[, "SSC-H"], pch=".")
plot(exprs(allDat[[2]])[, "SSC-H"], pch=".")

A class for encapsulating a filter to be performed on transformed parameters

Description

The transformFilter class is a mechanism for including one or more variable transformations into the filtering process. Using a special case of transform we can introduce transformations inline with the filtering process eliminating the need to process flowFrame objects before applying a filter.

Seealso

" , " , transform

Author

B. Ellis

Examples

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

## Gate this object after log transforming the forward and side
## scatter variables
filter(samp, norm2Filter("FSC-H", "SSC-H", scale.factor=2)
%on% transform("FSC-H"=log,"SSC-H"=log))

Class "transformList"

Description

A list of transformMaps to be applied to a list of parameters.

Usage

transformList(from, tfun, to=from, transformationId =
"defaultTransformation")

Arguments

Seealso

transform , transformMap

Author

B. Ellis, F. Hahne

Examples

tl <- transformList(c("FSC-H", "SSC-H"), list(log, asinh))
colnames(tl)
c(tl, transformList("FL1-H", "linearTransform"))
data(GvHD)
transform(GvHD[[1]], tl)

A class for mapping transforms between parameters

Description

This class provides a mapping between parameters and transformed parameters via a function.

Seealso

transform , transformList

Author

B. Ellis, F. Hahne

Examples

new("transformMap", input="FSC-H", output="FSC-H", f=log)

Class "transformReference"

Description

Class allowing for reference of transforms, for instance as parameters.

Author

N. Gopalakrishnan

'transform': a class for transforming flow-cytometry data by applying scale factors.

Description

Transform objects are simply functions that have been extended to allow for specialized dispatch. All of the `...Transform'' constructors return functions of this type for use in one of the transformation modalities. ## Seealso [linearTransform](#lineartransform) , [lnTransform](#lntransform) , [logicleTransform](#logicletransform) , [biexponentialTransform](#biexponentialtransform) , [arcsinhTransform](#arcsinhtransform) , [quadraticTransform](#quadratictransform) , [logTransform`](#logtransform) ## Author N LeMeur ## Examples r cosTransform <- function(transformId, a=1, b=1){ t = new("transform", .Data = function(x) cos(a*x+b)) t@transformationId = transformId t } cosT <- cosTransform(transformId="CosT",a=2,b=1) summary(cosT)

Simplified geometric transformation of gates

Description

Perform geometric transformations of Gate-type filter objects

Usage

list(list("transform_gate"), list("default"))(obj, scale = NULL, deg = NULL,
  rot_center = NULL, dx = NULL, dy = NULL, center = NULL, ...)

Arguments

Details

This method allows changes to the four filter types defined by simple geometric gates ( quadGate , rectangleGate , ellipsoidGate , and polygonGate ) using equally simple geometric transformations (shifting/translation, scaling/dilation, and rotation). The method also allows for directly re-setting the slots of each Gate-type object. Note that these methods are for manually altering the geometric definition of a gate. To easily transform the definition of a gate with an accompanyging scale transformation applied to its underlying data, see rescale_gate .

First, transform_gate will apply any direct alterations to the slots of the supplied Gate-type filter object. For example, if " mean = c(1,3) " is present in the argument list when transform_gate is called on a ellipsoidGate object, the first change applied will be to shift the mean slot to (1,3) . The method will carry over the dimension names from the gate, so there is no need to provide column or row names with arguments such as mean or cov for ellipsoidGate or boundaries for polygonGate .

transform_gate then passes the geometric arguments ( dx , dy , deg , rot_center , scale , and center ) to the methods which perform each respective type of transformation: shift_gate , scale_gate , or rotate_gate . The order of operations is to first scale, then rotate, then shift. The default behavior of each operation follows that of its corresponding method but for the most part these are what the user would expect. A few quick notes:

• rotate_gate is not defined for rectangleGate or quadGate objects, due to their definition as having 1-dimensional boundaries.

• The default center for both rotation and scaling of a polygonGate is the centroid of the polygon. This results in the sort of scaling most users expect, with a uniform scale factor not distorting the shape of the original polygon.

Value

A Gate-type filter object of the same type as gate , with the geometric transformations applied

Examples

# Scale the original gate non-uniformly, rotate it 15 degrees, and shift it
transformed_gate <- transform_gate(original_gate, scale = c(2,3), deg = 15, dx = 500, dy = -700)

# Scale the original gate (in this case an ellipsoidGate) after moving its center to (1500, 2000)
transformed_gate <- transform_gate(original_gate, scale = c(2,3), mean = c(1500, 2000))

Class "transformation"

Description

A virtual class to abstract transformations.

Author

N. Gopalakrishnan

Create the definition of a truncate transformation function to be applied on a data set

Description

Create the definition of the truncate Transformation that will be applied on some parameter via the transform method. The definition of this function is currently x[x<a] <- a. Hence, all values less than a are replaced by a. The typical use would be to replace all values less than 1 by 1.

Usage

truncateTransform(transformationId="defaultTruncateTransform", a=1)

Arguments

Value

Returns an object of class transform .

Seealso

transform-class , transform

Other Transform functions: arcsinhTransform , biexponentialTransform , inverseLogicleTransform , linearTransform , lnTransform , logTransform , logicleTransform , quadraticTransform , scaleTransform , splitScaleTransform

Author

P. Haaland

Examples

samp <- read.FCS(system.file("extdata",
"0877408774.B08", package="flowCore"))
truncateTrans <- truncateTransform(transformationId="Truncate-transformation", a=5)
dataTransform <- transform(samp,transformList('FSC-H', truncateTrans))

Class unionFilter

Description

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

Seealso

filter , setOperationFilter

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

Author

B. Ellis

Class "unitytransform"

Description

Unity transform class transforms parameters names provided as characters into unity transform objects which can be evaluated to retrieve the corresponding columns from the data frame

Seealso

dg1polynomial, ratio

Other mathematical transform classes: EHtrans-class , 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

Author

Gopalakrishnan N, F.Hahne

Examples

dat <- read.FCS(system.file("extdata","0877408774.B08",
package="flowCore"))
un1<-unitytransform(c("FSC-H","SSC-H"),transformationId="un1")
transOut<-eval(un1)(exprs(dat))

modify description to reflect the transformation Involve inserting/updating 'transformation' and flowCore_$PnRmax keywords

Description

modify description to reflect the transformation Involve inserting/updating 'transformation' and flowCore_$PnRmax keywords

Usage

updateTransformKeywords(fr)

Arguments

Value

updated description slot

Check if all filters in a filters matches same paramters

Description

Check if all filters in a filters matches same paramters

Usage

validFilters(flist)

Arguments

Value

TRUE or FALSE

Write an FCS file

Description

Write FCS file from a flowFrame

Usage

|write.FCS(x, filename, what="numeric", delimiter = "|", endian="big")|

Arguments

|delimiter | a single character to separate the FCS keyword/value pairs. Default is : "|"| |endian | a character, either "little" or "big" (default), specifying the most significant or least significant byte is stored first in a 32 bit word.|

Details

The function write.FCS creates FCS 3.0 standard file from an object of class flowFrame .

For specifications of FCS 3.0 see http://www.isac-net.org and the file ../doc/fcs3.html in the doc directory of the package.

Value

A character vector of the file name.

Seealso

link[flowCore]{write.flowSet}

Author

F. Hahne

Examples

## a sample file
inFile <- system.file("extdata", "0877408774.B08", package="flowCore")
foo <- read.FCS(inFile, transform=FALSE)
outFile <- file.path(tempdir(), "foo.fcs")

## now write out into a file
write.FCS(foo, outFile)
bar <- read.FCS(outFile, transform=FALSE)
all(exprs(foo) == exprs(bar))

Write an FCS file

Description

Write FCS file for each flowFrame in a flowSet

Usage

write.flowSet(x, outdir=identifier(x), filename, list())

Arguments