org.fhcrc.cpl.toolbox.proteomics.feature
Class FeatureGrouper

java.lang.Object
  org.fhcrc.cpl.toolbox.proteomics.feature.FeatureGrouper

public class FeatureGrouper
extends java.lang.Object

Uses clustering (Clusterer2D) to align multiple feature sets

Field Summary

protected int	_conflictResolver
protected FeatureClusterer	_featureClusterer
protected boolean	_useMassInsteadOfMz
static int	BUCKET_EVALUATION_MODE_ONE_FROM_EACH
static int	BUCKET_EVALUATION_MODE_PEPTIDE_AGREEMENT
protected int	bucketEvaluationPeptideAgreementMatchScore
protected double	bucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple
protected double	bucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple
protected int	bucketEvaluationPeptideAgreementMismatchPenalty
static int	CONFLICT_RESOLVER_BEST
static int	CONFLICT_RESOLVER_SUM
static int	DEFAULT_CONFLICT_RESOLVER
static int	DEFAULT_PEPTIDE_AGREEMENT_MATCH_SCORE
static int	DEFAULT_PEPTIDE_AGREEMENT_MISMATCH_PENALTY

Constructor Summary

FeatureGrouper()
Initialize the clusterer

FeatureGrouper(FeatureSet fs, boolean useMassForMz)
Initialize, set usemassformz, add a featureset

Method Summary

void	addSet(FeatureSet fs)
protected java.lang.String	buildFeatureSetColumnSuffix(FeatureSet featureSet, int featureSetNumber) build the column suffix for this featureset.
Pair<java.lang.Double,java.lang.Integer>	calculateBestBuckets(double[] massOrMzBuckets, int[] scanBuckets) By default, simply evaluate the bucket settings based on the number of rows with exactly one feature from each bucket
Pair<java.lang.Double,java.lang.Integer>	calculateBestBuckets(double[] massOrMzBuckets, int[] scanBuckets, int bucketEvaluationMode)
protected static java.lang.String	createArrayRow(Clusterer2D.BucketSummary summary, java.util.List<Feature>[] bucketFeatures, float[] bucketIntensities, boolean writePeptidesAndProteins, boolean writeMultipleFeatures) Create a single row for a peptide array.
FeatureSet[]	filterByGroupedAlignment(int minAligned) Filter each FeatureSet to include only those features that align across at least minAligned sets.
int	getBucketEvaluationPeptideAgreementMatchScore()
double	getBucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple()
double	getBucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple()
int	getBucketEvaluationPeptideAgreementMismatchPenalty()
int	getConflictResolver()
int	getElutionMode()
static Feature[]	getFeatures(Clusterer2D.BucketSummary bucketSummary)
static java.util.List<Feature>	getFeaturesFromSet(int setIndex, Clusterer2D.BucketSummary bucketSummary)
boolean	getGroupByMass()
int	getMassType()
FeatureSet	getSet(int i)
int	numBuckets()
static java.util.List<Feature>[]	orderClusterFeatures(Clusterer2D.BucketSummary cluster, FeatureSet[] featureSetArray, int conflictResolver) Resolve conflicts between features in a cluster by ordering them along some metric Result is a list of Features in descending order of goodness
static java.util.List<Feature>[]	orderClusterFeatures(Clusterer2D.BucketSummary cluster, java.util.List<FeatureSet> featureSets, int conflictResolver) Cover method
int	rowsWithOneFromEach()
void	setBucketEvaluationPeptideAgreementMatchScore(int bucketEvaluationPeptideAgreementMatchScore)
void	setBucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple(double bucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple)
void	setBucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple(double bucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple)
void	setBucketEvaluationPeptideAgreementMismatchPenalty(int bucketEvaluationPeptideAgreementMismatchPenalty)
void	setConflictResolver(int conflictResolver)
void	setElutionMode(int _elutionMode)
void	setGroupByMass(boolean groupByMass)
void	setMassType(int _massType)
void	split2D(double dimension1Bucket, double dimension2Bucket) Split based on a set of bucket sizes.
Clusterer2D.BucketSummary[]	summarize()
void	writeArrayDetails(java.io.PrintWriter writer, boolean unDeconvolute, boolean writeMS2) Write out all feature details (except peptide, protein)
protected void	writeDetailsFeatureRow(java.io.PrintWriter writer, int rowId, java.lang.String setName, Feature feature, FeatureExtraInformationDef[] extraInfos) Helper method to write a single row in a details file representing one feature
void	writePeptideArray(java.io.PrintWriter writer) Old school entry point; never does normalization
void	writePeptideArray(java.io.PrintWriter writer, boolean normalize) by default, don't sum intensities
void	writePeptideArray(java.io.PrintWriter writer, boolean normalize, boolean sumIntensities) Write out a peptide array.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

