/// <summary> /// Gets a value indicating whether the specified point belongs to the collection. /// </summary> /// <param name="pts">The instance to which the method applies.</param> /// <param name="pt">The point to search.</param> /// <param name="tol">The tolerance to use in comparisons.</param> /// <returns>true if the point is found; otherwise, false.</returns> public static bool Contains(this Point3dCollection pts, Point3d pt, Tolerance tol) { for (int i = 0; i < pts.Count; i++) { if (pt.IsEqualTo(pts[i], tol)) return true; } return false; }
public override PeptideSpectralMatch Search(IMassSpectrum massSpectrum, Peptide peptide, FragmentTypes fragmentTypes, Tolerance productMassTolerance) { double[] eMasses = massSpectrum.MassSpectrum.GetMasses(); double[] eIntenisties = massSpectrum.MassSpectrum.GetIntensities(); double tic = massSpectrum.MassSpectrum.GetTotalIonCurrent(); PeptideSpectralMatch psm = new PeptideSpectralMatch(DefaultPsmScoreType) {Peptide = peptide}; double[] tMasses = peptide.Fragment(fragmentTypes).Select(frag => Mass.MzFromMass(frag.MonoisotopicMass, 1)).OrderBy(val => val).ToArray(); double score = Search(eMasses, eIntenisties, tMasses, productMassTolerance, tic); psm.Score = score; return psm; }
public IEnumerable<Fragment> MatchFragments(IEnumerable<Fragment> fragments, Tolerance tolerance, double percentCutoff, params int[] chargeStates) { double basePeakInt = Spectrum.GetBasePeakIntensity(); double lowThreshold = basePeakInt*percentCutoff; double summedIntensity = 0; double totalIntensity = Spectrum.GetTotalIonCurrent(); foreach (Fragment fragment in fragments) { foreach (int chargeState in chargeStates) { double mz = fragment.ToMz(chargeState); var peak = Spectrum.GetClosestPeak(tolerance.GetRange(mz)); if (peak != null && peak.Intensity >= lowThreshold) { Add(new FragmentSpectralMatch(Spectrum, fragment, tolerance, chargeState)); yield return fragment; summedIntensity += peak.Intensity; } } } PercentTIC = 100.0*summedIntensity/totalIntensity; }
public override SortedMaxSizedContainer<PeptideSpectralMatch> Search(IMassSpectrum spectrum, IEnumerable<Peptide> peptides, FragmentTypes fragmentTypes, Tolerance productMassTolerance) { SortedMaxSizedContainer<PeptideSpectralMatch> results = new SortedMaxSizedContainer<PeptideSpectralMatch>(MaxMatchesPerSpectrum); double[] eMasses = spectrum.MassSpectrum.GetMasses(); double[] eIntenisties = spectrum.MassSpectrum.GetIntensities(); double tic = spectrum.MassSpectrum.TotalIonCurrent; foreach (var peptide in peptides) { PeptideSpectralMatch psm = new PeptideSpectralMatch(DefaultPsmScoreType) {Peptide = peptide}; double[] tMasses = peptide.Fragment(fragmentTypes) .Select(frag => Mass.MzFromMass(frag.MonoisotopicMass, 1)) .OrderBy(val => val) .ToArray(); double score = Search(eMasses, eIntenisties, tMasses, productMassTolerance, tic); psm.Score = score; results.Add(psm); } return results; }
public bool initXtalTolerance(string configurationField) { try { if (configurationField == "loPPM") { this.XtalTol = Tolerance.loPPM; } else if (configurationField == "hiPPM") { this.XtalTol = Tolerance.hiPPM; } else { return false; } return true; } catch { return false; } }
/// <summary> /// Removes duplicated points in the collection. /// </summary> /// <param name="pts">The instance to which the method applies.</param> /// <param name="tol">The tolerance to use in comparisons.</param> public static void RemoveDuplicate(this Point3dCollection pts, Tolerance tol) { List<Point3d> ptlst = new List<Point3d>(); for (int i = 0; i < pts.Count; i++) { ptlst.Add(pts[i]); } ptlst.Sort((p1, p2) => p1.X.CompareTo(p2.X)); for (int i = 0; i < ptlst.Count - 1; i++) { for (int j = i + 1; j < ptlst.Count; ) { if ((ptlst[j].X - ptlst[i].X) > tol.EqualPoint) break; if (ptlst[i].IsEqualTo(ptlst[j], tol)) { pts.Remove(ptlst[j]); ptlst.RemoveAt(j); } else j++; } } }
public void GeneratePrmInfo(string resultFilePath, string outputFilePath) { Console.Write("Processing {0}", Path.GetFileName(resultFilePath)); Console.Out.Flush(); var rawFilePath = @"D:\Research\Data\EDRN\DDA\raw\" + Path.GetFileNameWithoutExtension(resultFilePath) + ".raw"; var reader = new XCaliburReader(rawFilePath); var run = InMemoryLcMsRun.GetLcMsRun(rawFilePath); var tolerance = new Tolerance(10, ToleranceUnit.Ppm); const string spikedInPeptideFile = @"D:\Research\Data\EDRN\SpikedPeptides.txt"; var spikedInPeptides = File.ReadAllLines(spikedInPeptideFile); var spikedInPepSet = new HashSet <string>(); foreach (var p in spikedInPeptides) { spikedInPepSet.Add(p); } // const string resultFilePath = @"D:\Research\Data\EDRN\DDA\Frac7_NTT2.tsv"; //const string resultFilePath = @"D:\Research\Data\EDRN\DDA\Heavy\342865_EDRN_Serum_07_DDA_1_12Nov13_Samwise_13-07-28.tsv"; // const string resultFilePath = @"D:\Research\Data\EDRN\DDA\NTT1_NoMod\342865_EDRN_Serum_07_DDA_1_12Nov13_Samwise_13-07-28.tsv"; const double qValueThreshold = 0.01; var pepSet = new HashSet <string>(); MsGfPlusHeaderInformation headerInfo = null; //var prefix = new HashSet<string>(); //var suffix = new HashSet<string>(); var numPeptides = 0; var prevScanNum = -1; using (var writer = new StreamWriter(outputFilePath)) { writer.WriteLine("Peptide\tCharge\tMonoMz\tMostAbundantMz\tMs2ScanNum\tRtMs2\tRtApex\tRtStart\tRtEnd\tSpecEValue\tPepQValue"); foreach (var line in File.ReadLines(resultFilePath)) { if (line.StartsWith("#")) { headerInfo = new MsGfPlusHeaderInformation(line); continue; } var match = new MsGfMatch(line, headerInfo); if (match.ScanNum == prevScanNum) { continue; } prevScanNum = match.ScanNum; if (!match.IsValid || match.Protein.StartsWith(FastaDatabase.DecoyProteinPrefix)) { continue; } if (match.PepQValue > qValueThreshold) { continue; } var peptide = match.Peptide.Replace("C+57.021", "C").Replace("K+8.014", "K").Replace("R+10.008", "R"); if (pepSet.Contains(peptide)) { continue; } pepSet.Add(peptide); if (spikedInPepSet.Contains(peptide)) { var ion = new Ion(match.Formula, match.Charge); var mostAbundantIonMz = ion.GetMostAbundantIsotopeMz(); var xic = run.GetPrecursorExtractedIonChromatogram(mostAbundantIonMz, tolerance, match.ScanNum); if (xic.Count == 0) { continue; } var minScan = xic.Min().ScanNum; var maxScan = xic.Max().ScanNum; writer.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}\t{8}\t{9}\t{10}", peptide, match.Charge, ion.GetMonoIsotopicMz(), mostAbundantIonMz, match.ScanNum, reader.RtFromScanNum(match.ScanNum), reader.RtFromScanNum(xic.GetApexScanNum()), // Rt apex reader.RtFromScanNum(minScan), // Rt start reader.RtFromScanNum(maxScan), // Rt end match.SpecEValue, match.PepQValue); ++numPeptides; } //else //{ // foreach (var spikedInPeptide in spikedInPeptides) // { // if (spikedInPeptide.StartsWith(peptide)) prefix.Add(spikedInPeptide + "\t" + peptide + "\t" + match.ScanNum); // else if (spikedInPeptide.EndsWith(peptide)) suffix.Add(spikedInPeptide + "\t" + peptide + "\t" + match.ScanNum); // } //} } } //Console.WriteLine("*********Prefix"); //foreach(var p in prefix) Console.WriteLine(p); //Console.WriteLine("*********Suffix"); //foreach (var p in suffix) Console.WriteLine(p); Console.WriteLine("\t{0}", numPeptides); }
public LeaderSkillStatus(string leaderSkillId, string name, string description, LeaderSkillType type, float hpFollowingPercent, float upPercent, Tolerance tolerance) { float[] array = new float[2]; array[0] = 1f; this._floatValue = array; this._isHaving = true; base..ctor(); this._leaderSkillId = leaderSkillId; this._name = name; this._description = description; this._type = type; this._floatValue[0] = Mathf.Clamp01(hpFollowingPercent); this._floatValue[1] = Mathf.Clamp01(upPercent); this._addTolerances = this.addTolerances; this._isHaving = (name != null); }
public void ExtractLcMsFeaturesForTrainingSet() { var methodName = MethodBase.GetCurrentMethod().Name; TestUtils.ShowStarting(methodName); const string idFileFolder = @"D:\MassSpecFiles\training\FilteredIdResult"; if (!Directory.Exists(idFileFolder)) { Assert.Ignore(@"Skipping test {0} since folder not found: {1}", methodName, idFileFolder); } var tolerance = new Tolerance(10); var tolerance2 = new Tolerance(20); var id = 1; for (var d = 0; d < TrainSetFileLists.Length; d++) { var dataset = TrainSetFileLists[d]; var dataname = Path.GetFileNameWithoutExtension(dataset); var filtedIdResultFile = string.Format(@"{0}\{1}.trainset.tsv", idFileFolder, Path.GetFileNameWithoutExtension(dataset)); var featureResult = string.Format(@"{0}\{1}.ms1ft", idFileFolder, Path.GetFileNameWithoutExtension(dataset)); if (!File.Exists(dataset)) { Console.WriteLine(@"Warning: Skipping since file not found: {0}", dataset); continue; } if (!File.Exists(filtedIdResultFile)) { Console.WriteLine(@"Warning: Skipping since file not found: {0}", filtedIdResultFile); continue; } var run = PbfLcMsRun.GetLcMsRun(dataset); var targetStatWriter = new StreamWriter(string.Format(@"D:\MassSpecFiles\training\statistics\{0}.tsv", Path.GetFileNameWithoutExtension(dataset))); var decoyStatWriter = new StreamWriter(string.Format(@"D:\MassSpecFiles\training\statistics\{0}_decoy.tsv", Path.GetFileNameWithoutExtension(dataset))); var writer = new StreamWriter(featureResult); writer.Write("Ms2MinScan\tMs2MaxScan\tMs2MinCharge\tMs2MaxCharge\tMs2Mass\t"); writer.Write("Mass\tMinScan\tMaxScan\tMinCharge\tMaxCharge\tMinTime\tMaxTime\tElution\tGood\n"); var tsvParser = new TsvFileParser(filtedIdResultFile); var featureFinder = new LcMsPeakMatrix(run); for (var i = 0; i < tsvParser.NumData; i++) { var minScan = int.Parse(tsvParser.GetData("MinScan")[i]); var maxScan = int.Parse(tsvParser.GetData("MaxScan")[i]); var minCharge = int.Parse(tsvParser.GetData("MinCharge")[i]); var maxCharge = int.Parse(tsvParser.GetData("MaxCharge")[i]); var mass = double.Parse(tsvParser.GetData("Mass")[i]); writer.Write(minScan); writer.Write("\t"); writer.Write(maxScan); writer.Write("\t"); writer.Write(minCharge); writer.Write("\t"); writer.Write(maxCharge); writer.Write("\t"); writer.Write(mass); writer.Write("\t"); var binNum = featureFinder.Comparer.GetBinNumber(mass); var binMass = featureFinder.Comparer.GetMzAverage(binNum); var binNumList = (mass < binMass) ? new int[] { binNum, binNum - 1, binNum + 1 } : new int[] { binNum, binNum + 1, binNum - 1 }; LcMsPeakCluster refinedFeature = null; foreach (var bi in binNumList) { var tempList = new List <LcMsPeakCluster>(); var features = featureFinder.FindFeatures(bi); var massTh = (mass < 2000) ? tolerance2.GetToleranceAsTh(mass) : tolerance.GetToleranceAsTh(mass); foreach (var feature in features) { if (Math.Abs(mass - feature.Mass) < massTh) { tempList.Add(feature); } } //var nHits = 0; var highestAbu = 0d; //var scans = Enumerable.Range(minScan, maxScan - minScan + 1); foreach (var feature in tempList) { //var scans2 = Enumerable.Range(feature.MinScanNum, feature.MaxScanNum - feature.MinScanNum + 1); //var hitScans = scans.Intersect(scans2).Count(); if (feature.MinScanNum < 0.5 * (minScan + maxScan) && 0.5 * (minScan + maxScan) < feature.MaxScanNum) { if (feature.Abundance > highestAbu) { refinedFeature = feature; highestAbu = feature.Abundance; } } /*if (hitScans > 0) * { * refinedFeature = feature; * nHits = hitScans; * }*/ } if (refinedFeature != null) { break; } } if (refinedFeature != null) { writer.Write(refinedFeature.Mass); writer.Write("\t"); writer.Write(refinedFeature.MinScanNum); writer.Write("\t"); writer.Write(refinedFeature.MaxScanNum); writer.Write("\t"); writer.Write(refinedFeature.MinCharge); writer.Write("\t"); writer.Write(refinedFeature.MaxCharge); writer.Write("\t"); writer.Write(refinedFeature.MinElutionTime); writer.Write("\t"); writer.Write(refinedFeature.MaxElutionTime); writer.Write("\t"); writer.Write(refinedFeature.MaxElutionTime - refinedFeature.MinElutionTime); writer.Write("\t"); var good = (refinedFeature.MinScanNum <= minScan && refinedFeature.MaxScanNum >= maxScan); writer.Write(good ? 1 : 0); writer.Write("\n"); //writer.Write(0); writer.Write("\t"); //writer.Write(0); writer.Write("\n"); OutputEnvelopPeakStat(id, refinedFeature, targetStatWriter); var chargeRange = featureFinder.GetDetectableMinMaxCharge(refinedFeature.RepresentativeMass, run.MinMs1Mz, run.MaxMs1Mz); refinedFeature.UpdateWithDecoyScore(featureFinder.Ms1Spectra, chargeRange.Item1, chargeRange.Item2); OutputEnvelopPeakStat(id, refinedFeature, decoyStatWriter); id++; } else { writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\t"); writer.Write(0); writer.Write("\n"); } //var feature = featureFinder.FindLcMsPeakCluster(mass, (int) scan, (int) charge); } writer.Close(); targetStatWriter.Close(); decoyStatWriter.Close(); Console.WriteLine(dataname); } }
/// <summary> /// Creates a new Polyline that is the result of projecting the Polyline parallel to 'direction' onto 'plane' and returns it. /// </summary> /// <param name="pline">The polyline to project.</param> /// <param name="plane">The plane onto which the curve is to be projected.</param> /// <param name="direction">Direction (in WCS coordinates) of the projection.</param> /// <returns>The projected Polyline.</returns> public static Polyline GetProjectedPolyline(this Polyline pline, Plane plane, Vector3d direction) { Tolerance tol = new Tolerance(1e-9, 1e-9); if (plane.Normal.IsPerpendicularTo(direction, tol)) return null; if (pline.Normal.IsPerpendicularTo(direction, tol)) { Plane dirPlane = new Plane(Point3d.Origin, direction); if (!pline.IsWriteEnabled) pline.UpgradeOpen(); pline.TransformBy(Matrix3d.WorldToPlane(dirPlane)); Extents3d extents = pline.GeometricExtents; pline.TransformBy(Matrix3d.PlaneToWorld(dirPlane)); return GeomExt.ProjectExtents(extents, plane, direction, dirPlane); } return GeomExt.ProjectPolyline(pline, plane, direction); }
static PointSampler() { Tolerance = new Tolerance(1E-6, 1E-6); }
public IcBottomUpRescorer(string specFilePath, string icResultFilePath, string outputFilePath, AminoAcidSet aaSet, Tolerance tolerance) { _run = InMemoryLcMsRun.GetLcMsRun(specFilePath, 1.4826, 0.0); Rescore(icResultFilePath, outputFilePath); }
public Curve3d GetGeCurve(Tolerance tolerance) { createInstance(); Curve3d GetGeCur = BaseCurve.GetGeCurve(tolerance); tr.Dispose(); return GetGeCur; }
public MassRange(double meanMass, Tolerance toleranceWidth) : base(meanMass, toleranceWidth) { }
public MzRange(double meanMZ, Tolerance tolerance) : base(meanMZ, tolerance) { }
protected bool CompareColor(ScreenshotColor refColor, ScreenshotColor actualColor, Tolerance tolerance) { // Simply compare the discrepancy of the R, G and B values // of each color. for (int i = 0; i < 3; i++) { byte bRef = refColor.GetValueFromIndex(i); byte bAct = actualColor.GetValueFromIndex(i); if (!(Math.Abs(bRef - bAct) <= tolerance.GetValueFromIndex(i))) return false; } return true; }
/// <summary> /// Gets a value indicating whether the specified point is on the segment defined by two points. /// </summary> /// <param name="pt">The instance to which the method applies.</param> /// <param name="p1">The segment start point.</param> /// <param name="p2">The segment end point.</param> /// <param name="tol">The tolerance used in comparisons.</param> /// <returns>true if the point is on the segment; otherwise, false.</returns> public static bool IsBetween(this Point3d pt, Point3d p1, Point3d p2, Tolerance tol) { return p1.GetVectorTo(pt).GetNormal(tol).Equals(pt.GetVectorTo(p2).GetNormal(tol)); }
/// <summary> /// Проверка дублирования вхождений блоков /// </summary> /// <param name="blk1"></param> /// <param name="blk2"></param> /// <returns></returns> public static bool IsDuplicate(this BlockReference blk1, BlockReference blk2) { Tolerance tol = new Tolerance(1, 1); return blk1.OwnerId == blk2.OwnerId && blk1.Name == blk2.Name && Math.Round(blk1.Rotation, 1) == Math.Round(blk2.Rotation, 1) && blk1.Position.IsEqualTo(blk2.Position, tol) && blk1.ScaleFactors.IsEqualTo(blk2.ScaleFactors, tol); }
public void SetFromGeCurve(Curve3d geCurve, Vector3d __unnamed001, Tolerance tolerance) { createInstance(); BaseCurve.SetFromGeCurve(geCurve, __unnamed001, tolerance); tr.Dispose(); }
public void SetFromGeCurve(Curve3d geCurve, Tolerance tolerance) { createInstance(); BaseCurve.SetFromGeCurve(geCurve, tolerance); tr.Dispose(); }
/// <summary> /// Gets a value indicating whether the specified point belongs to the collection. /// </summary> /// <param name="pts">The instance to which the method applies.</param> /// <param name="pt">The point to search.</param> /// <param name="tol">The tolerance to use in comparisons.</param> /// <returns>true if the point is found; otherwise, false.</returns> public static bool Contains([NotNull] this Point2dCollection pts, Point2d pt, Tolerance tol) { foreach (var t in pts) { if (pt.IsEqualTo(t, tol)) { return(true); } } return(false); }
public void MassToleranceImplicitValue() { var tol = new Tolerance("10 ppm"); Assert.AreEqual(10, tol.Value); }
public Xic GetProductExtractedIonChromatogram(double productIonMz, double precursorIonMz, Tolerance tolerance, int minScanNum, int maxScanNum) { var productXic = new Xic(); for (var scanNum = minScanNum; scanNum <= maxScanNum; scanNum++) { if (GetMsLevel(scanNum) == 1) { continue; } var productSpec = _scanNumSpecMap[scanNum] as ProductSpectrum; if (productSpec == null) { continue; } if (!productSpec.IsolationWindow.Contains(precursorIonMz)) { continue; } var peak = productSpec.FindPeak(productIonMz, tolerance); if (peak != null) { productXic.Add(new XicPoint(scanNum, peak.Mz, peak.Intensity)); } } return(productXic); }
/// <summary> /// Прополка полилинии /// </summary> public static void Wedding(this Polyline pl, Tolerance tolerance) { var count = pl.NumberOfVertices; for (int i = 1; i < count; i++) { int iPrew; int iCur; int iNext; iPrew = i-1; iCur = i; iNext = i + 1; if (iNext == count) { break; } var prew = pl.GetPoint2dAt(iPrew); var cur = pl.GetPoint2dAt(iCur); var next = pl.GetPoint2dAt(iNext); if (IsPointsOnSomeLine(prew, cur, next, tolerance)) { pl.RemoveVertexAt(i); i--; count--; } } count = pl.NumberOfVertices; // Если начальная точка совпадает с конечной, то проверка сегменов до и после if (count > 3) { Point2d fp = pl.GetPoint2dAt(0); Point2d lp = pl.GetPoint2dAt(count - 1); Point2d next = pl.GetPoint2dAt(1); if (fp.IsEqualTo(lp, tolerance)) { var cur = fp; var prew = pl.GetPoint2dAt(count - 2); if (IsPointsOnSomeLine(prew, cur, next, tolerance)) { pl.RemoveVertexAt(count - 1); pl.RemoveVertexAt(0); if (!pl.Closed) { pl.Closed = true; } } } else if (pl.Closed) { var prew = lp; var cur = fp; if (IsPointsOnSomeLine(prew, cur, next, tolerance)) { pl.RemoveVertexAt(0); } } } }
public virtual SortedMaxSizedContainer<PeptideSpectralMatch> Search(IMassSpectrum massSpectrum, IEnumerable<Peptide> peptides, FragmentTypes fragmentTypes, Tolerance productMassTolerance) { SortedMaxSizedContainer<PeptideSpectralMatch> results = new SortedMaxSizedContainer<PeptideSpectralMatch>(MaxMatchesPerSpectrum); foreach (var peptide in peptides) { results.Add(Search(massSpectrum, peptide, fragmentTypes, productMassTolerance)); } return results; }
private static bool IsPointsOnSomeLine(Point2d pt1, Point2d pt2, Point2d pt3, Tolerance tolerance) { var vec1 = pt2 - pt1; var vec2 = pt3 - pt1; return vec1.IsParallelTo(vec2, tolerance); }
public void MassToleranceImplicitPlusMinus5() { var tol = new Tolerance("10 ppm"); Assert.AreEqual(tol.Type, ToleranceType.FullWidth); }
/// <summary> /// TODO /// </summary> /// <param name="axis"></param> /// <param name="tol"></param> /// <returns></returns> public bool IsParallelTo(Axis axis, Tolerance tol) { return(Start.GetVectorTo(End).IsParallelTo(axis.Start.GetVectorTo(axis.End), tol)); }
public void MassToleranceConstructorDaValue() { var tol = new Tolerance(ToleranceUnit.DA, 10); Assert.AreEqual(10, tol.Value); }
public void FindMissingLcMsFeatures() { var mspfFolder = @"D:\MassSpecFiles\CompRef_Kelleher\Study3"; var ms1ftFolder = @"D:\MassSpecFiles\CompRef_Kelleher\Study3"; const int Nfraction1 = 3; const int Nfraction2 = 5; for (var frac1 = 1; frac1 <= Nfraction1; frac1++) { for (var frac2 = 1; frac2 <= Nfraction2; frac2++) { var datasets = GetDataSetNamesStudy3(frac1, frac2); //var outFilePath = string.Format(@"D:\MassSpecFiles\CompRef_Kelleher\study3_GFrep{0}_Gfrac{1}.tsv", frac1.ToString("D2"), frac2.ToString("D2")); var nDataset = datasets.Count; var prsmReader = new ProteinSpectrumMatchReader(); var tolerance = new Tolerance(12); for (var i = 0; i < nDataset; i++) { var rawFile = string.Format(@"{0}\{1}.pbf", PbfPath, datasets[i]); var mspFile = string.Format(@"{0}\{1}_IcTda.tsv", mspfFolder, datasets[i]); var ms1FtFile = string.Format(@"{0}\{1}.ms1ft", ms1ftFolder, datasets[i]); var outPath = string.Format(@"{0}\{1}.seqtag.ms1ft", ms1ftFolder, datasets[i]); if (File.Exists(outPath)) { continue; } var run = PbfLcMsRun.GetLcMsRun(rawFile); var features = LcMsFeatureAlignment.LoadProMexResult(i, ms1FtFile, run); var prsmList = prsmReader.LoadIdentificationResult(mspFile, ProteinSpectrumMatch.SearchTool.MsPathFinder); var prsmFeatureMatch = new bool[prsmList.Count]; for (var j = 0; j < features.Count; j++) { //features[j].ProteinSpectrumMatches = new ProteinSpectrumMatchSet(i); var massTol = tolerance.GetToleranceAsTh(features[j].Mass); for (var k = 0; k < prsmList.Count; k++) { var match = prsmList[k]; if (features[j].MinScanNum < match.ScanNum && match.ScanNum < features[j].MaxScanNum && Math.Abs(features[j].Mass - match.Mass) < massTol) { features[j].ProteinSpectrumMatches.Add(match); prsmFeatureMatch[k] = true; } } } var missingPrsm = new List <ProteinSpectrumMatch>(); for (var k = 0; k < prsmList.Count; k++) { if (!prsmFeatureMatch[k]) { missingPrsm.Add(prsmList[k]); } } FeatureFind(missingPrsm, run, outPath); Console.WriteLine(outPath); } } } }
public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { if (!(x is Stream) || !(y is Stream)) { return(null); } Stream xStream = (Stream)x; Stream yStream = (Stream)y; if (xStream == yStream) { return(true); } if (!xStream.CanRead) { throw new ArgumentException("Stream is not readable", "expected"); } if (!yStream.CanRead) { throw new ArgumentException("Stream is not readable", "actual"); } if (!xStream.CanSeek) { throw new ArgumentException("Stream is not seekable", "expected"); } if (!yStream.CanSeek) { throw new ArgumentException("Stream is not seekable", "actual"); } if (xStream.Length != yStream.Length) { return(false); } byte[] bufferExpected = new byte[BUFFER_SIZE]; byte[] bufferActual = new byte[BUFFER_SIZE]; BinaryReader binaryReaderExpected = new BinaryReader(xStream); BinaryReader binaryReaderActual = new BinaryReader(yStream); long expectedPosition = xStream.Position; long actualPosition = yStream.Position; try { binaryReaderExpected.BaseStream.Seek(0, SeekOrigin.Begin); binaryReaderActual.BaseStream.Seek(0, SeekOrigin.Begin); for (long readByte = 0; readByte < xStream.Length; readByte += BUFFER_SIZE) { binaryReaderExpected.Read(bufferExpected, 0, BUFFER_SIZE); binaryReaderActual.Read(bufferActual, 0, BUFFER_SIZE); for (int count = 0; count < BUFFER_SIZE; ++count) { if (bufferExpected[count] != bufferActual[count]) { NUnitEqualityComparer.FailurePoint fp = new NUnitEqualityComparer.FailurePoint(); fp.Position = readByte + count; fp.ExpectedHasData = true; fp.ExpectedValue = bufferExpected[count]; fp.ActualHasData = true; fp.ActualValue = bufferActual[count]; _equalityComparer.FailurePoints.Insert(0, fp); return(false); } } } } finally { xStream.Position = expectedPosition; yStream.Position = actualPosition; } return(true); }
//private double Search(ref double[] eMasses, ref double[] eIntenisties, double[] tMasses, double productTolerance, double tic, ref Dictionary<double, double> scores) //{ // double score = 0.0; // int eLength = eMasses.Length; // int tLength = tMasses.Length; // int e = 0; // foreach (double t in tMasses) // { // double storedScore; // if (scores.TryGetValue(t, out storedScore)) // { // score += storedScore; // continue; // } // double minMZ = t - productTolerance; // double maxMZ = t + productTolerance; // while (e < eLength && eMasses[e] < minMZ) // e++; // if (e >= eLength) // break; // if (eMasses[e] > maxMZ) // continue; // double intensities = 0; // int index = e; // switch variables to keep e the same for the next loop around // do // { // intensities += eIntenisties[index]; // index++; // } while (index < eLength && eMasses[index] < maxMZ); // storedScore = 1 + intensities/tic; // score += storedScore; // scores[t] = storedScore; // } // return score; //} /// <summary> /// The main searching algorithm of Morpheus /// </summary> /// <param name="eMasses">The experimental masses</param> /// <param name="eIntenisties">The experimental intensities</param> /// <param name="tMasses">The theoretical masses</param> /// <param name="productTolerance">The product mass tolerance</param> /// <param name="tic">The total ion current of the experimental peaks</param> /// <returns></returns> private double Search(double[] eMasses, double[] eIntenisties, double[] tMasses, Tolerance productTolerance, double tic) { double score = 0.0; double intensities = 0.0; int eLength = eMasses.Length; int tLength = tMasses.Length; int e = 0; bool forceCheck = productTolerance.GetMinimumValue(tMasses[tLength - 1]) >= eMasses[eLength - 1]; if (forceCheck) { foreach (double t in tMasses) { IRange<double> range = productTolerance.GetRange(t); double minMZ = range.Minimum; double maxMZ = range.Maximum; while (e < eLength && eMasses[e] < minMZ) e++; if (e >= eLength) break; if (eMasses[e] > maxMZ) continue; score++; int index = e; // switch variables to keep e the same for the next loop around do { intensities += eIntenisties[index]; index++; } while (index < eLength && eMasses[index] < maxMZ); } } else { foreach (double t in tMasses) { IRange<double> range = productTolerance.GetRange(t); double minMZ = range.Minimum; double maxMZ = range.Maximum; while (eMasses[e] < minMZ) e++; if (eMasses[e] > maxMZ) continue; score++; int index = e; // switch variables to keep e the same for the next loop around do { intensities += eIntenisties[index]; index++; } while (index < eLength && eMasses[index] < maxMZ); } } return score + intensities/tic; }
public void AlignFeatures(List <string> datasets, string mspfFolder, string ms1ftFolder, string outFilePath) { var nDataset = datasets.Count; var prsmReader = new ProteinSpectrumMatchReader(); var tolerance = new Tolerance(12); var alignment = new LcMsFeatureAlignment(new AnalysisCompRef.CompRefFeatureComparer(tolerance)); for (var i = 0; i < nDataset; i++) { var rawFile = string.Format(@"{0}\{1}.pbf", PbfPath, datasets[i]); var mspFile = string.Format(@"{0}\{1}_IcTda.tsv", mspfFolder, datasets[i]); var ms1FtFile = string.Format(@"{0}\{1}.ms1ft", ms1ftFolder, datasets[i]); var ms1FtFile2 = string.Format(@"{0}\{1}.seqtag.ms1ft", ms1ftFolder, datasets[i]); var run = PbfLcMsRun.GetLcMsRun(rawFile); var features = LcMsFeatureAlignment.LoadProMexResult(i, ms1FtFile, run); var features2 = LcMsFeatureAlignment.LoadProMexResult(i, ms1FtFile2, run); features.AddRange(features2); if (File.Exists(mspFile)) { var prsmList = prsmReader.LoadIdentificationResult(mspFile, ProteinSpectrumMatch.SearchTool.MsPathFinder); //var prsmFeatureMatch = new bool[prsmList.Count]; for (var j = 0; j < prsmList.Count; j++) { var match = prsmList[j]; match.ProteinId = match.ProteinName; } // tag features by PrSMs for (var j = 0; j < features.Count; j++) { //features[j].ProteinSpectrumMatches = new ProteinSpectrumMatchSet(i); var massTol = tolerance.GetToleranceAsTh(features[j].Mass); for (var k = 0; k < prsmList.Count; k++) { var match = prsmList[k]; if (features[j].MinScanNum < match.ScanNum && match.ScanNum < features[j].MaxScanNum && Math.Abs(features[j].Mass - match.Mass) < massTol) { features[j].ProteinSpectrumMatches.Add(match); //prsmFeatureMatch[k] = true; } } } } alignment.AddDataSet(i, features, run); } alignment.AlignFeatures(); Console.WriteLine("{0} alignments ", alignment.CountAlignedFeatures); for (var i = 0; i < nDataset; i++) { alignment.FillMissingFeatures(i); Console.WriteLine("{0} has been processed", datasets[i]); } AnalysisCompRef.OutputCrossTabWithId(outFilePath, alignment, datasets.ToArray()); }
/// <summary> /// Perform the comparison /// </summary> protected override bool PerformComparison(ComparisonAdapter comparer, object actual, object expected, Tolerance tolerance) { return(comparer.Compare(actual, tolerance.ApplyToValue(expected).UpperBound) <= 0); }
public IEnumerable <Tuple <List <IMzPeak>, int> > Deconvolute(MzRange theRange, int maxAssumedChargeState, Tolerance massTolerance, double intensityRatio) { var isolatedMassesAndCharges = new List <Tuple <List <IMzPeak>, int> >(); foreach (var peak in Extract(theRange)) { // Always assume the current peak is a monoisotopic peak! List <IMzPeak> bestListOfPeaks = new List <IMzPeak>(); int bestChargeState = 1; for (int chargeState = 1; chargeState <= maxAssumedChargeState; chargeState++) { var listOfPeaksForThisChargeState = new List <IMzPeak> { peak }; var mMass = peak.Mz.ToMass(chargeState); for (int mm = 1; mm <= mms.Length; mm++) { double diffToNextMmPeak = mms[mm - 1]; double theorMass = mMass + diffToNextMmPeak; var closestpeak = GetClosestPeak(theorMass.ToMz(chargeState)); if (massTolerance.Within(closestpeak.Mz.ToMass(chargeState), theorMass) && SatisfiesRatios(mMass, mm, peak, closestpeak, intensityRatio)) { // Found a match to an isotope peak for this charge state! listOfPeaksForThisChargeState.Add(closestpeak); } else { break; } } if (listOfPeaksForThisChargeState.Count >= bestListOfPeaks.Count) { bestListOfPeaks = listOfPeaksForThisChargeState; bestChargeState = chargeState; } } if (bestListOfPeaks.Count >= 2) { isolatedMassesAndCharges.Add(new Tuple <List <IMzPeak>, int>(bestListOfPeaks, bestChargeState)); } } List <double> seen = new List <double>(); while (isolatedMassesAndCharges.Any()) { // Pick longest var longest = isolatedMassesAndCharges.OrderByDescending(b => b.Item1.Count).First(); yield return(longest); isolatedMassesAndCharges.Remove(longest); isolatedMassesAndCharges.RemoveAll(b => b.Item1.Intersect(longest.Item1).Any()); } }
/// <summary> /// Reads RawData into structured data. /// </summary> public void StructureData(CFGData cfg) { this.Name = cfg.Name; this.Strength = cfg.Attributes[0]; this.Intelligence = cfg.Attributes[1]; this.Willpower = cfg.Attributes[2]; this.Agility = cfg.Attributes[3]; this.Endurance = cfg.Attributes[4]; this.Personality = cfg.Attributes[5]; this.Speed = cfg.Attributes[6]; this.Luck = cfg.Attributes[7]; this.PrimarySkill1 = (Skills)cfg.PrimarySkill1; this.PrimarySkill2 = (Skills)cfg.PrimarySkill2; this.PrimarySkill3 = (Skills)cfg.PrimarySkill3; this.MajorSkill1 = (Skills)cfg.MajorSkill1; this.MajorSkill2 = (Skills)cfg.MajorSkill2; this.MajorSkill3 = (Skills)cfg.MajorSkill3; this.MinorSkill1 = (Skills)cfg.MinorSkill1; this.MinorSkill2 = (Skills)cfg.MinorSkill2; this.MinorSkill3 = (Skills)cfg.MinorSkill3; this.MinorSkill4 = (Skills)cfg.MinorSkill4; this.MinorSkill5 = (Skills)cfg.MinorSkill5; this.MinorSkill6 = (Skills)cfg.MinorSkill6; this.HitPointsPerLevelOrMonsterLevel = cfg.HitPointsPerLevelOrMonsterLevel; float value = (cfg.AdvancementMultiplier >> 16) + ((cfg.AdvancementMultiplier & 0xffff)) / 65536f; try { this.AdvancementMultiplier = float.Parse(string.Format("{0:0.00}", value), NumberStyles.Float, CultureInfo.InvariantCulture); } catch { this.AdvancementMultiplier = value; } this.Paralysis = GetTolerance(cfg, EffectFlags.Paralysis); this.Magic = GetTolerance(cfg, EffectFlags.Magic); this.Poison = GetTolerance(cfg, EffectFlags.Poison); this.Fire = GetTolerance(cfg, EffectFlags.Fire); this.Frost = GetTolerance(cfg, EffectFlags.Frost); this.Shock = GetTolerance(cfg, EffectFlags.Shock); this.Disease = GetTolerance(cfg, EffectFlags.Disease); this.ForbiddenMaterials = (MaterialFlags)cfg.ForbiddenMaterialsFlags; this.ForbiddenShields = (ShieldFlags)((cfg.WeaponArmorShieldsBitfield >> 9) & 0x0f); this.ForbiddenArmors = (ArmorFlags)((cfg.WeaponArmorShieldsBitfield >> 6) & 0x07); this.ForbiddenProficiencies = (ProficiencyFlags)(cfg.WeaponArmorShieldsBitfield & 0x3f); this.ExpertProficiencies = (ProficiencyFlags)((cfg.WeaponArmorShieldsBitfield >> 16) & 0x3f); this.ShortBlades = GetProficiency(ProficiencyFlags.ShortBlades); this.LongBlades = GetProficiency(ProficiencyFlags.LongBlades); this.HandToHand = GetProficiency(ProficiencyFlags.HandToHand); this.Axes = GetProficiency(ProficiencyFlags.Axes); this.BluntWeapons = GetProficiency(ProficiencyFlags.BluntWeapons); this.MissileWeapons = GetProficiency(ProficiencyFlags.MissileWeapons); this.SpellPointMultiplier = GetSpellPointMultiplier(cfg); this.SpellPointMultiplierValue = GetSpellPointMultiplierValue(this.SpellPointMultiplier); this.DarknessPoweredMagery = (DarknessMageryFlags)((cfg.AbilityFlagsAndSpellPointsBitfield & 0x300) >> 8); this.LightPoweredMagery = (LightMageryFlags)((cfg.AbilityFlagsAndSpellPointsBitfield & 0x00C0) >> 6); this.SpellAbsorption = (SpellAbsorptionFlags)cfg.SpellAbsorptionFlags; this.NoRegenSpellPoints = HasSpecialAbility(cfg, SpecialAbilityFlags.NoRegenSpellPoints); this.AcuteHearing = HasSpecialAbility(cfg, SpecialAbilityFlags.AcuteHearing); this.Athleticism = HasSpecialAbility(cfg, SpecialAbilityFlags.Athleticism); this.AdrenalineRush = HasSpecialAbility(cfg, SpecialAbilityFlags.AdrenalineRush); this.Regeneration = (RegenerationFlags)cfg.Regeneration; this.RapidHealing = (RapidHealingFlags)cfg.RapidHealing; this.DamageFromSunlight = HasSpecialAbility(cfg, SpecialAbilityFlags.SunDamage); this.DamageFromHolyPlaces = HasSpecialAbility(cfg, SpecialAbilityFlags.HolyDamage); this.UndeadAttackModifier = GetAttackModifier(cfg, EnemyGroups.Undead); this.DaedraAttackModifier = GetAttackModifier(cfg, EnemyGroups.Daedra); this.HumanoidAttackModifier = GetAttackModifier(cfg, EnemyGroups.Humanoid); this.AnimalsAttackModifier = GetAttackModifier(cfg, EnemyGroups.Animals); }
public CompositeScorerBasedOnDeconvolutedSpectrum(DeconvolutedSpectrum deconvolutedSpectrum, ProductSpectrum spec, Tolerance productTolerance, IMassBinning comparer) : base(deconvolutedSpectrum, productTolerance) { ReferencePeakIntensity = GetRefIntensity(spec.Peaks); _comparer = comparer; _massBinToPeakMap = new Dictionary <int, DeconvolutedPeak>(); foreach (var p in deconvolutedSpectrum.Peaks) { var mass = p.Mz; var deltaMass = productTolerance.GetToleranceAsDa(mass, 1); var minMass = mass - deltaMass; var maxMass = mass + deltaMass; var binNum = comparer.GetBinNumber(mass); if (binNum < 0) { binNum = comparer.GetBinNumber(minMass); if (binNum < 0) { binNum = comparer.GetBinNumber(maxMass); } } // filter out if (binNum < 0) { continue; } UpdateDeconvPeak(binNum, p as DeconvolutedPeak); // going up for (var nextBinNum = binNum + 1; nextBinNum < comparer.NumberOfBins; nextBinNum++) { var nextBinMass = comparer.GetMassStart(nextBinNum); if (minMass < nextBinMass && nextBinMass < maxMass) { UpdateDeconvPeak(nextBinNum, p as DeconvolutedPeak); //_ionMassChkBins[nextBinNum] = true; } else { break; } } // going down for (var prevBinNum = binNum - 1; prevBinNum < comparer.NumberOfBins; prevBinNum--) { var prevBinMass = comparer.GetMassEnd(prevBinNum); if (minMass < prevBinMass && prevBinMass < maxMass) { UpdateDeconvPeak(prevBinNum, p as DeconvolutedPeak); //_ionMassChkBins[prevBinNum] = true; } else { break; } } } }
public void FilteringEfficiencyQcShew() { var methodName = MethodBase.GetCurrentMethod().Name; Utils.ShowStarting(methodName); var sw = new System.Diagnostics.Stopwatch(); sw.Start(); const string rawFilePath = @"C:\cygwin\home\kims336\Data\TopDownQCShew\raw\QC_ShewIntact_2ug_3k_CID_4Apr14_Bane_PL011402.raw"; if (!File.Exists(rawFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, rawFilePath); } var run = InMemoryLcMsRun.GetLcMsRun(rawFilePath, 1.4826, 1.4826); sw.Stop(); Console.WriteLine(@"Reading run: {0:f4} sec", sw.Elapsed.TotalSeconds); const int minPrecursorCharge = 3; const int maxPrecursorCharge = 30; const int tolerancePpm = 10; var tolerance = new Tolerance(tolerancePpm); sw.Reset(); sw.Start(); var ms1BasedFilter = new Ms1IsotopeAndChargeCorrFilter(run, new Tolerance(10.0), minPrecursorCharge, maxPrecursorCharge, 3000, 50000, 0.7, 0.7, 0.7, 40); //var ms1BasedFilter = new Ms1IsotopeCorrFilter(run, minPrecursorCharge, maxPrecursorCharge, 15, 0.5, 40); sw.Stop(); Console.WriteLine(@"Ms1 filter: {0:f4} sec", sw.Elapsed.TotalSeconds); ISequenceFilter ms1Filter = ms1BasedFilter; sw.Reset(); sw.Start(); const double minProteinMass = 3000.0; const double maxProteinMass = 30000.0; var minBinNum = ProductScorerBasedOnDeconvolutedSpectra.GetBinNumber(minProteinMass); var maxBinNum = ProductScorerBasedOnDeconvolutedSpectra.GetBinNumber(maxProteinMass); var numComparisons = 0L; for (var binNum = minBinNum; binNum <= maxBinNum; binNum++) { var mass = ProductScorerBasedOnDeconvolutedSpectra.GetMz(binNum); numComparisons += ms1Filter.GetMatchingMs2ScanNums(mass).Count(); } sw.Stop(); Console.WriteLine(@"Calculating #matches per bin: {0:f4} sec", sw.Elapsed.TotalSeconds); //const string prot = // "ADVFHLGLTKAMLDGATLAIVPGDPERVKRIAELMDNATFLASHREYTSYLAYADGKPVVICSTGIGGPSTSIAVEELAQLGVNTFLRVGTTGAIQPHVNVGDVIVTQASVRLDGASLHFAPMEFPAVANFECTTAMVAACRDAGVEPHIGVTASSDTFYPGQERYDTVTGRVTRRFAGSMKEWQDMGVLNYEMESATLFTMCATQGWRAACVAGVIVNRTQQEIPDEATMKKTEVSAVSIVVAAAKKLLA"; //var protMass = (new AminoAcidSet().GetComposition(prot) + Composition.H2O).Mass; //Console.WriteLine("************ScanNums: " + string.Join("\t", ms1Filter.GetMatchingMs2ScanNums(protMass))); const string resultFilePath = @"C:\cygwin\home\kims336\Data\TopDownQCShew\MSAlign\NoMod.tsv"; if (!File.Exists(resultFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, resultFilePath); } var tsvReader = new TsvFileParser(resultFilePath); var scanNums = tsvReader.GetData("Scan(s)"); var charges = tsvReader.GetData("Charge"); var scores = tsvReader.GetData("E-value"); var sequences = tsvReader.GetData("Peptide"); //const string resultFilePath = @"C:\cygwin\home\kims336\Data\TopDownQCShew\raw\QC_ShewIntact_2ug_3k_CID_4Apr14_Bane_PL011402_N30_C30.tsv"; //var tsvReader = new TsvFileParser(resultFilePath); //var scanNums = tsvReader.GetData("ScanNum"); //var charges = tsvReader.GetData("Charge"); //var scores = tsvReader.GetData("Score"); //var sequences = tsvReader.GetData("Sequence"); var aaSet = new AminoAcidSet(); var seqSet = new HashSet <string>(); var allSeqSet = new HashSet <string>(); var numUnfilteredSpecs = 0; var totalSpecs = 0; for (var i = 0; i < scores.Count; i++) { var score = Convert.ToDouble(scores[i]); if (score > 1E-4) { continue; } //if (score < 10) continue; var scanNum = Convert.ToInt32(scanNums[i]); var charge = Convert.ToInt32(charges[i]); var sequence = SimpleStringProcessing.GetStringBetweenDots(sequences[i]); if (sequence == null || sequence.Contains("(")) { continue; } //var sequence = sequences[i]; var composition = aaSet.GetComposition(sequence) + Composition.H2O; var precursorIon = new Ion(composition, charge); var isValid = run.GetSpectrum(scanNum) is ProductSpectrum spec && spec.IsolationWindow.Contains(precursorIon.GetMostAbundantIsotopeMz()); if (!isValid) { continue; } ++totalSpecs; var precursorScanNum = run.GetPrecursorScanNum(scanNum); var precursorSpec = run.GetSpectrum(precursorScanNum); var corr1 = precursorSpec.GetCorrScore(precursorIon, tolerance, 0.1); var nextScanNum = run.GetNextScanNum(scanNum, 1); var nextSpec = run.GetSpectrum(nextScanNum); var corr2 = nextSpec.GetCorrScore(precursorIon, tolerance, 0.1); var corr3 = ms1Filter.GetMatchingMs2ScanNums(composition.Mass).Contains(scanNum) ? 1 : 0; if (corr3 == 1) { numUnfilteredSpecs++; seqSet.Add(sequences[i]); } allSeqSet.Add(sequences[i]); var corrMax = new[] { corr1, corr2, corr3 }.Max(); Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}", scanNum, precursorScanNum, corr1, nextScanNum, corr2, corr3, corrMax); } Console.WriteLine("TotalNumComparisons: {0}", numComparisons); Console.WriteLine("AverageNumComparisons: {0:f2}", numComparisons / (double)(maxBinNum - minBinNum + 1)); Console.WriteLine("SuccessRate: {0:f2} {1} / {2}", numUnfilteredSpecs / (double)totalSpecs, numUnfilteredSpecs, totalSpecs); Console.WriteLine("NumUniqueSequences: {0:f2}, {1} / {2}", seqSet.Count / (double)allSeqSet.Count, seqSet.Count, allSeqSet.Count); Console.WriteLine(@"Elapsed Time: {0:f4} sec", sw.Elapsed.TotalSeconds); }
protected override MyTaskResults RunSpecific(string OutputFolder, List <DbForTask> dbFilenameList, List <string> currentRawFileList, string taskId, FileSpecificParameters[] fileSettingsList) { LoadModifications(taskId, out var variableModifications, out var fixedModifications, out var localizeableModificationTypes); // TODO: print error messages loading GPTMD mods List <Modification> gptmdModifications = GlobalVariables.AllModsKnown.OfType <Modification>().Where(b => GptmdParameters.ListOfModsGptmd.Contains((b.ModificationType, b.IdWithMotif))).ToList(); IEnumerable <Tuple <double, double> > combos = LoadCombos(gptmdModifications).ToList(); // load proteins List <Protein> proteinList = LoadProteins(taskId, dbFilenameList, true, DecoyType.Reverse, localizeableModificationTypes, CommonParameters); List <PeptideSpectralMatch> allPsms = new List <PeptideSpectralMatch>(); var numRawFiles = currentRawFileList.Count; // write prose settings ProseCreatedWhileRunning.Append("The following G-PTM-D settings were used: "); ProseCreatedWhileRunning.Append("protease = " + CommonParameters.DigestionParams.Protease + "; "); ProseCreatedWhileRunning.Append("maximum missed cleavages = " + CommonParameters.DigestionParams.MaxMissedCleavages + "; "); ProseCreatedWhileRunning.Append("minimum peptide length = " + CommonParameters.DigestionParams.MinPeptideLength + "; "); ProseCreatedWhileRunning.Append(CommonParameters.DigestionParams.MaxPeptideLength == int.MaxValue ? "maximum peptide length = unspecified; " : "maximum peptide length = " + CommonParameters.DigestionParams.MaxPeptideLength + "; "); ProseCreatedWhileRunning.Append("initiator methionine behavior = " + CommonParameters.DigestionParams.InitiatorMethionineBehavior + "; "); ProseCreatedWhileRunning.Append("max modification isoforms = " + CommonParameters.DigestionParams.MaxModificationIsoforms + "; "); ProseCreatedWhileRunning.Append("fixed modifications = " + string.Join(", ", fixedModifications.Select(m => m.IdWithMotif)) + "; "); ProseCreatedWhileRunning.Append("variable modifications = " + string.Join(", ", variableModifications.Select(m => m.IdWithMotif)) + "; "); ProseCreatedWhileRunning.Append("G-PTM-D modifications count = " + gptmdModifications.Count + "; "); // temporary search type for writing prose // the actual search type is technically file-specific but we don't allow file-specific notches, so it's safe to do this MassDiffAcceptor tempSearchMode = new DotMassDiffAcceptor("", GetAcceptableMassShifts(fixedModifications, variableModifications, gptmdModifications, combos), CommonParameters.PrecursorMassTolerance); ProseCreatedWhileRunning.Append("precursor mass tolerance(s) = {" + tempSearchMode.ToProseString() + "}; "); ProseCreatedWhileRunning.Append("product mass tolerance = " + CommonParameters.ProductMassTolerance + ". "); ProseCreatedWhileRunning.Append("The combined search database contained " + proteinList.Count(p => !p.IsDecoy) + " non-decoy protein entries including " + proteinList.Where(p => p.IsContaminant).Count() + " contaminant sequences. "); // start the G-PTM-D task Status("Running G-PTM-D...", new List <string> { taskId }); MyTaskResults = new MyTaskResults(this) { NewDatabases = new List <DbForTask>() }; var fileSpecificCommonParams = fileSettingsList.Select(b => SetAllFileSpecificCommonParams(CommonParameters, b)); HashSet <DigestionParams> ListOfDigestionParams = new HashSet <DigestionParams>(fileSpecificCommonParams.Select(p => p.DigestionParams)); MyFileManager myFileManager = new MyFileManager(true); object lock1 = new object(); object lock2 = new object(); for (int spectraFileIndex = 0; spectraFileIndex < currentRawFileList.Count; spectraFileIndex++) { // Stop if canceled if (GlobalVariables.StopLoops) { break; } var origDataFile = currentRawFileList[spectraFileIndex]; // mark the file as in-progress StartingDataFile(origDataFile, new List <string> { taskId, "Individual Spectra Files", origDataFile }); CommonParameters combinedParams = SetAllFileSpecificCommonParams(CommonParameters, fileSettingsList[spectraFileIndex]); MassDiffAcceptor searchMode = new DotMassDiffAcceptor("", GetAcceptableMassShifts(fixedModifications, variableModifications, gptmdModifications, combos), combinedParams.PrecursorMassTolerance); NewCollection(Path.GetFileName(origDataFile), new List <string> { taskId, "Individual Spectra Files", origDataFile }); Status("Loading spectra file...", new List <string> { taskId, "Individual Spectra Files", origDataFile }); MsDataFile myMsDataFile = myFileManager.LoadFile(origDataFile, combinedParams); Status("Getting ms2 scans...", new List <string> { taskId, "Individual Spectra Files", origDataFile }); Ms2ScanWithSpecificMass[] arrayOfMs2ScansSortedByMass = GetMs2Scans(myMsDataFile, origDataFile, combinedParams).OrderBy(b => b.PrecursorMass).ToArray(); myFileManager.DoneWithFile(origDataFile); PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[arrayOfMs2ScansSortedByMass.Length]; new ClassicSearchEngine(allPsmsArray, arrayOfMs2ScansSortedByMass, variableModifications, fixedModifications, null, proteinList, searchMode, combinedParams, new List <string> { taskId, "Individual Spectra Files", origDataFile }).Run(); allPsms.AddRange(allPsmsArray.Where(p => p != null)); FinishedDataFile(origDataFile, new List <string> { taskId, "Individual Spectra Files", origDataFile }); ReportProgress(new ProgressEventArgs(100, "Done!", new List <string> { taskId, "Individual Spectra Files", origDataFile })); } ReportProgress(new ProgressEventArgs(100, "Done!", new List <string> { taskId, "Individual Spectra Files" })); allPsms = allPsms.OrderByDescending(b => b.Score) .ThenBy(b => b.PeptideMonisotopicMass.HasValue ? Math.Abs(b.ScanPrecursorMass - b.PeptideMonisotopicMass.Value) : double.MaxValue) .GroupBy(b => new Tuple <string, int, double?>(b.FullFilePath, b.ScanNumber, b.PeptideMonisotopicMass)) .Select(b => b.First()).ToList(); new FdrAnalysisEngine(allPsms, tempSearchMode.NumNotches, CommonParameters, new List <string> { taskId }).Run(); var writtenFile = Path.Combine(OutputFolder, "GPTMD_Candidates.psmtsv"); WritePsmsToTsv(allPsms, writtenFile, new Dictionary <string, int>()); FinishedWritingFile(writtenFile, new List <string> { taskId }); // get file-specific precursor mass tolerances for the GPTMD engine var filePathToPrecursorMassTolerance = new Dictionary <string, Tolerance>(); for (int i = 0; i < currentRawFileList.Count; i++) { string filePath = currentRawFileList[i]; Tolerance fileTolerance = CommonParameters.PrecursorMassTolerance; if (fileSettingsList[i] != null && fileSettingsList[i].PrecursorMassTolerance != null) { fileTolerance = fileSettingsList[i].PrecursorMassTolerance; } filePathToPrecursorMassTolerance.Add(filePath, fileTolerance); } // run GPTMD engine var gptmdResults = (GptmdResults) new GptmdEngine(allPsms, gptmdModifications, combos, filePathToPrecursorMassTolerance, CommonParameters, new List <string> { taskId }).Run(); // Stop if canceled if (GlobalVariables.StopLoops) { return(MyTaskResults); } // write GPTMD databases if (dbFilenameList.Any(b => !b.IsContaminant)) { List <string> databaseNames = new List <string>(); foreach (var nonContaminantDb in dbFilenameList.Where(p => !p.IsContaminant)) { var dbName = Path.GetFileNameWithoutExtension(nonContaminantDb.FilePath); var theExtension = Path.GetExtension(nonContaminantDb.FilePath).ToLowerInvariant(); bool compressed = theExtension.EndsWith("gz"); databaseNames.Add(compressed ? Path.GetFileNameWithoutExtension(dbName) : dbName); } string outputXMLdbFullName = Path.Combine(OutputFolder, string.Join("-", databaseNames) + "GPTMD.xml"); var newModsActuallyWritten = ProteinDbWriter.WriteXmlDatabase(gptmdResults.Mods, proteinList.Where(b => !b.IsDecoy && !b.IsContaminant).ToList(), outputXMLdbFullName); FinishedWritingFile(outputXMLdbFullName, new List <string> { taskId }); MyTaskResults.NewDatabases.Add(new DbForTask(outputXMLdbFullName, false)); MyTaskResults.AddNiceText("Modifications added: " + newModsActuallyWritten.Select(b => b.Value).Sum()); MyTaskResults.AddNiceText("Mods types and counts:"); MyTaskResults.AddNiceText(string.Join(Environment.NewLine, newModsActuallyWritten.OrderByDescending(b => b.Value).Select(b => "\t" + b.Key + "\t" + b.Value))); } if (dbFilenameList.Any(b => b.IsContaminant)) { // do NOT use this code (Path.GetFilenameWithoutExtension) because GPTMD on .xml.gz will result in .xml.xml file type being written //string outputXMLdbFullNameContaminants = Path.Combine(OutputFolder, string.Join("-", dbFilenameList.Where(b => b.IsContaminant).Select(b => Path.GetFileNameWithoutExtension(b.FilePath))) + "GPTMD.xml"); List <string> databaseNames = new List <string>(); foreach (var contaminantDb in dbFilenameList.Where(p => p.IsContaminant)) { var dbName = Path.GetFileName(contaminantDb.FilePath); int indexOfFirstDot = dbName.IndexOf("."); databaseNames.Add(dbName.Substring(0, indexOfFirstDot)); } string outputXMLdbFullNameContaminants = Path.Combine(OutputFolder, string.Join("-", databaseNames) + "GPTMD.xml"); var newModsActuallyWritten = ProteinDbWriter.WriteXmlDatabase(gptmdResults.Mods, proteinList.Where(b => !b.IsDecoy && b.IsContaminant).ToList(), outputXMLdbFullNameContaminants); FinishedWritingFile(outputXMLdbFullNameContaminants, new List <string> { taskId }); MyTaskResults.NewDatabases.Add(new DbForTask(outputXMLdbFullNameContaminants, true)); MyTaskResults.AddNiceText("Contaminant modifications added: " + newModsActuallyWritten.Select(b => b.Value).Sum()); MyTaskResults.AddNiceText("Mods types and counts:"); MyTaskResults.AddNiceText(string.Join(Environment.NewLine, newModsActuallyWritten.OrderByDescending(b => b.Value).Select(b => "\t" + b.Key + "\t" + b.Value))); } return(MyTaskResults); }
public void FilteringEfficiency() { var methodName = MethodBase.GetCurrentMethod().Name; Utils.ShowStarting(methodName); var sw = new System.Diagnostics.Stopwatch(); sw.Start(); const string rawFilePath = @"C:\cygwin\home\kims336\Data\TopDown\raw\SBEP_STM_001_02272012_Aragon.raw"; if (!File.Exists(rawFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, rawFilePath); } var run = InMemoryLcMsRun.GetLcMsRun(rawFilePath, 1.4826, 1.4826); sw.Stop(); Console.WriteLine(@"Reading run: {0:f4} sec", sw.Elapsed.TotalSeconds); const int minPrecursorCharge = 3; const int maxPrecursorCharge = 30; const int tolerancePpm = 10; var tolerance = new Tolerance(tolerancePpm); sw.Reset(); sw.Start(); //var ms1BasedFilter = new Ms1BasedFilter(run, minPrecursorCharge, maxPrecursorCharge, tolerancePpm); // //var ms1BasedFilter = new Ms1IsotopeTopKFilter(run, minPrecursorCharge, maxPrecursorCharge, tolerancePpm, 20); //var ms1BasedFilter = new ProductScorerBasedOnDeconvolutedSpectra(run, // minPrecursorCharge, maxPrecursorCharge, // 0, 0, // 600.0, 1800.0, new Tolerance(tolerancePpm), null); //ms1BasedFilter.CachePrecursorMatchesBinCentric(); var ms1BasedFilter = new Ms1IsotopeAndChargeCorrFilter(run, new Tolerance(10.0), minPrecursorCharge, maxPrecursorCharge, 3000, 50000, 0.5, 0.5, 0.5, 40); //var ms1BasedFilter = new Ms1IsotopeCorrFilter(run, minPrecursorCharge, maxPrecursorCharge, 15, 0.5, 40); sw.Stop(); Console.WriteLine(@"Ms1 filter: {0:f4} sec", sw.Elapsed.TotalSeconds); ISequenceFilter ms1Filter = ms1BasedFilter; sw.Reset(); sw.Start(); const double minProteinMass = 3000.0; const double maxProteinMass = 30000.0; var minBinNum = ProductScorerBasedOnDeconvolutedSpectra.GetBinNumber(minProteinMass); var maxBinNum = ProductScorerBasedOnDeconvolutedSpectra.GetBinNumber(maxProteinMass); var numComparisons = 0L; for (var binNum = minBinNum; binNum <= maxBinNum; binNum++) { var mass = ProductScorerBasedOnDeconvolutedSpectra.GetMz(binNum); numComparisons += ms1Filter.GetMatchingMs2ScanNums(mass).Count(); } sw.Stop(); Console.WriteLine(@"Calculating #matches per bin: {0:f4} sec", sw.Elapsed.TotalSeconds); const string resultFilePath = @"C:\cygwin\home\kims336\Data\TopDown\raw\SBEP_STM_001_02272012_Aragon_4PTMs.icresult"; if (!File.Exists(resultFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, resultFilePath); } var tsvReader = new TsvFileParser(resultFilePath); var compositions = tsvReader.GetData("Composition"); var scanNums = tsvReader.GetData("ScanNum"); var charges = tsvReader.GetData("Charge"); var scores = tsvReader.GetData("Score"); var qvalues = tsvReader.GetData("QValue"); var sequences = tsvReader.GetData("Sequence"); var sequenceCount = new Dictionary <string, int>(); for (var i = 0; i < compositions.Count; i++) { if (qvalues != null) { var qValue = Convert.ToDouble(qvalues[i]); if (qValue > 0.01) { continue; } } else { var score = Convert.ToDouble(scores[i]); if (score < 13) { continue; } } var scanNum = Convert.ToInt32(scanNums[i]); var charge = Convert.ToInt32(charges[i]); var composition = Composition.Parse(compositions[i]); var precursorIon = new Ion(composition, charge); var isValid = run.GetSpectrum(scanNum) is ProductSpectrum spec && spec.IsolationWindow.Contains(precursorIon.GetMostAbundantIsotopeMz()); if (!isValid) { continue; } var sequence = sequences[i]; if (sequenceCount.TryGetValue(sequence, out var count)) { sequenceCount[sequence] = count + 1; } else { sequenceCount[sequence] = 1; } } //var sequences = tsvReader.GetData("Annotation"); var seqSet = new HashSet <string>(); var allSeqSet = new HashSet <string>(); var numUnfilteredSpecs = 0; var totalSpecs = 0; for (var i = 0; i < compositions.Count; i++) { if (qvalues != null) { var qValue = Convert.ToDouble(qvalues[i]); if (qValue > 0.01) { continue; } } else { var score = Convert.ToDouble(scores[i]); if (score < 13) { continue; } } var scanNum = Convert.ToInt32(scanNums[i]); var charge = Convert.ToInt32(charges[i]); var composition = Composition.Parse(compositions[i]); var precursorIon = new Ion(composition, charge); var isValid = run.GetSpectrum(scanNum) is ProductSpectrum spec && spec.IsolationWindow.Contains(precursorIon.GetMostAbundantIsotopeMz()); if (!isValid) { continue; } ++totalSpecs; var precursorScanNum = run.GetPrecursorScanNum(scanNum); var precursorSpec = run.GetSpectrum(precursorScanNum); var corr1 = precursorSpec.GetCorrScore(precursorIon, tolerance, 0.1); var nextScanNum = run.GetNextScanNum(scanNum, 1); var nextSpec = run.GetSpectrum(nextScanNum); var corr2 = nextSpec.GetCorrScore(precursorIon, tolerance, 0.1); var corr3 = ms1Filter.GetMatchingMs2ScanNums(composition.Mass).Contains(scanNum) ? 1 : 0; if (corr3 == 1) { numUnfilteredSpecs++; seqSet.Add(sequences[i]); } allSeqSet.Add(sequences[i]); //var xic = run.GetFullPrecursorIonExtractedIonChromatogram(precursorIon.GetMostAbundantIsotopeMz(), tolerance); ////xic.Display(); //var apexScanNum = xic.GetNearestApexScanNum(run.GetPrecursorScanNum(scanNum), false); //var apexSpec = run.GetSpectrum(apexScanNum); //var corr3 = apexSpec.GetCorrScore(precursorIon, tolerance, 0.1); var corrMax = new[] { corr1, corr2, corr3 }.Max(); Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}", scanNum, precursorScanNum, corr1, nextScanNum, corr2, corr3, corrMax, sequenceCount[sequences[i]]); } Console.WriteLine("TotalNumComparisons: {0}", numComparisons); Console.WriteLine("AverageNumComparisons: {0:f2}", numComparisons / (double)(maxBinNum - minBinNum + 1)); Console.WriteLine("SuccessRate: {0:f2} {1} / {2}", numUnfilteredSpecs / (double)totalSpecs, numUnfilteredSpecs, totalSpecs); Console.WriteLine("NumUniqueSequences: {0:f2}, {1} / {2}", seqSet.Count / (double)allSeqSet.Count, seqSet.Count, allSeqSet.Count); Console.WriteLine(@"Elapsed Time: {0:f4} sec", sw.Elapsed.TotalSeconds); }
public static void MatchIons(IMsDataScan <IMzSpectrum <IMzPeak> > thisScan, Tolerance productMassTolerance, double[] sortedTheoreticalProductMassesForThisPeptide, List <double> matchedIonMassesList, List <double> productMassErrorDa, List <double> productMassErrorPpm, double precursorMass, List <DissociationType> dissociationTypes, bool addCompIons) { var TotalProductsHere = sortedTheoreticalProductMassesForThisPeptide.Length; if (TotalProductsHere == 0) { return; } int currentTheoreticalIndex = -1; double currentTheoreticalMass; do { currentTheoreticalIndex++; currentTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[currentTheoreticalIndex]; } while (double.IsNaN(currentTheoreticalMass) && currentTheoreticalIndex < sortedTheoreticalProductMassesForThisPeptide.Length - 1); if (double.IsNaN(currentTheoreticalMass)) { return; } double currentTheoreticalMz = currentTheoreticalMass + Constants.protonMass; int testTheoreticalIndex; double testTheoreticalMass; double testTheoreticalMz; // speed optimizations double[] experimental_mzs = thisScan.MassSpectrum.XArray; double[] experimental_intensities = thisScan.MassSpectrum.YArray; int numExperimentalPeaks = experimental_mzs.Length; // Loop over all experimental indices for (int experimentalIndex = 0; experimentalIndex < numExperimentalPeaks; experimentalIndex++) { double currentExperimentalMz = experimental_mzs[experimentalIndex]; // If found match if (productMassTolerance.Within(currentExperimentalMz, currentTheoreticalMz)) { matchedIonMassesList.Add(currentTheoreticalMass); double currentExperimentalMass = currentExperimentalMz - Constants.protonMass; productMassErrorDa.Add(currentExperimentalMass - currentTheoreticalMass); productMassErrorPpm.Add((currentExperimentalMass - currentTheoreticalMass) * 1000000 / currentTheoreticalMass); currentTheoreticalIndex++; if (currentTheoreticalIndex == TotalProductsHere) { break; } currentTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[currentTheoreticalIndex]; currentTheoreticalMz = currentTheoreticalMass + Constants.protonMass; } // Else if for sure did not reach the next theoretical yet else if (currentExperimentalMz > currentTheoreticalMz) { // Move on to next index and never come back! currentTheoreticalIndex++; if (currentTheoreticalIndex == TotalProductsHere) { break; } currentTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[currentTheoreticalIndex]; currentTheoreticalMz = currentTheoreticalMass + Constants.protonMass; // Start with the current ones testTheoreticalIndex = currentTheoreticalIndex; testTheoreticalMass = currentTheoreticalMass; testTheoreticalMz = currentTheoreticalMz; // Mark the skipped theoreticals as not found. The last one is not for sure, might be flipped! while (currentExperimentalMz > testTheoreticalMz) { // Store old info for possible reuse currentTheoreticalMz = testTheoreticalMz; currentTheoreticalMass = testTheoreticalMass; currentTheoreticalIndex = testTheoreticalIndex; // Update test stuff! testTheoreticalIndex++; if (testTheoreticalIndex == TotalProductsHere) { break; } testTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[testTheoreticalIndex]; testTheoreticalMz = testTheoreticalMass + Constants.protonMass; } experimentalIndex--; } } if (addCompIons) { double[] complementaryMasses = new double[numExperimentalPeaks]; double[] complementaryIntensities = new double[numExperimentalPeaks]; foreach (DissociationType dissociationType in dissociationTypes) { if (complementaryIonConversionDictionary.TryGetValue(dissociationType, out double protonMassShift)) { currentTheoreticalIndex = -1; do { currentTheoreticalIndex++; currentTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[currentTheoreticalIndex]; } while (double.IsNaN(currentTheoreticalMass) && currentTheoreticalIndex < sortedTheoreticalProductMassesForThisPeptide.Length - 1); double massShiftForComplementaryConversion = precursorMass + protonMassShift; //mass shift needed to reobtain the original product ion for calculating tolerance for (int i = numExperimentalPeaks - 1; i >= 0; i--) { complementaryMasses[numExperimentalPeaks - i - 1] = massShiftForComplementaryConversion - experimental_mzs[i]; complementaryIntensities[numExperimentalPeaks - i - 1] = experimental_intensities[i]; } // Loop over all experimental indices for (int experimentalIndex = 0; experimentalIndex < numExperimentalPeaks; experimentalIndex++) { double currentExperimentalMass = complementaryMasses[experimentalIndex]; double originalExperimentalMass = massShiftForComplementaryConversion - currentExperimentalMass; double minBoundary = currentExperimentalMass - originalExperimentalMass + productMassTolerance.GetMinimumValue(originalExperimentalMass); double maxBoundary = currentExperimentalMass - originalExperimentalMass + productMassTolerance.GetMaximumValue(originalExperimentalMass); // If found match if (minBoundary < currentTheoreticalMass && maxBoundary > currentTheoreticalMass) { matchedIonMassesList.Add(currentTheoreticalMass); productMassErrorDa.Add(currentExperimentalMass - currentTheoreticalMass); productMassErrorPpm.Add((currentExperimentalMass - currentTheoreticalMass) * 1000000 / currentTheoreticalMass); currentTheoreticalIndex++; if (currentTheoreticalIndex == TotalProductsHere) { break; } currentTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[currentTheoreticalIndex]; } // Else if for sure passed a theoretical else if (currentExperimentalMass > currentTheoreticalMass) { // Move on to next index and never come back! currentTheoreticalIndex++; if (currentTheoreticalIndex == TotalProductsHere) { break; } currentTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[currentTheoreticalIndex]; // Start with the current ones testTheoreticalIndex = currentTheoreticalIndex; testTheoreticalMass = currentTheoreticalMass; // Mark the skipped theoreticals as not found. The last one is not for sure, might be flipped! while (currentExperimentalMass > testTheoreticalMass) { // Store old info for possible reuse currentTheoreticalMass = testTheoreticalMass; currentTheoreticalIndex = testTheoreticalIndex; // Update test stuff! testTheoreticalIndex++; if (testTheoreticalIndex == TotalProductsHere) { break; } testTheoreticalMass = sortedTheoreticalProductMassesForThisPeptide[testTheoreticalIndex]; } experimentalIndex--; } } } else { throw new NotImplementedException(); } } } }
public void TestMs1Filtering() { var methodName = MethodBase.GetCurrentMethod().Name; Utils.ShowStarting(methodName); const string resultFilePath = // @"C:\cygwin\home\kims336\Data\TopDown\raw\CorrMatches_N30\SBEP_STM_001_02272012_Aragon.tsv"; @"C:\cygwin\home\kims336\Data\TopDown\raw\CorrMatches_N30\SBEP_STM_001_02272012_Aragon.decoy.icresult"; if (!File.Exists(resultFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, resultFilePath); } const string rawFilePath = @"C:\cygwin\home\kims336\Data\TopDown\raw\DataFiles\SBEP_STM_001_02272012_Aragon.raw"; if (!File.Exists(rawFilePath)) { Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, rawFilePath); } var run = InMemoryLcMsRun.GetLcMsRun(rawFilePath, 1.4826, 1.4826); //const int minPrecursorCharge = 3; //const int maxPrecursorCharge = 30; //const int tolerancePpm = 15; var tolerance = new Tolerance(15); //var ms1BasedFilter = new Ms1IsotopeCorrFilter(run, minPrecursorCharge, maxPrecursorCharge, tolerancePpm, 0.7, 40); ////var ms1BasedFilter = new Ms1IsotopeTopKFilter(run, minPrecursorCharge, maxPrecursorCharge, tolerancePpm, 20); //ISequenceFilter ms1Filter = ms1BasedFilter; var tsvReader = new TsvFileParser(resultFilePath); var compositions = tsvReader.GetData("Composition"); var scanNums = tsvReader.GetData("ScanNum"); var charges = tsvReader.GetData("Charge"); var qValues = tsvReader.GetData("QValue"); var scores = tsvReader.GetData("Score"); //var sequences = tsvReader.GetData("Annotation"); //var hist = new int[11]; Console.WriteLine("ScanNum\tScore\tPrecursor\tNext\tSum\tNextIsotope\tLessCharge\tMoreCharge\tMax\tNumXicPeaks"); for (var i = 0; i < compositions.Count; i++) { if (qValues != null) { var qValue = Convert.ToDouble(qValues[i]); if (qValue > 0.01) { continue; } } var scanNum = Convert.ToInt32(scanNums[i]); var composition = Composition.Parse(compositions[i]); var charge = Convert.ToInt32(charges[i]); var precursorIon = new Ion(composition, charge); var isValid = run.GetSpectrum(scanNum) is ProductSpectrum spec && spec.IsolationWindow.Contains(precursorIon.GetMostAbundantIsotopeMz()); if (!isValid) { continue; } var score = Convert.ToDouble(scores[i]); var precursorScanNum = run.GetPrecursorScanNum(scanNum); var precursorSpec = run.GetSpectrum(precursorScanNum); var preIsotopeCorr = precursorSpec.GetCorrScore(precursorIon, tolerance, 0.1); var nextScanNum = run.GetNextScanNum(scanNum, 1); var nextSpec = run.GetSpectrum(nextScanNum); var nextIsotopeCorr = nextSpec.GetCorrScore(precursorIon, tolerance, 0.1); var xicMostAbundant = run.GetPrecursorExtractedIonChromatogram(precursorIon.GetMostAbundantIsotopeMz(), tolerance, scanNum); var apexScanNum = xicMostAbundant.GetApexScanNum(); if (apexScanNum < run.MinLcScan) { apexScanNum = scanNum; } //var sumSpec = run.GetSummedMs1Spectrum(apexScanNum); // var apexIsotopeCorr = sumSpec.GetCorrScore(precursorIon, tolerance, 0.1); // var corr3 = ms1Filter.GetMatchingMs2ScanNums(composition.Mass).Contains(scanNum) ? 1 : 0; var xicNextIsotope = run.GetPrecursorExtractedIonChromatogram(precursorIon.GetMostAbundantIsotopeMz() + Constants.C13MinusC12 / charge, tolerance, scanNum); var plusOneIsotopeCorr = xicMostAbundant.GetCorrelation(xicNextIsotope); var precursorIonChargeMinusOne = new Ion(composition, charge - 1); var xicChargeMinusOne = run.GetPrecursorExtractedIonChromatogram(precursorIonChargeMinusOne.GetMostAbundantIsotopeMz(), tolerance, scanNum); var chargeMinusOneCorr = xicMostAbundant.GetCorrelation(xicChargeMinusOne); var precursorIonChargePlusOne = new Ion(composition, charge + 1); var xicChargePlusOne = run.GetPrecursorExtractedIonChromatogram(precursorIonChargePlusOne.GetMostAbundantIsotopeMz(), tolerance, scanNum); var chargePlusOneCorr = xicMostAbundant.GetCorrelation(xicChargePlusOne); //var max = new[] {preIsotopeCorr, nextIsotopeCorr, apexIsotopeCorr, plusOneIsotopeCorr, chargeMinusOneCorr, chargePlusOneCorr}.Max(); //Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}\t{8}\t{9}", // scanNum, score, preIsotopeCorr, nextIsotopeCorr, apexIsotopeCorr, plusOneIsotopeCorr, chargeMinusOneCorr, chargePlusOneCorr, max, xicMostAbundant.Count); } //Console.WriteLine("Histogram"); //for (var i = 0; i < hist.Length; i++) //{ // Console.WriteLine("{0:f1}\t{1}", i / 10.0, hist[i]); //} }
/// <summary> /// Gets a value indicating whether the specified point is on the segment defined by two points. /// </summary> /// <param name="pt">The instance to which the method applies.</param> /// <param name="p1">The segment start point.</param> /// <param name="p2">The segment end point.</param> /// <param name="tol">The tolerance used in comparisons.</param> /// <returns>true if the point is on the segment; otherwise, false.</returns> public static bool IsBetween(this Point2d pt, Point2d p1, Point2d p2, Tolerance tol) { return(p1.GetVectorTo(pt).GetNormal(tol).Equals(pt.GetVectorTo(p2).GetNormal(tol))); }
//Calculate score based on All possible Products Masses for inter- or intra- crosslinks and deadend. public static void XlLocalization(Ms2ScanWithSpecificMass theScan, PsmCross psmCross, double modMass, CrosslinkerTypeClass crosslinker, List <ProductType> lp, Tolerance fragmentTolerance, bool Charge_2_3, bool Charge_2_3_PrimeFragment, List <int> linkPos) { var pmmhList = PsmCross.XlCalculateTotalProductMasses(psmCross, modMass, crosslinker, lp, Charge_2_3, Charge_2_3_PrimeFragment, linkPos); List <double> scoreList = new List <double>(); List <MatchedIonInfo> miil = new List <MatchedIonInfo>(); foreach (var pmm in pmmhList) { var matchedIonMassesListPositiveIsMatch = new MatchedIonInfo(pmm.ProductMz.Length); double pmmScore = PsmCross.XlMatchIons(theScan.TheScan, fragmentTolerance, pmm.ProductMz, pmm.ProductName, matchedIonMassesListPositiveIsMatch); miil.Add(matchedIonMassesListPositiveIsMatch); scoreList.Add(pmmScore); } psmCross.XLBestScore = scoreList.Max(); psmCross.MatchedIonInfo = miil[scoreList.IndexOf(scoreList.Max())]; psmCross.XlPos = pmmhList[scoreList.IndexOf(scoreList.Max())].XlPos + 1; if (crosslinker.Cleavable) { psmCross.ParentIonMaxIntensityRanks = new List <int>(); if (psmCross.MatchedIonInfo.MatchedIonName.Any(p => p != null && p.Contains("PepS"))) { psmCross.ParentIonExist += "PepS"; psmCross.ParentIonExistNum += 1; } if (psmCross.MatchedIonInfo.MatchedIonName.Any(p => p != null && p.Contains("PepL"))) { psmCross.ParentIonExist += "PepL"; psmCross.ParentIonExistNum += 1; } //if (psmCross.MatchedIonInfo.MatchedIonName.Any(p => p != null && p.Equals("PepS2"))) //{ // psmCross.ParentIonExist += "PepS2"; // psmCross.ParentIonExistNum += 1; //} //if (psmCross.MatchedIonInfo.MatchedIonName.Any(p => p != null && p.Equals("PepL2"))) //{ // psmCross.ParentIonExist += "PepL2"; // psmCross.ParentIonExistNum += 1; //} for (int i = 0; i < psmCross.MatchedIonInfo.MatchedIonName.Length; i++) { if (psmCross.MatchedIonInfo.MatchedIonName[i] != null) { if (psmCross.MatchedIonInfo.MatchedIonName[i].Contains("Pep")) { psmCross.ParentIonMaxIntensityRanks.Add(psmCross.MatchedIonInfo.MatchedIonIntensityRank[i]); } } } } if (Charge_2_3 || Charge_2_3_PrimeFragment) { int Charge2IonExist = 0; for (int i = 0; i < psmCross.MatchedIonInfo.MatchedIonName.Length; i++) { if (psmCross.MatchedIonInfo.MatchedIonName[i] != null && (psmCross.MatchedIonInfo.MatchedIonName[i].Contains("t2") || psmCross.MatchedIonInfo.MatchedIonName[i].Contains("t3"))) { Charge2IonExist++; } } psmCross.Charge2IonExist = Charge2IonExist; } }
public void TestFeatureAlignment() { const string outFilePath = @"\\protoapps\UserData\Jungkap\Lewy\aligned\promex_crosstab_temp.tsv"; //CPTAC_Intact_CR32A_24Aug15_Bane_15-02-06-RZ var prsmReader = new ProteinSpectrumMatchReader(); var tolerance = new Tolerance(10); var alignment = new LcMsFeatureAlignment(new AnalysisCompRef.CompRefFeatureComparer(tolerance)); for (var i = 0; i < DATASET_COUNT; i++) { var rawFile = string.Format(@"{0}\{1}.pbf", PbfPath, GetDataSetNames(i)); var mspFile = string.Format(@"{0}\{1}_IcTda.tsv", MsPfFolder, GetDataSetNames(i)); var mspFile2 = string.Format(@"{0}\{1}_IcTda.tsv", MsPfFolder2, GetDataSetNames(i)); var ms1FtFile = string.Format(@"{0}\{1}.ms1ft", Ms1FtFolder, GetDataSetNames(i)); if (!File.Exists(rawFile)) { Console.WriteLine("Skipping test since file not found: " + rawFile); continue; } if (!File.Exists(ms1FtFile)) { Console.WriteLine("Skipping test since file not found: " + ms1FtFile); continue; } if (!File.Exists(mspFile)) { Console.WriteLine("Skipping test since file not found: " + mspFile); continue; } if (!File.Exists(mspFile2)) { Console.WriteLine("Skipping test since file not found: " + mspFile2); continue; } Console.WriteLine(rawFile); var run = PbfLcMsRun.GetLcMsRun(rawFile); var prsmList1 = prsmReader.LoadIdentificationResult(mspFile, ProteinSpectrumMatch.SearchTool.MsPathFinder); var prsmList2 = prsmReader.LoadIdentificationResult(mspFile2, ProteinSpectrumMatch.SearchTool.MsPathFinder); prsmList1.AddRange(prsmList2); var prsmList = MergePrsm(prsmList1); var features = LcMsFeatureAlignment.LoadProMexResult(i, ms1FtFile, run); foreach (var match in prsmList) { match.ProteinId = match.ProteinName; } // tag features by PrSMs foreach (var feature in features) { //features[j].ProteinSpectrumMatches = new ProteinSpectrumMatchSet(i); var massTol = tolerance.GetToleranceAsMz(feature.Mass); foreach (var match in prsmList) { if (feature.MinScanNum < match.ScanNum && match.ScanNum < feature.MaxScanNum && Math.Abs(feature.Mass - match.Mass) < massTol) { feature.ProteinSpectrumMatches.Add(match); } } } alignment.AddDataSet(i, features, run); } if (alignment.CountDatasets == 0) { Assert.Ignore("Skipping test since input data files were found"); } alignment.AlignFeatures(); Console.WriteLine("{0} alignments ", alignment.CountAlignedFeatures); for (var i = 0; i < DATASET_COUNT; i++) { alignment.FillMissingFeatures(i); Console.WriteLine("{0} has been processed", GetDataSetNames(i)); } OutputCrossTabWithId(outFilePath, alignment); }
//Calculate score based on All possible Products Masses for inter- or intra- crosslinks and deadend. public static void XlLocalizationForLoopCrosslink(Ms2ScanWithSpecificMass theScan, PsmCross psmCross, double modMass, CrosslinkerTypeClass crosslinker, List <ProductType> lp, Tolerance fragmentTolerance, List <int> linkPos) { var pmmhList = PsmCross.XlCalculateTotalProductMassesForLoopCrosslink(psmCross, modMass, crosslinker, lp, linkPos); List <double> scoreList = new List <double>(); List <MatchedIonInfo> miil = new List <MatchedIonInfo>(); foreach (var pmm in pmmhList) { var matchedIonMassesListPositiveIsMatch = new MatchedIonInfo(pmm.ProductMz.Length); double pmmScore = PsmCross.XlMatchIons(theScan.TheScan, fragmentTolerance, pmm.ProductMz, pmm.ProductName, matchedIonMassesListPositiveIsMatch); miil.Add(matchedIonMassesListPositiveIsMatch); scoreList.Add(pmmScore); } psmCross.XLBestScore = scoreList.Max(); psmCross.MatchedIonInfo = miil[scoreList.IndexOf(scoreList.Max())]; psmCross.XlPos = pmmhList[scoreList.IndexOf(scoreList.Max())].XlPos + 1; psmCross.XlPos2 = pmmhList[scoreList.IndexOf(scoreList.Max())].XlPos2 + 1; }
public void SetUp() { tenPercent = new Tolerance(10.0).Percent; zeroTolerance = new Tolerance(0); }
//Calculate score based on Product Masses. public static double XlMatchIons(IMsDataScan <IMzSpectrum <IMzPeak> > thisScan, Tolerance productMassTolerance, double[] sorted_theoretical_product_masses_for_this_peptide, string[] sorted_theoretical_product_name_for_this_peptide, MatchedIonInfo matchedIonMassesListPositiveIsMatch) { var TotalProductsHere = sorted_theoretical_product_masses_for_this_peptide.Length; if (TotalProductsHere == 0) { return(0); } int MatchingProductsHere = 0; double MatchingIntensityHere = 0; // speed optimizations double[] experimental_mzs = thisScan.MassSpectrum.XArray; double[] experimental_intensities = thisScan.MassSpectrum.YArray; int[] experimental_intensities_rank = GenerateIntensityRanks(experimental_mzs, experimental_intensities); int num_experimental_peaks = experimental_mzs.Length; int currentTheoreticalIndex = -1; double currentTheoreticalMass; do { currentTheoreticalIndex++; currentTheoreticalMass = sorted_theoretical_product_masses_for_this_peptide[currentTheoreticalIndex]; } while (double.IsNaN(currentTheoreticalMass) && currentTheoreticalIndex < sorted_theoretical_product_masses_for_this_peptide.Length - 1); if (double.IsNaN(currentTheoreticalMass)) { return(0); } double currentTheoreticalMz = currentTheoreticalMass + Constants.protonMass; int testTheoreticalIndex; double testTheoreticalMZ; double testTheoreticalMass; // Loop over all experimenal indices for (int experimentalIndex = 0; experimentalIndex < num_experimental_peaks; experimentalIndex++) { double currentExperimentalMZ = experimental_mzs[experimentalIndex]; // If found match if (productMassTolerance.Within(currentExperimentalMZ, currentTheoreticalMz)) { MatchingProductsHere++; MatchingIntensityHere += experimental_intensities[experimentalIndex]; matchedIonMassesListPositiveIsMatch.MatchedIonMz[currentTheoreticalIndex] = currentTheoreticalMass; matchedIonMassesListPositiveIsMatch.MatchedIonIntensity[currentTheoreticalIndex] = experimental_intensities[experimentalIndex]; matchedIonMassesListPositiveIsMatch.MatchedIonName[currentTheoreticalIndex] = sorted_theoretical_product_name_for_this_peptide[currentTheoreticalIndex]; matchedIonMassesListPositiveIsMatch.MatchedIonIntensityRank[currentTheoreticalIndex] = experimental_intensities_rank[experimentalIndex]; currentTheoreticalIndex++; if (currentTheoreticalIndex == TotalProductsHere) { break; } currentTheoreticalMass = sorted_theoretical_product_masses_for_this_peptide[currentTheoreticalIndex]; currentTheoreticalMz = currentTheoreticalMass + Constants.protonMass; } // Else if for sure did not reach the next theoretical yet, move to next experimental else if (currentExperimentalMZ < currentTheoreticalMz) { continue; } // Else if for sure passed a theoretical else { // Mark the theoretical as missed matchedIonMassesListPositiveIsMatch.MatchedIonMz[currentTheoreticalIndex] = -currentTheoreticalMass; // Move on to next index and never come back! currentTheoreticalIndex++; if (currentTheoreticalIndex == TotalProductsHere) { break; } currentTheoreticalMass = sorted_theoretical_product_masses_for_this_peptide[currentTheoreticalIndex]; currentTheoreticalMz = currentTheoreticalMass + Constants.protonMass; // Start with the current ones testTheoreticalIndex = currentTheoreticalIndex; testTheoreticalMZ = currentTheoreticalMz; testTheoreticalMass = currentTheoreticalMass; // Mark the skipped theoreticals as not found. The last one is not for sure, might be flipped! while (currentExperimentalMZ > testTheoreticalMZ) { matchedIonMassesListPositiveIsMatch.MatchedIonMz[testTheoreticalIndex] = -currentTheoreticalMass; // Store old info for possible reuse currentTheoreticalMass = testTheoreticalMass; currentTheoreticalMz = testTheoreticalMZ; currentTheoreticalIndex = testTheoreticalIndex; // Update test stuff! testTheoreticalIndex++; if (testTheoreticalIndex == TotalProductsHere) { break; } testTheoreticalMass = sorted_theoretical_product_masses_for_this_peptide[testTheoreticalIndex]; testTheoreticalMZ = testTheoreticalMass + Constants.protonMass; } experimentalIndex--; } } return(MatchingProductsHere + MatchingIntensityHere / thisScan.TotalIonCurrent); }
public abstract PeptideSpectralMatch Search(IMassSpectrum massSpectrum, Peptide peptide, FragmentTypes fragmentTypes, Tolerance productMassTolerance);
public LcMsFeatureMergeComparer(Tolerance tolerance) { _tolerance = tolerance; }
public void SetUp() { tolerance = Tolerance.Empty; comparer = new NUnitComparer(); }
public void TestPearsonCorrelation(int precursor, string commonName, string composition, Tolerance tolerance) { var rawFilePath = @"\\proto-2\UnitTest_Files\Liquid\PearsonCorrelationTests\OMICS_IM102_691_1d_Lipid_pooled_POS_150mm_17Apr15_Polaroid_14-12-16.raw"; var lcmsRun = PbfLcMsRun.GetLcMsRun(rawFilePath); var spectrum = lcmsRun.GetSpectrum(precursor); var parsedComposition = Composition.ParseFromPlainString(composition); var correlationCalculator = new PearsonCorrelationFitUtil(); //var target = new LipidTarget(commonName, LipidClass.DG, FragmentationMode.Positive, parsedComposition, new List<AcylChain>(), Adduct.Hydrogen); var spectrumSearchResult = new SpectrumSearchResult(null, null, spectrum, null, null, new Xic(), lcmsRun) { PrecursorTolerance = tolerance }; var correlation = correlationCalculator.GetFitScore(spectrumSearchResult, parsedComposition); Console.WriteLine("The Pearson correlation is: " + correlation); }
public void MassToleranceImplicitPlusMinus4() { var tol = new Tolerance("± 10 ppm"); // alt-code 241 Assert.AreEqual(tol.Type, ToleranceType.PlusAndMinus); }
public void TestPearsonCorrelationWholeFile(string directoryPath) { var dirFiles = Directory.GetFiles(directoryPath); var correlationCalculator = new PearsonCorrelationFitUtil(); foreach (var pathToResults in dirFiles.Where(path => path.EndsWith(".txt"))) { var datasetName = Path.GetFileNameWithoutExtension(pathToResults); var pathToRaw = GetRawFilePath(directoryPath, datasetName); if (string.IsNullOrEmpty(pathToRaw)) { continue; } var lcmsRun = PbfLcMsRun.GetLcMsRun(pathToRaw); var tolerance = new Tolerance(30, ToleranceUnit.Ppm); var rawFileName = Path.GetFileName(pathToRaw); var datasetDirPath = Path.GetDirectoryName(pathToResults); var outputFileName = string.Format("{0}_training.tsv", datasetName); var outputPath = Path.Combine(datasetDirPath, outputFileName); using (var writer = new StreamWriter(outputPath)) using (var reader = new StreamReader(new FileStream(pathToResults, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { var lineCount = 0; var headerToIndex = new Dictionary <string, int>(); while (!reader.EndOfStream) { var line = reader.ReadLine(); if (string.IsNullOrWhiteSpace(line)) { continue; } var pieces = line.Split('\t').ToArray(); if (lineCount++ == 0) { // First line writer.Write("Raw File\t"); for (var i = 0; i < pieces.Length; i++) { headerToIndex.Add(pieces[i], i); writer.Write("{0}\t", pieces[i]); } writer.WriteLine("Fit Score\tFit M-1 Score"); continue; } var precursor = Convert.ToInt32(pieces[headerToIndex["Precursor Scan"]]); var commonName = pieces[headerToIndex["Common Name"]]; var adduct = pieces[headerToIndex["Adduct"]]; var spectrum = lcmsRun.GetSpectrum(precursor); if (spectrum == null) { Console.WriteLine("Invalid scan number: {0}", precursor); continue; } var lipid = new Lipid { AdductFull = adduct, CommonName = commonName }; var lipidTarget = lipid.CreateLipidTarget(); var spectrumSearchResult = new SpectrumSearchResult(null, null, spectrum, null, null, new Xic(), lcmsRun) { PrecursorTolerance = tolerance }; var fitScore = correlationCalculator.GetFitScore(spectrumSearchResult, lipidTarget.Composition); var fitMinus1Score = correlationCalculator.GetFitMinus1Score(spectrumSearchResult, lipidTarget.Composition); writer.Write(rawFileName + "\t"); writer.Write(line); writer.WriteLine("{0}\t{1}", fitScore, fitMinus1Score); } } } }
public void MassToleranceImplicitType() { var tol = new Tolerance("10 ppm"); Assert.AreEqual(ToleranceUnit.PPM, tol.Unit); }
public void PearsonCorrelationFileCombiner(string directoryPath) { var dirFiles = Directory.GetFiles(directoryPath); var correlationCalculator = new PearsonCorrelationFitUtil(); var cosineCalculator = new CosineFitUtil(); // Each dictionary corresponds to a dataset, each dictionary key corresponds to the TSV header. var results = new List <Dictionary <string, List <string> > >(); var headers = new HashSet <string>(); foreach (var pathToResults in dirFiles.Where(path => path.EndsWith(".txt"))) { var datasetName = Path.GetFileNameWithoutExtension(pathToResults); var pathToRaw = GetRawFilePath(directoryPath, datasetName); var rawName = Path.GetFileName(pathToRaw); if (string.IsNullOrEmpty(pathToRaw)) { continue; } var lcmsRun = PbfLcMsRun.GetLcMsRun(pathToRaw); var tolerance = new Tolerance(30, ToleranceUnit.Ppm); using (var reader = new StreamReader(new FileStream(pathToResults, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))) { results.Add(new Dictionary <string, List <string> >()); // Add dictionary for new dataset. var datasetResults = results.Last(); // Results for the current dataset. var lineCount = 0; var headerToIndex = new Dictionary <string, int>(); while (!reader.EndOfStream) { var line = reader.ReadLine(); if (string.IsNullOrWhiteSpace(line)) { continue; } var pieces = line.Split('\t').ToArray(); if (lineCount++ == 0) { // First line for (var i = 0; i < pieces.Length; i++) { var header = pieces[i]; headerToIndex.Add(header, i); datasetResults.Add(header, new List <string>()); } datasetResults.Add("Raw File", new List <string>()); datasetResults.Add("Pearson Corr Score", new List <string>()); datasetResults.Add("Pearson Corr M-1 Score", new List <string>()); datasetResults.Add("Cosine Score", new List <string>()); datasetResults.Add("Cosine M-1 Score", new List <string>()); headers.UnionWith(datasetResults.Keys); continue; } var precursor = Convert.ToInt32(pieces[headerToIndex["Precursor Scan"]]); var commonName = pieces[headerToIndex["Common Name"]]; var adduct = pieces[headerToIndex["Adduct"]]; var spectrum = lcmsRun.GetSpectrum(precursor); if (spectrum == null) { Console.WriteLine("Invalid scan number: {0}", precursor); continue; } var lipid = new Lipid { AdductFull = adduct, CommonName = commonName }; var lipidTarget = lipid.CreateLipidTarget(); var spectrumSearchResult = new SpectrumSearchResult(null, null, spectrum, null, null, new Xic(), lcmsRun) { PrecursorTolerance = tolerance }; var pearsonCorrScore = correlationCalculator.GetFitScore(spectrumSearchResult, lipidTarget.Composition); var pearsonCorrMinus1Score = correlationCalculator.GetFitMinus1Score(spectrumSearchResult, lipidTarget.Composition); var cosineScore = cosineCalculator.GetFitScore(spectrumSearchResult, lipidTarget.Composition); var cosineMinus1Score = cosineCalculator.GetFitScore( spectrumSearchResult, lipidTarget.Composition); // Add results to results dictionary. datasetResults["Raw File"].Add(rawName); foreach (var header in headerToIndex.Keys) { datasetResults[header].Add(pieces[headerToIndex[header]]); } datasetResults["Pearson Corr Score"].Add(pearsonCorrScore.ToString()); datasetResults["Pearson Corr M-1 Score"].Add(pearsonCorrMinus1Score.ToString()); datasetResults["Cosine Score"].Add(cosineScore.ToString()); datasetResults["Cosine M-1 Score"].Add(cosineMinus1Score.ToString()); } } } // Write results var outputFilePath = Path.Combine(directoryPath, "training.tsv"); using (var writer = new StreamWriter(outputFilePath)) { // Write headers foreach (var header in headers) { writer.Write("{0}\t", header); } writer.WriteLine(); // Write data foreach (var datasetResults in results) { var fileLength = datasetResults["Pearson Corr Score"].Count; for (var i = 0; i < fileLength; i++) { foreach (var header in headers) { var value = datasetResults.ContainsKey(header) ? datasetResults[header][i] : string.Empty; writer.Write("{0}\t", value); } writer.WriteLine(); } } } }
public void MassToleranceConstructorDaType() { var tol = new Tolerance(ToleranceUnit.DA, 10); Assert.AreEqual(ToleranceUnit.DA, tol.Unit); }
private static ApartmentContourInfo GetApartmentContour(IEnumerable <ObjectId> linearIds) { var info = ApartmentContour.CalcContour(Application.DocumentManager.MdiActiveDocument, linearIds); var database = Application.DocumentManager.MdiActiveDocument.Database; // Test code ! using (var transaction = database.TransactionManager.StartTransaction()) { var contourSegments = info.Contour; var innerSegments = info.InternalSegments; // find out windows on wall, usually there are 4 or 3 parallel line segments for a window like below. // ----------------------- // ----------------------- // ----------------------- // ----------------------- const double maxWallWidth = 600; // todo Tolerance tol = new Tolerance(0.001, 0.001); List <LineSegment3d> sideWindowSegments = new List <LineSegment3d>(); List <List <LineSegment3d> > windowGroup = new List <List <LineSegment3d> >(); for (var i = 0; i < innerSegments.Count; i++) { var thisSeg = innerSegments[i]; //var startPt = innerSegments[i].StartPoint; //var endPt = innerSegments[i].EndPoint; // do check if the start and end points are on the wall //var cIndex = contourSegments.FindIndex((seg) => { // if (seg.IsOn(startPt, tol) && seg.IsOn(endPt, tol)) // return true; // return false; //}); // find out if the line segment is on the outer contour wall //var cIndex = contourSegments.FindIndex((seg) => //{ // if (seg.IsParallelTo(innerSegments[i], tol)) // { // var dist = seg.GetDistanceTo(thisSeg.MidPoint); // if (dist < maxWallWidth) // return true; // } // return false; //}); //if (cIndex != -1) { // find out all other parallel and equal length segments with this one var startPt = thisSeg.StartPoint; var endPt = thisSeg.EndPoint; double thisLength = thisSeg.Length; Vector3d direction = thisSeg.Direction.RotateBy(Math.PI / 2, Vector3d.ZAxis); Line3d startLine = new Line3d(startPt, direction); Line3d endLine = new Line3d(endPt, direction); List <LineSegment3d> parEqualSegs = new List <LineSegment3d>(); for (var j = 0; j < innerSegments.Count; j++) { if (i == j || innerSegments[j] == null) { continue; // itself } if (thisSeg.IsParallelTo(innerSegments[j]) && (startLine.IsOn(innerSegments[j].StartPoint, tol) && endLine.IsOn(innerSegments[j].EndPoint, tol)) || (startLine.IsOn(innerSegments[j].EndPoint, tol) && endLine.IsOn(innerSegments[j].StartPoint, tol))) { parEqualSegs.Add(innerSegments[j]); } } if (parEqualSegs.Count > 1) { Line3d helper1 = new Line3d(thisSeg.MidPoint, thisSeg.Direction); Line3d helper2 = new Line3d(thisSeg.MidPoint, direction); var intersects = helper1.IntersectWith(helper2); var basePt = intersects[0]; //direction = (thisSeg.MidPoint - basePt).GetNormal(); // sort them by direction parEqualSegs.Add(thisSeg); parEqualSegs.Sort((seg1, seg2) => { Vector3d vector1 = seg1.MidPoint - basePt; Vector3d vector2 = seg2.MidPoint - basePt; if (Math.Abs(vector1.DotProduct(direction) - vector2.DotProduct(direction)) < 0.001) { return(0); } else if (vector1.DotProduct(direction) > vector2.DotProduct(direction)) { return(1); } return(-1); }); List <LineSegment3d> thisWindow = new List <LineSegment3d>(); double distance = parEqualSegs[1].MidPoint.DistanceTo(parEqualSegs[0].MidPoint); if (distance < maxWallWidth / 2) { thisWindow.Add(parEqualSegs[0]); thisWindow.Add(parEqualSegs[1]); for (var k = 2; k < parEqualSegs.Count; k++) { var dist = parEqualSegs[k].MidPoint.DistanceTo(parEqualSegs[k - 1].MidPoint); if (thisWindow.Count > 4 || Math.Abs(dist - distance) > 100) { // we have find out 4 parallel lines or the distance is not equal to previous one break; } thisWindow.Add(parEqualSegs[k]); } if (thisWindow.Count > 2) { // this will be treaded as a valid window windowGroup.Add(thisWindow); } } } } } innerSegments.RemoveAll((seg) => { var index = windowGroup.FindIndex((window) => { return(window.Contains(seg)); }); if (index != -1) { return(true); } return(false); }); // end window var modelspaceId = SymbolUtilityServices.GetBlockModelSpaceId(database); var modelspace = (BlockTableRecord)transaction.GetObject(modelspaceId, OpenMode.ForWrite); var color1 = Color.FromColorIndex(ColorMethod.ByAci, 1); // 1: red ObjectId layerId = LayerUtils.AddNewLayer(database, "temp-poly", "Continuous", color1); for (var i = 0; i < windowGroup.Count; i++) { var window = windowGroup[i]; for (var j = 0; j < window.Count; j++) { var start = window[j].StartPoint; var end = window[j].EndPoint; var line = new Line(start, end); line.Color = color1; line.LayerId = layerId; modelspace.AppendEntity(line); transaction.AddNewlyCreatedDBObject(line, add: true); } } var color = Color.FromColorIndex(ColorMethod.ByAci, 3); // Green var polyline = new Polyline(); for (var i = 0; i < contourSegments.Count; i++) { var segment = contourSegments[i]; var start = segment.StartPoint; polyline.AddVertexAt(i, new Point2d(start.X, start.Y), 0, 0, 0); } polyline.Closed = true; polyline.Color = color; polyline.LayerId = layerId; modelspace.AppendEntity(polyline); transaction.AddNewlyCreatedDBObject(polyline, add: true); foreach (var segment in innerSegments) { var line = new Line(segment.StartPoint, segment.EndPoint); line.Color = color; line.LayerId = layerId; modelspace.AppendEntity(line); transaction.AddNewlyCreatedDBObject(line, add: true); } transaction.Commit(); } return(info); }
public void MassToleranceImplicitPlusMinus() { var tol = new Tolerance("+-10 ppm"); Assert.AreEqual(tol.Type, ToleranceType.PlusAndMinus); }
public static bool IsLineDuplicate(Line ln1, Line ln2, Tolerance tol) { return (ln1.StartPoint.IsEqualTo(ln2.StartPoint, tol) || ln1.StartPoint.IsEqualTo(ln2.EndPoint, tol)) && (ln1.EndPoint.IsEqualTo(ln2.EndPoint) || ln1.EndPoint.IsEqualTo(ln2.StartPoint)); }