CandidateSearch 1.1.2
Proof-of-concept implementation of a search engine that uses sparse matrix multiplication to identify the best peptide candidates for a given mass spectrum.
Loading...
Searching...
No Matches
Settings.cs
Go to the documentation of this file.
1using System.Text;
2
3namespace CandidateSearch.util
4{
8 public class Settings
9 {
10 // config digestion
14 public int MAX_CLEAVAGES { get; set; } // default: 2
18 public int MIN_PEP_LENGTH { get; set; } // default: 5
22 public int MAX_PEP_LENGTH { get; set; } // default: 30
23
24 // config ion calculation
28 public int MAX_PRECURSOR_CHARGE { get; set; } // default: 4
32 public string MAX_FRAGMENT_CHARGE { get; set; } // default: "+1";
36 public int MAX_NEUTRAL_LOSSES { get; set; } // default: 1
40 public int MAX_NEUTRAL_LOSS_MODS { get; set; } // default: 2
44 public Dictionary<string, double> FIXED_MODIFICATIONS { get; set; } // default: empty Dictionary
48 public Dictionary<string, double> VARIABLE_MODIFICATIONS { get; set; } // default: empty Dictionary
49
50 // config search parameters
54 public bool DECOY_SEARCH { get; set; } // default: true
55
56 // config vector search
60 public int TOP_N { get; set; } // default: 1000
64 public float TOLERANCE { get; set; } // default: 0.02f
68 public bool NORMALIZE { get; set; } // default: false
72 public bool USE_GAUSSIAN { get; set; } // default: true
76 public string MODE { get; set; } // default: CPU_DV
77
94 public Settings(int MaxCleavages = 2, int MinPepLength = 5, int MaxPepLength = 30,
95 int MaxPrecursorCharge = 4, string MaxFragmentCharge = "+1", int MaxNeutralLosses = 1, int MaxNeutralLossMods = 2,
96 bool DecoySearch = true,
97 int TopN = 1000, float Tolerance = 0.02f, bool Normalize = false, bool UseGaussian = true, string Mode = "CPU_SMi32")
98 {
99 MAX_CLEAVAGES = MaxCleavages;
100 MIN_PEP_LENGTH = MinPepLength;
101 MAX_PEP_LENGTH = MaxPepLength;
102
103 MAX_PRECURSOR_CHARGE = MaxPrecursorCharge;
104 MAX_FRAGMENT_CHARGE = MaxFragmentCharge;
105 MAX_NEUTRAL_LOSSES = MaxNeutralLosses;
106 MAX_NEUTRAL_LOSS_MODS = MaxNeutralLossMods;
107 FIXED_MODIFICATIONS = new Dictionary<string, double>();
108 VARIABLE_MODIFICATIONS = new Dictionary<string, double>();
109
110 DECOY_SEARCH = DecoySearch;
111
112 TOP_N = TopN;
113 TOLERANCE = Tolerance;
114 NORMALIZE = Normalize;
115 USE_GAUSSIAN = UseGaussian;
116 MODE = Mode;
117 }
118
125 public bool addFixedModification(string aminoAcid, double mass)
126 {
127 if (FIXED_MODIFICATIONS.ContainsKey(aminoAcid))
128 return false;
129
130 FIXED_MODIFICATIONS.Add(aminoAcid, mass);
131 return true;
132 }
133
140 public bool addVariableModification(string aminoAcid, double mass)
141 {
142 if (VARIABLE_MODIFICATIONS.ContainsKey(aminoAcid))
143 return false;
144
145 VARIABLE_MODIFICATIONS.Add(aminoAcid, mass);
146 return true;
147 }
148
154 public string modificationsToString(bool variable = false)
155 {
156 var sb = new StringBuilder();
157 if (!variable)
158 {
159 foreach (var mod in FIXED_MODIFICATIONS)
160 {
161 sb.Append($"{mod.Key.ToString()}:{mod.Value.ToString()};");
162 }
163 }
164 else
165 {
166 foreach (var mod in VARIABLE_MODIFICATIONS)
167 {
168 sb.Append($"{mod.Key.ToString()}:{mod.Value.ToString()};");
169 }
170 }
171 return sb.ToString();
172 }
173
178 public override string ToString()
179 {
180 var sb = new StringBuilder();
181 sb.Append("---- SETTINGS: ----\n");
182 sb.Append($"MAX_CLEAVAGES: {MAX_CLEAVAGES}\n");
183 sb.Append($"MIN_PEP_LENGTH: {MIN_PEP_LENGTH}\n");
184 sb.Append($"MAX_PEP_LENGTH: {MAX_PEP_LENGTH}\n");
185 sb.Append($"MAX_PRECURSOR_CHARGE: {MAX_PRECURSOR_CHARGE}\n");
186 sb.Append($"MAX_FRAGMENT_CHARGE: {MAX_FRAGMENT_CHARGE}\n");
187 sb.Append($"MAX_NEUTRAL_LOSSES: {MAX_NEUTRAL_LOSSES}\n");
188 sb.Append($"MAX_NEUTRAL_LOSS_MODS: {MAX_NEUTRAL_LOSS_MODS}\n");
189 sb.Append($"FIXED_MODIFICATIONS: {modificationsToString(false)}\n");
190 sb.Append($"VARIABLE_MODIFICATIONS: {modificationsToString(true)}\n");
191 sb.Append($"DECOY_SEARCH: {DECOY_SEARCH}\n");
192 sb.Append($"TOP_N: {TOP_N}\n");
193 sb.Append($"TOLERANCE: {TOLERANCE}\n");
194 sb.Append($"NORMALIZE: {NORMALIZE}\n");
195 sb.Append($"USE_GAUSSIAN: {USE_GAUSSIAN}\n");
196 sb.Append($"MODE: {MODE}\n");
197 sb.Append("---- SETTINGS END ----");
198
199 return sb.ToString();
200 }
201 }
202
206 public static class SettingsReader
207 {
213 public static Settings readSettings(string filename)
214 {
215 var settings = new Settings();
216
217 using (StreamReader sr = new StreamReader(filename))
218 {
219 while (!sr.EndOfStream)
220 {
221 var line = sr.ReadLine();
222
223 if (line != null && line.StartsWith("MAX_CLEAVAGES"))
224 {
225 var values = line.Split("=");
226 if (values.Length > 1)
227 {
228 var ok = int.TryParse(values[1], out var value);
229 if (ok)
230 {
231 settings.MAX_CLEAVAGES = value;
232 }
233 }
234 }
235
236 if (line != null && line.StartsWith("MIN_PEP_LENGTH"))
237 {
238 var values = line.Split("=");
239 if (values.Length > 1)
240 {
241 var ok = int.TryParse(values[1], out var value);
242 if (ok)
243 {
244 settings.MIN_PEP_LENGTH = value;
245 }
246 }
247 }
248
249 if (line != null && line.StartsWith("MAX_PEP_LENGTH"))
250 {
251 var values = line.Split("=");
252 if (values.Length > 1)
253 {
254 var ok = int.TryParse(values[1], out var value);
255 if (ok)
256 {
257 settings.MAX_PEP_LENGTH = value;
258 }
259 }
260 }
261
262 if (line != null && line.StartsWith("MAX_PRECURSOR_CHARGE"))
263 {
264 var values = line.Split("=");
265 if (values.Length > 1)
266 {
267 var ok = int.TryParse(values[1], out var value);
268 if (ok)
269 {
270 settings.MAX_PRECURSOR_CHARGE = value;
271 }
272 }
273 }
274
275 if (line != null && line.StartsWith("MAX_FRAGMENT_CHARGE"))
276 {
277 var values = line.Split("=");
278 if (values.Length > 1)
279 {
280 var maxFragmentCharge = values[1].Trim();
281 if (maxFragmentCharge == "+2" ||
282 maxFragmentCharge == "+3" ||
283 maxFragmentCharge == "+4" ||
284 maxFragmentCharge == "Precursor - 1")
285 {
286 settings.MAX_FRAGMENT_CHARGE = maxFragmentCharge;
287 }
288 }
289 }
290
291 if (line != null && line.StartsWith("MAX_NEUTRAL_LOSSES"))
292 {
293 var values = line.Split("=");
294 if (values.Length > 1)
295 {
296 var ok = int.TryParse(values[1], out var value);
297 if (ok)
298 {
299 settings.MAX_NEUTRAL_LOSSES = value;
300 }
301 }
302 }
303
304 if (line != null && line.StartsWith("MAX_NEUTRAL_LOSS_MODS"))
305 {
306 var values = line.Split("=");
307 if (values.Length > 1)
308 {
309 var ok = int.TryParse(values[1], out var value);
310 if (ok)
311 {
312 settings.MAX_NEUTRAL_LOSS_MODS = value;
313 }
314 }
315 }
316
317 if (line != null && line.StartsWith("FIXED_MODIFICATIONS"))
318 {
319 var values = line.Split("=");
320 if (values.Length > 1)
321 {
322 var mods = values[1].Split(";");
323 foreach (var mod in mods)
324 {
325 var modProps = mod.Split(":");
326 if (modProps.Length == 2)
327 {
328 if (modProps[0].Trim().Length == 1)
329 {
330 var ok = double.TryParse(modProps[1],
331 System.Globalization.NumberStyles.AllowDecimalPoint,
332 System.Globalization.CultureInfo.InvariantCulture,
333 out var value);
334 if (ok)
335 {
336 if (!settings.FIXED_MODIFICATIONS.ContainsKey(modProps[0]))
337 {
338 settings.addFixedModification(modProps[0].Trim(), value);
339 }
340 }
341 }
342 }
343 }
344 }
345 }
346
347 if (line != null && line.StartsWith("VARIABLE_MODIFICATIONS"))
348 {
349 var values = line.Split("=");
350 if (values.Length > 1)
351 {
352 var mods = values[1].Split(";");
353 foreach (var mod in mods)
354 {
355 var modProps = mod.Split(":");
356 if (modProps.Length == 2)
357 {
358 if (modProps[0].Trim().Length == 1)
359 {
360 var ok = double.TryParse(modProps[1],
361 System.Globalization.NumberStyles.AllowDecimalPoint,
362 System.Globalization.CultureInfo.InvariantCulture,
363 out var value);
364 if (ok)
365 {
366 if (!settings.VARIABLE_MODIFICATIONS.ContainsKey(modProps[0]))
367 {
368 settings.addVariableModification(modProps[0].Trim(), value);
369 }
370 }
371 }
372 }
373 }
374 }
375 }
376
377 if (line != null && line.StartsWith("DECOY_SEARCH"))
378 {
379 var values = line.Split("=");
380 if (values.Length > 1)
381 {
382 var ok = bool.TryParse(values[1], out var value);
383 if (ok)
384 {
385 settings.DECOY_SEARCH = value;
386 }
387 }
388 }
389
390 if (line != null && line.StartsWith("TOP_N"))
391 {
392 var values = line.Split("=");
393 if (values.Length > 1)
394 {
395 var ok = int.TryParse(values[1], out var value);
396 if (ok)
397 {
398 settings.TOP_N = value;
399 }
400 }
401 }
402
403 if (line != null && line.StartsWith("TOLERANCE"))
404 {
405 var values = line.Split("=");
406 if (values.Length > 1)
407 {
408 var ok = float.TryParse(values[1],
409 System.Globalization.NumberStyles.AllowDecimalPoint,
410 System.Globalization.CultureInfo.InvariantCulture,
411 out var value);
412 if (ok)
413 {
414 settings.TOLERANCE = value;
415 }
416 }
417 }
418
419 if (line != null && line.StartsWith("NORMALIZE"))
420 {
421 var values = line.Split("=");
422 if (values.Length > 1)
423 {
424 var ok = bool.TryParse(values[1], out var value);
425 if (ok)
426 {
427 settings.NORMALIZE = value;
428 }
429 }
430 }
431
432 if (line != null && line.StartsWith("USE_GAUSSIAN"))
433 {
434 var values = line.Split("=");
435 if (values.Length > 1)
436 {
437 var ok = bool.TryParse(values[1], out var value);
438 if (ok)
439 {
440 settings.USE_GAUSSIAN = value;
441 }
442 }
443 }
444
445 if (line != null && line.StartsWith("MODE"))
446 {
447 var values = line.Split("=");
448 if (values.Length > 1)
449 {
450 var mode = values[1].Trim();
451 switch (mode)
452 {
453 case "CPU_DV":
454 settings.MODE = "CPU_DVi32";
455 break;
456 case "CPU_DVi32":
457 settings.MODE = mode;
458 break;
459 case "CPU_DVf32":
460 settings.MODE = mode;
461 break;
462 case "CPU_SV":
463 settings.MODE = "CPU_SVi32";
464 break;
465 case "CPU_SVi32":
466 settings.MODE = mode;
467 break;
468 case "CPU_SVf32":
469 settings.MODE = mode;
470 break;
471 case "CPU_DM":
472 settings.MODE = "CPU_DMi32";
473 break;
474 case "CPU_DMi32":
475 settings.MODE = mode;
476 break;
477 case "CPU_DMf32":
478 settings.MODE = mode;
479 break;
480 case "CPU_SM":
481 settings.MODE = "CPU_SMi32";
482 break;
483 case "CPU_SMi32":
484 settings.MODE = mode;
485 break;
486 case "CPU_SMf32":
487 settings.MODE = mode;
488 break;
489 case "GPU_DV":
490 settings.MODE = "GPU_DVf32";
491 break;
492 case "GPU_DVf32":
493 settings.MODE = mode;
494 break;
495 case "GPU_DM":
496 settings.MODE = "GPU_DMf32";
497 break;
498 case "GPU_DMf32":
499 settings.MODE = mode;
500 break;
501 case "GPU_SM":
502 settings.MODE = "GPU_SMf32";
503 break;
504 case "GPU_SMf32":
505 settings.MODE = mode;
506 break;
507 default:
508 settings.MODE = "CPU_SMi32";
509 break;
510 }
511 }
512 }
513 }
514 }
515
516 return settings;
517 }
518 }
519}
CandidateSearch.util.Settings
Settings for digestion, ion calculation and VectorSearch.
Definition Settings.cs:9
CandidateSearch.util.Settings.MAX_CLEAVAGES
int MAX_CLEAVAGES
Maximum number of missed cleavages allowed during digestion.
Definition Settings.cs:14
CandidateSearch.util.Settings.TOP_N
int TOP_N
The top n candidates that should be returned by the VectorSearch.
Definition Settings.cs:60
CandidateSearch.util.Settings.Settings
Settings(int MaxCleavages=2, int MinPepLength=5, int MaxPepLength=30, int MaxPrecursorCharge=4, string MaxFragmentCharge="+1", int MaxNeutralLosses=1, int MaxNeutralLossMods=2, bool DecoySearch=true, int TopN=1000, float Tolerance=0.02f, bool Normalize=false, bool UseGaussian=true, string Mode="CPU_SMi32")
Settings constructor to set the specified search parameters.
Definition Settings.cs:94
CandidateSearch.util.Settings.FIXED_MODIFICATIONS
Dictionary< string, double > FIXED_MODIFICATIONS
Dictionary for fixed modifications that maps amino acids to their possible modification masses.
Definition Settings.cs:44
CandidateSearch.util.Settings.MAX_FRAGMENT_CHARGE
string MAX_FRAGMENT_CHARGE
Maximum considered fragment ion charge.
Definition Settings.cs:32
CandidateSearch.util.Settings.MODE
string MODE
The search approach used by the VectorSearch.
Definition Settings.cs:76
CandidateSearch.util.Settings.addVariableModification
bool addVariableModification(string aminoAcid, double mass)
Add a variable modification to the variable modification dictionary.
Definition Settings.cs:140
CandidateSearch.util.Settings.NORMALIZE
bool NORMALIZE
Whether or not scores should be normalized by the VectorSearch.
Definition Settings.cs:68
CandidateSearch.util.Settings.VARIABLE_MODIFICATIONS
Dictionary< string, double > VARIABLE_MODIFICATIONS
Dictionary for variable modifications that maps amino acids to their possible modification masses.
Definition Settings.cs:48
CandidateSearch.util.Settings.MIN_PEP_LENGTH
int MIN_PEP_LENGTH
Minimum peptide length.
Definition Settings.cs:18
CandidateSearch.util.Settings.MAX_PEP_LENGTH
int MAX_PEP_LENGTH
Maximum peptide length.
Definition Settings.cs:22
CandidateSearch.util.Settings.TOLERANCE
float TOLERANCE
The tolerance used for the VectorSearch.
Definition Settings.cs:64
CandidateSearch.util.Settings.ToString
override string ToString()
Returns a string representation of the settings.
Definition Settings.cs:178
CandidateSearch.util.Settings.addFixedModification
bool addFixedModification(string aminoAcid, double mass)
Add a fixed modification to the fixed modification dictionary.
Definition Settings.cs:125
CandidateSearch.util.Settings.MAX_PRECURSOR_CHARGE
int MAX_PRECURSOR_CHARGE
Maximum considered precursor ion charge.
Definition Settings.cs:28
CandidateSearch.util.Settings.MAX_NEUTRAL_LOSSES
int MAX_NEUTRAL_LOSSES
Maximum number of considered neutral losses.
Definition Settings.cs:36
CandidateSearch.util.Settings.USE_GAUSSIAN
bool USE_GAUSSIAN
Whether or not peaks should be modelled as gaussian distributions by the VectorSearch.
Definition Settings.cs:72
CandidateSearch.util.Settings.DECOY_SEARCH
bool DECOY_SEARCH
Whether or not decoy search should be performed.
Definition Settings.cs:54
CandidateSearch.util.Settings.modificationsToString
string modificationsToString(bool variable=false)
Returns a string representation of the modifications.
Definition Settings.cs:154
CandidateSearch.util.Settings.MAX_NEUTRAL_LOSS_MODS
int MAX_NEUTRAL_LOSS_MODS
Maximum number of considered neutral loss modifications.
Definition Settings.cs:40