_featureClusterer

protected FeatureClusterer _featureClusterer

_useMassInsteadOfMz

protected boolean _useMassInsteadOfMz

_conflictResolver

protected int _conflictResolver

BUCKET_EVALUATION_MODE_ONE_FROM_EACH

public static final int BUCKET_EVALUATION_MODE_ONE_FROM_EACH

See Also:

Constant Field Values

BUCKET_EVALUATION_MODE_PEPTIDE_AGREEMENT

public static final int BUCKET_EVALUATION_MODE_PEPTIDE_AGREEMENT

See Also:

Constant Field Values

bucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple

protected double bucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple

bucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple

protected double bucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple

bucketEvaluationPeptideAgreementMatchScore

protected int bucketEvaluationPeptideAgreementMatchScore

bucketEvaluationPeptideAgreementMismatchPenalty

protected int bucketEvaluationPeptideAgreementMismatchPenalty

DEFAULT_PEPTIDE_AGREEMENT_MATCH_SCORE

public static final int DEFAULT_PEPTIDE_AGREEMENT_MATCH_SCORE

See Also:

Constant Field Values

DEFAULT_PEPTIDE_AGREEMENT_MISMATCH_PENALTY

public static final int DEFAULT_PEPTIDE_AGREEMENT_MISMATCH_PENALTY

See Also:

Constant Field Values

CONFLICT_RESOLVER_SUM

public static final int CONFLICT_RESOLVER_SUM

See Also:

Constant Field Values

CONFLICT_RESOLVER_BEST

public static final int CONFLICT_RESOLVER_BEST

See Also:

Constant Field Values

DEFAULT_CONFLICT_RESOLVER

public static final int DEFAULT_CONFLICT_RESOLVER

See Also:

Constant Field Values

Constructor Detail

FeatureGrouper

public FeatureGrouper()

Initialize the clusterer

FeatureGrouper

public FeatureGrouper(FeatureSet fs,
                      boolean useMassForMz)

Initialize, set usemassformz, add a featureset

Parameters:

fs -

useMassForMz -

Method Detail

calculateBestBuckets

public Pair<java.lang.Double,java.lang.Integer> calculateBestBuckets(double[] massOrMzBuckets,
                                                                     int[] scanBuckets)

By default, simply evaluate the bucket settings based on the number of rows with exactly one feature from each bucket

Parameters:

massOrMzBuckets -

scanBuckets -

Returns:

calculateBestBuckets

public Pair<java.lang.Double,java.lang.Integer> calculateBestBuckets(double[] massOrMzBuckets,
                                                                     int[] scanBuckets,
                                                                     int bucketEvaluationMode)

writePeptideArray

public void writePeptideArray(java.io.PrintWriter writer)

Old school entry point; never does normalization

writePeptideArray

public void writePeptideArray(java.io.PrintWriter writer,
                              boolean normalize)

by default, don't sum intensities

Parameters:

writer -

normalize -

getFeatures

public static Feature[] getFeatures(Clusterer2D.BucketSummary bucketSummary)

getFeaturesFromSet

public static java.util.List<Feature> getFeaturesFromSet(int setIndex,
                                                         Clusterer2D.BucketSummary bucketSummary)

writePeptideArray

public void writePeptideArray(java.io.PrintWriter writer,
                              boolean normalize,
                              boolean sumIntensities)

Write out a peptide array. Optionally normalize. If sumIntensities is true, all intensities from a given FeatureSet in the bucket will be summed. Otherwise, the intensity included will be from the feature that was picked to represent the bucket

Parameters:

writer -

normalize -

buildFeatureSetColumnSuffix

