organize

stefanks · stefanks · commit 6c27470929e5 · 2017-02-14T18:19:43.000-06:00
diff --git a/EngineLayer/Analysis/BinTreeStructure.cs b/EngineLayer/Analysis/BinTreeStructure.cs
@@ -140,18 +140,14 @@ private static double getSigma(double thisMassShift, int thisP, int i, List<doub
                 {
                     lookingAtP = p[currentDown];
                     if (lookingAtP > thisP)
-                    {
                         return distDown;
-                    }
                     currentDown--;
                 }
                 else
                 {
                     lookingAtP = p[currentUp];
                     if (lookingAtP > thisP)
-                    {
                         return distUp;
-                    }
                     currentUp++;
                 }
             }
@@ -160,7 +156,6 @@ private static double getSigma(double thisMassShift, int thisP, int i, List<doub
         private void OverlappingIonSequences()
         {
             foreach (Bin bin in FinalBins)
-            {
                 foreach (var hm in bin.uniquePSMs.Where(b => !b.Value.Item3.IsDecoy))
                 {
                     var ya = hm.Value.Item3.thisPSM.newPsm.matchedIonsList;
@@ -171,7 +166,6 @@ private void OverlappingIonSequences()
                         && ya[ProductType.B].Last(b => b > 0) + ya[ProductType.Y].Last(b => b > 0) > hm.Value.Item3.thisPSM.PeptideMonoisotopicMass)
                         bin.Overlapping++;
                 }
-            }
         }
 
         private void IdentifyFracWithSingle()
@@ -193,18 +187,12 @@ private void IdentifyAAsInCommon()
                 {
                     var chars = new HashSet<char>();
                     for (int i = 0; i < hehe.Item1.Count(); i++)
-                    {
                         chars.Add(hehe.Item1[i]);
-                    }
                     foreach (var ch in chars)
-                    {
                         if (bin.AAsInCommon.ContainsKey(ch))
-                        {
                             bin.AAsInCommon[ch]++;
-                        }
                         else
                             bin.AAsInCommon.Add(ch, 1);
-                    }
                 }
             }
         }
@@ -225,9 +213,7 @@ private void IdentifyMods()
                         {
                             inModLevel++;
                             if (inModLevel == 1)
-                            {
                                 continue;
-                            }
                         }
                         else if (ye.Equals(']'))
                         {
@@ -243,9 +229,7 @@ private void IdentifyMods()
                             continue;
                         }
                         if (inModLevel > 0)
-                        {
                             currentMod += ye;
-                        }
                     }
                 }
             }
@@ -262,15 +246,11 @@ private void IdentifyResidues()
                     if (bestScore >= hehe.Item3.thisPSM.Score + 1 && !hehe.Item3.IsDecoy)
                     {
                         for (int i = 0; i < hehe.Item1.Count(); i++)
-                        {
                             if (bestScore - hehe.Item3.thisPSM.LocalizedScores[i] < 0.5)
-                            {
                                 if (bin.residueCount.ContainsKey(hehe.Item1[i]))
                                     bin.residueCount[hehe.Item1[i]]++;
                                 else
                                     bin.residueCount.Add(hehe.Item1[i], 1);
-                            }
-                        }
                         if (hehe.Item3.thisPSM.LocalizedScores.Max() - hehe.Item3.thisPSM.LocalizedScores[0] < 0.5)
                             bin.NlocCount++;
                         if (hehe.Item3.thisPSM.LocalizedScores.Max() - hehe.Item3.thisPSM.LocalizedScores.Last() < 0.5)
@@ -328,12 +308,8 @@ private void IdentifyCombos(double v)
             {
                 var okk = new HashSet<string>();
                 foreach (var hm in ok)
-                {
                     if (Math.Abs(hm.Item1 + hm.Item2 - bin.MassShift) <= v && bin.CountTarget < hm.Item3)
-                    {
                         okk.Add("Combo " + Math.Min(hm.Item1, hm.Item2).ToString("F3", CultureInfo.InvariantCulture) + " and " + Math.Max(hm.Item1, hm.Item2).ToString("F3", CultureInfo.InvariantCulture));
-                    }
-                }
                 bin.combos = string.Join(" or ", okk);
             }
         }
