private int FilterAndOutputFeatures(LcMsFeatureContainer container, LcMsPeakMatrix featureFinder, string outCsvFilePath, string ms1FeaturesFilePath)
{
var featureCounter = new int[1];
Ms1FtEntry.WriteToFile(ms1FeaturesFilePath, FilterFeaturesWithOutput(container, featureFinder, outCsvFilePath, featureCounter), Parameters.ScoreReport);
return(featureCounter[0]);
}
public static List <LcMsFeature> LoadProMexResult(int dataId, string featureFilePath, LcMsRun run, double minMass = 2000, double maxMass = 50000)
{
var featureList = new List <LcMsFeature>();
var totalDatasetRunTime = run.GetElutionTime(run.MaxLcScan);
foreach (var entry in Ms1FtEntry.ReadFromFile(featureFilePath, false))
{
if (entry.MonoMass < minMass || maxMass < entry.MonoMass)
{
continue;
}
var feature = entry.ToLcMsFeature(totalDatasetRunTime);
feature.DataSetId = dataId;
featureList.Add(feature);
}
return(featureList);
}
/// <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="LcMsPeakCluster"/> to a <see cref="Ms1FtEntry"/>
/// </summary>
/// <param name="feature"></param>
/// <param name="featureId"></param>
/// <returns></returns>
public static Ms1FtEntry ToMs1FtEntry(this LcMsPeakCluster feature, int featureId = 0)
{
var intensity = feature.RepresentativeSummedEnvelop;
var maxIntensity = intensity.Max();
var sb = new StringBuilder();
for (var i = 0; i < intensity.Length; i++)
{
if (i != 0)
{
sb.Append(";");
}
sb.AppendFormat("{0},{1:0.000}", feature.TheoreticalEnvelope.Isotopes[i].Index, intensity[i] / maxIntensity);
}
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,
ApexScanNum = feature.ApexScanNum,
ApexIntensity = feature.ApexIntensity,
MinElutionTime = feature.MinElutionTime,
MaxElutionTime = feature.MaxElutionTime,
ElutionLength = feature.ElutionLength,
Envelope = sb.ToString(),
LikelihoodRatio = feature.Score,
ExtendedData = feature.ToMs1FtEntryExtendedData()
};
return(ms1FtEntry);
}
private void Read(string ms1FtFileName)
{
var featureCountFiltered = 0;
var totalFeatureCount = 0;
foreach (var entry in Ms1FtEntry.ReadFromFile(ms1FtFileName))
{
totalFeatureCount++;
if (entry.LikelihoodRatio < _minLikelihoodRatio)
{
continue;
}
featureCountFiltered++;
_lcMsChargeMap.SetMatches(entry.FeatureId, entry.MonoMass, entry.MinScan, entry.MaxScan, entry.RepresentativeScan, entry.MinCharge, entry.MaxCharge);
Ms1FtIndexToScanRange.Add(entry.FeatureId, new Tuple <int, int>(entry.MinScan, entry.MaxScan));
}
// NOTE: The DMS Analysis Manager looks for this statistic; do not change it
Console.Write(@"{0}/{1} features loaded...", featureCountFiltered, totalFeatureCount);
_lcMsChargeMap.CreateMassToScanNumMap();
}
/// <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);
}