protected java.lang.String buildFeatureSetColumnSuffix(FeatureSet featureSet,
                                                       int featureSetNumber)

build the column suffix for this featureset. Separating this to make it easy to find and mess with.

Parameters:

featureSet -

Returns:

filterByGroupedAlignment

public FeatureSet[] filterByGroupedAlignment(int minAligned)

Filter each FeatureSet to include only those features that align across at least minAligned sets. Intended for use when runs are grouped by some tag (e.g. "case" or "control")

orderClusterFeatures

public static java.util.List<Feature>[] orderClusterFeatures(Clusterer2D.BucketSummary cluster,
                                                             java.util.List<FeatureSet> featureSets,
                                                             int conflictResolver)

Cover method

Parameters:

cluster -

featureSets -

conflictResolver -

Returns:

orderClusterFeatures

public static java.util.List<Feature>[] orderClusterFeatures(Clusterer2D.BucketSummary cluster,
                                                             FeatureSet[] featureSetArray,
                                                             int conflictResolver)

Resolve conflicts between features in a cluster by ordering them along some metric Result is a list of Features in descending order of goodness

Parameters:

cluster -

conflictResolver -

Returns:

an array of Features, one representing each FeatureSet from featureSets if at least one feature from that FeatureSet was present.

summarize

public Clusterer2D.BucketSummary[] summarize()

createArrayRow

protected static java.lang.String createArrayRow(Clusterer2D.BucketSummary summary,
                                                 java.util.List<Feature>[] bucketFeatures,
                                                 float[] bucketIntensities,
                                                 boolean writePeptidesAndProteins,
                                                 boolean writeMultipleFeatures)

Create a single row for a peptide array.

Parameters:

summary -

bucketFeatures -

bucketIntensities -

Returns:

writeArrayDetails

public void writeArrayDetails(java.io.PrintWriter writer,
                              boolean unDeconvolute,
                              boolean writeMS2)

Write out all feature details (except peptide, protein)

Parameters:

writer -

unDeconvolute - if false, writes out deconvoluted features. If true, writes the original, un-deconvoluted features

writeDetailsFeatureRow

protected void writeDetailsFeatureRow(java.io.PrintWriter writer,
                                      int rowId,
                                      java.lang.String setName,
                                      Feature feature,
                                      FeatureExtraInformationDef[] extraInfos)

Helper method to write a single row in a details file representing one feature

Parameters:

writer -

rowId -

setName -

feature -

split2D

public void split2D(double dimension1Bucket,
                    double dimension2Bucket)

Split based on a set of bucket sizes. Just passes the command along to the clusterer

Parameters:

dimension1Bucket -

dimension2Bucket -

numBuckets

public int numBuckets()

rowsWithOneFromEach

public int rowsWithOneFromEach()

getGroupByMass

public boolean getGroupByMass()

setGroupByMass

public void setGroupByMass(boolean groupByMass)

addSet

public void addSet(FeatureSet fs)

getSet

public FeatureSet getSet(int i)

getConflictResolver

public int getConflictResolver()

setConflictResolver

public void setConflictResolver(int conflictResolver)

getBucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple

public double getBucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple()

setBucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple

public void setBucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple(double bucketEvaluationPeptideAgreementMinAlignedNumSetsMultiple)

getBucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple

public double getBucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple()

setBucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple

public void setBucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple(double bucketEvaluationPeptideAgreementMinPeptideIdsNumSetsMultiple)

getBucketEvaluationPeptideAgreementMatchScore

public int getBucketEvaluationPeptideAgreementMatchScore()

setBucketEvaluationPeptideAgreementMatchScore

public void setBucketEvaluationPeptideAgreementMatchScore(int bucketEvaluationPeptideAgreementMatchScore)

getBucketEvaluationPeptideAgreementMismatchPenalty

public int getBucketEvaluationPeptideAgreementMismatchPenalty()

setBucketEvaluationPeptideAgreementMismatchPenalty

public void setBucketEvaluationPeptideAgreementMismatchPenalty(int bucketEvaluationPeptideAgreementMismatchPenalty)

getMassType

public int getMassType()

setMassType

public void setMassType(int _massType)

getElutionMode

public int getElutionMode()

setElutionMode

public void setElutionMode(int _elutionMode)