@@ -349,26 +325,18 @@ private void IdentifyAA(double v)
                     if (Residue.TryGetResidue(c, out residue))
                     {
                         if (Math.Abs(residue.MonoisotopicMass - bin.MassShift) <= v)
-                        {
                             ok.Add("Add " + residue.Name);
-                        }
                         if (Math.Abs(residue.MonoisotopicMass + bin.MassShift) <= v)
-                        {
                             ok.Add("Remove " + residue.Name);
-                        }
                         for (char cc = 'A'; cc <= 'Z'; cc++)
                         {
                             Residue residueCC;
                             if (Residue.TryGetResidue(cc, out residueCC))
                             {
                                 if (Math.Abs(residueCC.MonoisotopicMass + residue.MonoisotopicMass - bin.MassShift) <= v)
-                                {
                                     ok.Add("Add (" + residue.Name + "+" + residueCC.Name + ")");
-                                }
                                 if (Math.Abs(residueCC.MonoisotopicMass + residue.MonoisotopicMass + bin.MassShift) <= v)
-                                {
                                     ok.Add("Remove (" + residue.Name + "+" + residueCC.Name + ")");
-                                }
                             }
                         }
                     }
@@ -397,12 +365,8 @@ private void IdentifyMine(double v)
             {
                 bin.Mine = "";
                 foreach (MyInfo myInfo in myInfos)
-                {
                     if (Math.Abs(myInfo.MassShift - bin.MassShift) <= v)
-                    {
                         bin.Mine = myInfo.infostring;
-                    }
-                }
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -140,18 +140,14 @@ private static double getSigma(double thisMassShift, int thisP, int i, List<doub`
`140`	`140`	`{`
`141`	`141`	`lookingAtP = p[currentDown];`
`142`	`142`	`if (lookingAtP > thisP)`
`143`		`- {`
`144`	`143`	`return distDown;`
`145`		`- }`
`146`	`144`	`currentDown--;`
`147`	`145`	`}`
`148`	`146`	`else`
`149`	`147`	`{`
`150`	`148`	`lookingAtP = p[currentUp];`
`151`	`149`	`if (lookingAtP > thisP)`
`152`		`- {`
`153`	`150`	`return distUp;`
`154`		`- }`
`155`	`151`	`currentUp++;`
`156`	`152`	`}`
`157`	`153`	`}`
`@@ -160,7 +156,6 @@ private static double getSigma(double thisMassShift, int thisP, int i, List<doub`
`160`	`156`	`private void OverlappingIonSequences()`
`161`	`157`	`{`
`162`	`158`	`foreach (Bin bin in FinalBins)`
`163`		`- {`
`164`	`159`	`foreach (var hm in bin.uniquePSMs.Where(b => !b.Value.Item3.IsDecoy))`
`165`	`160`	`{`
`166`	`161`	`var ya = hm.Value.Item3.thisPSM.newPsm.matchedIonsList;`
`@@ -171,7 +166,6 @@ private void OverlappingIonSequences()`
`171`	`166`	`&& ya[ProductType.B].Last(b => b > 0) + ya[ProductType.Y].Last(b => b > 0) > hm.Value.Item3.thisPSM.PeptideMonoisotopicMass)`
`172`	`167`	`bin.Overlapping++;`
`173`	`168`	`}`
`174`		`- }`
`175`	`169`	`}`
`176`	`170`
`177`	`171`	`private void IdentifyFracWithSingle()`
`@@ -193,18 +187,12 @@ private void IdentifyAAsInCommon()`
`193`	`187`	`{`
`194`	`188`	`var chars = new HashSet<char>();`
`195`	`189`	`for (int i = 0; i < hehe.Item1.Count(); i++)`
`196`		`- {`
`197`	`190`	`chars.Add(hehe.Item1[i]);`
`198`		`- }`
`199`	`191`	`foreach (var ch in chars)`
`200`		`- {`
`201`	`192`	`if (bin.AAsInCommon.ContainsKey(ch))`
`202`		`- {`
`203`	`193`	`bin.AAsInCommon[ch]++;`
`204`		`- }`
`205`	`194`	`else`
`206`	`195`	`bin.AAsInCommon.Add(ch, 1);`
`207`		`- }`
`208`	`196`	`}`
`209`	`197`	`}`
`210`	`198`	`}`
`@@ -225,9 +213,7 @@ private void IdentifyMods()`
`225`	`213`	`{`
`226`	`214`	`inModLevel++;`
`227`	`215`	`if (inModLevel == 1)`
`228`		`- {`
`229`	`216`	`continue;`
`230`		`- }`
`231`	`217`	`}`
`232`	`218`	`else if (ye.Equals(']'))`
`233`	`219`	`{`
`@@ -243,9 +229,7 @@ private void IdentifyMods()`
`243`	`229`	`continue;`
`244`	`230`	`}`
`245`	`231`	`if (inModLevel > 0)`
`246`		`- {`
`247`	`232`	`currentMod += ye;`
`248`		`- }`
`249`	`233`	`}`
`250`	`234`	`}`
`251`	`235`	`}`
`@@ -262,15 +246,11 @@ private void IdentifyResidues()`
`262`	`246`	`if (bestScore >= hehe.Item3.thisPSM.Score + 1 && !hehe.Item3.IsDecoy)`
`263`	`247`	`{`
`264`	`248`	`for (int i = 0; i < hehe.Item1.Count(); i++)`
`265`		`- {`
`266`	`249`	`if (bestScore - hehe.Item3.thisPSM.LocalizedScores[i] < 0.5)`
`267`		`- {`
`268`	`250`	`if (bin.residueCount.ContainsKey(hehe.Item1[i]))`
`269`	`251`	`bin.residueCount[hehe.Item1[i]]++;`
`270`	`252`	`else`
`271`	`253`	`bin.residueCount.Add(hehe.Item1[i], 1);`
`272`		`- }`
`273`		`- }`
`274`	`254`	`if (hehe.Item3.thisPSM.LocalizedScores.Max() - hehe.Item3.thisPSM.LocalizedScores[0] < 0.5)`
`275`	`255`	`bin.NlocCount++;`
`276`	`256`	`if (hehe.Item3.thisPSM.LocalizedScores.Max() - hehe.Item3.thisPSM.LocalizedScores.Last() < 0.5)`
`@@ -328,12 +308,8 @@ private void IdentifyCombos(double v)`
`328`	`308`	`{`
`329`	`309`	`var okk = new HashSet<string>();`
`330`	`310`	`foreach (var hm in ok)`
`331`		`- {`
`332`	`311`	`if (Math.Abs(hm.Item1 + hm.Item2 - bin.MassShift) <= v && bin.CountTarget < hm.Item3)`
`333`		`- {`
`334`	`312`	`okk.Add("Combo " + Math.Min(hm.Item1, hm.Item2).ToString("F3", CultureInfo.InvariantCulture) + " and " + Math.Max(hm.Item1, hm.Item2).ToString("F3", CultureInfo.InvariantCulture));`
`335`		`- }`
`336`		`- }`
`337`	`313`	`bin.combos = string.Join(" or ", okk);`
`338`	`314`	`}`
`339`	`315`	`}`
`@@ -349,26 +325,18 @@ private void IdentifyAA(double v)`
`349`	`325`	`if (Residue.TryGetResidue(c, out residue))`
`350`	`326`	`{`
`351`	`327`	`if (Math.Abs(residue.MonoisotopicMass - bin.MassShift) <= v)`
`352`		`- {`
`353`	`328`	`ok.Add("Add " + residue.Name);`
`354`		`- }`
`355`	`329`	`if (Math.Abs(residue.MonoisotopicMass + bin.MassShift) <= v)`
`356`		`- {`
`357`	`330`	`ok.Add("Remove " + residue.Name);`
`358`		`- }`
`359`	`331`	`for (char cc = 'A'; cc <= 'Z'; cc++)`
`360`	`332`	`{`
`361`	`333`	`Residue residueCC;`
`362`	`334`	`if (Residue.TryGetResidue(cc, out residueCC))`
`363`	`335`	`{`
`364`	`336`	`if (Math.Abs(residueCC.MonoisotopicMass + residue.MonoisotopicMass - bin.MassShift) <= v)`
`365`		`- {`
`366`	`337`	`ok.Add("Add (" + residue.Name + "+" + residueCC.Name + ")");`
`367`		`- }`
`368`	`338`	`if (Math.Abs(residueCC.MonoisotopicMass + residue.MonoisotopicMass + bin.MassShift) <= v)`
`369`		`- {`
`370`	`339`	`ok.Add("Remove (" + residue.Name + "+" + residueCC.Name + ")");`
`371`		`- }`
`372`	`340`	`}`
`373`	`341`	`}`
`374`	`342`	`}`
`@@ -397,12 +365,8 @@ private void IdentifyMine(double v)`
`397`	`365`	`{`
`398`	`366`	`bin.Mine = "";`
`399`	`367`	`foreach (MyInfo myInfo in myInfos)`
`400`		`- {`
`401`	`368`	`if (Math.Abs(myInfo.MassShift - bin.MassShift) <= v)`
`402`		`- {`
`403`	`369`	`bin.Mine = myInfo.infostring;`
`404`		`- }`
`405`		`- }`
`406`	`370`	`}`
`407`	`371`	`}`
`408`	`372`