private UMCLight GetUMC(LcMsFeature lcmsFeature)
{
UMCLight umc;
if (lcmsFeature.FeatureId == 0)
{ // Promex clusterer added a new noise feature (filled in missing data for a cluster.
umc = new UMCLight
{
GroupId = lcmsFeature.DataSetId,
Id = ++this.maxFeatureId,
Abundance = lcmsFeature.Abundance,
AbundanceSum = lcmsFeature.Abundance,
Net = (lcmsFeature.MinNet + lcmsFeature.MaxNet) / 2,
NetStart = lcmsFeature.MinNet,
NetEnd = lcmsFeature.MaxNet,
ChargeState = (lcmsFeature.MinCharge + lcmsFeature.MaxCharge) / 2,
MinCharge = lcmsFeature.MinCharge,
MaxCharge = lcmsFeature.MaxCharge,
MassMonoisotopic = lcmsFeature.Mass,
MassMonoisotopicAligned = lcmsFeature.Mass,
};
}
else
{ // Clustered existing feature.
var key = new Tuple <int, int>(this.promexToMultiAlignDatasetIdMap[lcmsFeature.DataSetId], lcmsFeature.FeatureId);
umc = this.featureMap[key];
}
return(umc);
}
/*
* public static List<LcMsFeature> LoadProMexResult(string featureFilePath)
* {
* return LoadProMexResult(0, featureFilePath);
* }
*/
public static List <LcMsFeature> LoadProMexResult(int dataId, string featureFilePath, LcMsRun run, double minMass = 2000, double maxMass = 50000)
{
var featureList = new List <LcMsFeature>();
var tsvReader = new TsvFileParser(featureFilePath);
//var run = (rawFilePath == null || !File.Exists(rawFilePath)) ? null : PbfLcMsRun.GetLcMsRun(rawFilePath);
var featureIds = tsvReader.GetData("FeatureID");
var minScans = tsvReader.GetData("MinScan");
var maxScans = tsvReader.GetData("MaxScan");
var abu = tsvReader.GetData("Abundance");
var minCharges = tsvReader.GetData("MinCharge");
var maxCharges = tsvReader.GetData("MaxCharge");
var monoMass = tsvReader.GetData("MonoMass");
var minElutionTime = tsvReader.GetData("MinElutionTime");
var maxElutionTime = tsvReader.GetData("MaxElutionTime");
var repCharges = tsvReader.GetData("RepCharge");
var repScans = tsvReader.GetData("RepScan");
var repMzs = tsvReader.GetData("RepMz");
var scores = tsvReader.GetData("LikelihoodRatio");
for (var i = 0; i < tsvReader.NumData; i++)
{
var abundance = double.Parse(abu[i]);
var repMass = double.Parse(monoMass[i]);
if (repMass < minMass || repMass > maxMass)
{
continue;
}
var minCharge = int.Parse(minCharges[i]);
var maxCharge = int.Parse(maxCharges[i]);
var minScan = int.Parse(minScans[i]);
var maxScan = int.Parse(maxScans[i]);
var fid = int.Parse(featureIds[i]);
var repCharge = (repCharges != null) ? int.Parse(repCharges[i]) : (int)Math.Round(0.5 * (minCharge + maxCharge));
var repMz = (repMzs != null) ? double.Parse(repMzs[i]) : (repMass / repCharge) + Constants.Proton;
var repScanNum = (repScans != null) ? int.Parse(repScans[i]) : minScan;
var score = (scores != null) ? double.Parse(scores[i]) : 0;
var minEt = double.Parse(minElutionTime[i]);
var maxEt = double.Parse(maxElutionTime[i]);
var minNet = minEt / run.GetElutionTime(run.MaxLcScan);
var maxNet = maxEt / run.GetElutionTime(run.MaxLcScan);
var feature = new LcMsFeature(repMass, repCharge, repMz, repScanNum, abundance, minCharge, maxCharge, minScan, maxScan, minEt, maxEt, minNet, maxNet)
{
FeatureId = fid,
DataSetId = dataId,
Score = score,
};
featureList.Add(feature);
}
return(featureList);
}
private double NetDiff(LcMsFeature f1, LcMsFeature f2)
{
var n1 = Math.Abs(f1.Net - f2.Net);
return(n1);
//var n2 = Math.Abs(f1.MinNet - f2.MinNet);
//var n3 = Math.Abs(f1.MaxNet - f2.MaxNet);
//return Math.Min(Math.Min(n1, n2), n3);
}
private List <LcMsFeature[]> GroupFeatures(List <LcMsFeature> features)
{
var adjList = new List <int> [features.Count];
for (var i = 0; i < features.Count; i++)
{
adjList[i] = new List <int>();
}
for (var i = 0; i < features.Count; i++)
{
var fi = features[i];
for (var j = i + 1; j < features.Count; j++)
{
var fj = features[j];
if (fj.Mass - fi.Mass > 1.5)
{
break;
}
if (_featureCompare.SameCluster(fi, fj))
{
adjList[i].Add(j);
adjList[j].Add(i);
}
}
}
var ret = new List <LcMsFeature[]>();
var components = GetConnectedComponents(adjList);
for (var i = 0; i < components.Count; i++)
{
var component = new HashSet <int>(components[i]);
while (component.Count > 0)
{
var featureGroup = new LcMsFeature[CountDatasets];
var featureSet = GetAlignedFeatures(ref component, adjList);
foreach (var f in featureSet)
{
featureGroup[f.DataSetId] = f;
}
ret.Add(featureGroup);
}
}
return(ret);
}
/// <summary>
/// Converts a <see cref="LcMsFeature"/> to a <see cref="Ms1FtEntry"/>
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public static Ms1FtEntry ToMs1FtEntry(this LcMsFeature feature, int featureId = 0)
{
var ms1FtEntry = new Ms1FtEntry
{
FeatureId = featureId,
MinScan = feature.MinScanNum,
MaxScan = feature.MaxScanNum,
MinCharge = feature.MinCharge,
MaxCharge = feature.MaxCharge,
MonoMass = feature.RepresentativeMass,
RepresentativeScan = feature.RepresentativeScanNum,
RepresentativeCharge = feature.RepresentativeCharge,
RepresentativeMz = feature.RepresentativeMz,
Abundance = feature.Abundance,
MinElutionTime = feature.MinElutionTime,
MaxElutionTime = feature.MaxElutionTime,
ElutionLength = feature.ElutionLength,
LikelihoodRatio = feature.Score
};
return(ms1FtEntry);
}
/// <summary>
/// Converts a <see cref="Ms1FtEntry"/> to a <see cref="LcMsFeature"/>
/// </summary>
/// <param name="ms1FtEntry"></param>
/// <param name="totalDatasetRunTime">The total runtime of the dataset; generally the elution time of the last scan. Used to compute NET</param>
/// <returns></returns>
public static LcMsFeature ToLcMsFeature(this Ms1FtEntry ms1FtEntry, double totalDatasetRunTime = 0)
{
var repCharge = ms1FtEntry.RepresentativeCharge != 0 ? ms1FtEntry.RepresentativeCharge : (int)Math.Round(0.5 * (ms1FtEntry.MinCharge + ms1FtEntry.MaxCharge));
var repMz = !ms1FtEntry.RepresentativeMz.Equals(0) ? ms1FtEntry.RepresentativeMz : (ms1FtEntry.MonoMass / repCharge) + Constants.Proton;
var repScanNum = ms1FtEntry.RepresentativeScan > 0 ? ms1FtEntry.RepresentativeScan : ms1FtEntry.MinScan;
var minNet = 0.0;
var maxNet = 0.0;
if (totalDatasetRunTime > 0)
{
minNet = ms1FtEntry.MinElutionTime / totalDatasetRunTime;
maxNet = ms1FtEntry.MaxElutionTime / totalDatasetRunTime;
}
var feature = new LcMsFeature(ms1FtEntry.MonoMass, repCharge, repMz, repScanNum, ms1FtEntry.Abundance, ms1FtEntry.MinCharge, ms1FtEntry.MaxCharge, ms1FtEntry.MinScan, ms1FtEntry.MaxScan, ms1FtEntry.MinElutionTime, ms1FtEntry.MaxElutionTime, minNet, maxNet)
{
FeatureId = ms1FtEntry.FeatureId,
Score = ms1FtEntry.LikelihoodRatio,
};
return(feature);
}
public static string GetString(LcMsFeature feature)
{
// should be called after calling UpdateScore & UpdateAbundance
var sb = new StringBuilder(string.Format("{0}\t{1}\t{2}\t{3}\t{4:0.0000}\t{5}\t{6}\t{7:0.0000}\t{8:0.00}",
feature.MinScanNum, feature.MaxScanNum,
feature.MinCharge, feature.MaxCharge,
feature.RepresentativeMass,
feature.RepresentativeScanNum,
feature.RepresentativeCharge,
feature.RepresentativeMz,
feature.Abundance));
sb.AppendFormat("\t{0:0}", 0);
sb.AppendFormat("\t{0:0.00}", 0);
sb.AppendFormat("\t{0:0.0}", feature.MinElutionTime);
sb.AppendFormat("\t{0:0.0}", feature.MaxElutionTime);
sb.AppendFormat("\t{0:0.0}", feature.ElutionLength);
sb.Append("\t");
sb.Append("");
sb.Append(string.Format("\t{0:0.0}", feature.Score));
return(sb.ToString());
}
public ProteinSpectrumMatch FindByFeature(LcMsFeature feature, Tolerance tolerance)
{
return(FindByFeature(feature.Mass, feature.MinScanNum, feature.MaxScanNum, tolerance));
}
