29 |
30 |
31 |
32 |
217 |
218 |
219 |
220 |
221 |
--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | Lorikeet Reference
2 | =====================================
3 |
4 | Lorikeet is a JQuery plugin to render MS/MS spectra annotated with fragment ions.
5 | The spectrum is interactive with zoom capabilities, selection of fragment types,
6 | switching annotations on and off etc. The plugin can, optionally, also render a MS1
7 | spectrum below the MS/MS spectrum, with options to highlight the precursor peak
8 | for the MS/MS scan, as well as any other precursor peaks.
9 |
10 |
11 | Files required for the plugin to work:
12 | 1. specview.js -- this file has the plugin's rendering functions
13 | 2. aminoacid.js
14 | 3. ion.js
15 | 4. peptide.js
16 | 5. jquery.flot.js -- this is a modified version of the flot (http://code.google.com/p/flot/)
17 | plotting library for JQuery. It is base off of subversion revision 263.
18 | 6. jquery.flot.selection.js -- part of the flot package. This is also from revision 263.
19 |
20 |
21 | Other Dependencies:
22 | 1. JQuery core library (tested with version 3.5.1)
23 | 2. JQuery UI library (tested with version 1.13.0. Lorikeet uses only the slider widget)
24 |
25 | A NOTE ABOUT Internet Explorer
26 | ---------------------------------------
27 | The flot JQuery plugin makes use of the canvas element of HTML5. This element is not
28 | supported in the current versions of IE. It should be supported in IE9.
29 | For the viewer to work on IE the ExplorerCanvas script has to be included in the page.
30 | This script brings the canvas functionality to IE.
31 |
32 | <%-- Only load the excanvas.min.js if it is IE 8 or lower. IE 8 does not support HTML5 so this is a way to have HTML5 canvas support --%>
33 |
34 |
35 |
36 |
37 | Examples:
38 | ---------------------------------------
39 | Please see the following examples of using the Lorikeet plugin in a html page:
40 | 1. example_use.html -- MS/MS spectrum only
41 | 2. example_use2.html -- MS/MS and MS1 spectra
42 |
43 |
44 | Stylesheet:
45 | ---------------------------------------
46 | The stylesheet lorikeet.css contains the necessary styling for the Lorikeet plugin.
47 | jquery-ui-1.13.0.slider.min.css contains the JQuery UI Slider specific CSS
48 |
49 |
50 | Usage:
51 | ---------------------------------------
52 | The following fragment has to be included in the HTML file where the viewer should be
53 | displayed. The id of the div can be any id that is unique on the page.
54 |
55 |
56 | The following fragment has to be included in a script element on the page. This is
57 | typically included in the window.onload function. $("#lorikeet") is the JQuery way
58 | of referring to a DOM element with the id "lorikeet".
59 | $("#lorikeet").specview(options);
60 |
61 |
62 | API Documentation:
63 | ---------------------------------------
64 | Lorikeet has only a single method that renders the viewer!
65 |
66 | specview(options)
67 |
68 | options is a set of key/value pairs that configure and provide data to the viewer.
69 |
70 | Options:
71 | {
72 | "sequence": null,
73 | "staticMods": [],
74 | "variableMods": [],
75 | "ntermMod": 0, // additional mass to be added to the n-term
76 | "ctermMod": 0, // additional mass to be added to the c-term
77 | "peaks": [],
78 | "massError": 0.5,
79 | "scanNum": null,
80 | "fileName": null,
81 | "charge": null,
82 | "precursorMz": null,
83 | "ms1peaks": null,
84 | "ms1scanLabel": null,
85 | "precursorPeaks": null,
86 | "precursorPeakClickFn": null,
87 | "zoomMs1": false,
88 | "width": 750, // width of the ms/ms plot
89 | "height": 450, // height of the ms/ms plot
90 | "extraPeakSeries": [],
91 | "showIonTable": true,
92 | "showViewingOptions": true,
93 | "showOptionsTable": true,
94 | "showSequenceInfo": true,
95 | "labelImmoniumIons": true,
96 | "labelPrecursorPeak": true,
97 | "labelReporters": false,
98 | "showMassErrorPlot": false,
99 | "massErrorPlotDefaultUnit": 'Da'
100 | }
101 |
102 | The required options(key/value pairs) are:
103 | ------------------------------------------
104 | 1. sequence: the sequence of the peptide
105 | 2. peaks: an array of peaks in the MS/MS scan.
106 | Example: [ [602.17,209860.34], [691.67,33731.58],[871.42,236841.11],[888.50,1005389.56] ]
107 |
108 | Other options (not required):
109 | ----------------------------
110 | 1. charge: The charge of the precursor. This information is displayed at the top of the scan.
111 | 2. precursorMz: The m/z of the precursor. This information is displayed at the top of the scan.
112 | This value is required for labeling the precursor peak in the MS1 scan if
113 | it is rendered, and also marking the precursor peak in the MS/MS scan.
114 | 3. scanNum: The scan number of the MS/MS scan. This information is displayed at the top of the scan.
115 | 4. fileName: Name of the file that contains the MS/MS scan. This information is displayed at the top of the scan.
116 | 5. staticMods: An array of static modifications. Each modification is a set of key/value pairs.
117 | Example: [{"modMass":57.0,"aminoAcid":"C"}];
118 | 4. variableMods: An array of variable modifications. Each modification is a set of key/value pairs.
119 | Example: [ {index: 14, modMass: 16.0, aminoAcid: 'M'} ] // index is the index (1-based)
120 | // of the modification in the sequence.
121 | 5. ntermMod: additional mass to be added to the N-terminus.
122 | 6. ctermMod: additional mass to be added to the C-terminus.
123 | 7. massError: mass tolerance used for labeling peaks in the MS/MS scan.
124 | 8. ms1Peaks: peaks in the MS1 scan. Format is the same as the "peaks" option.
125 | 9. precursorPeaks: Any precursor peaks in the MS1 scan that will be highlighted.
126 | Same format is the same as the "peaks" option.
127 | 10. zoomMs1: If the value is "true" the MS1 scan, upon initialization, is zoomed around the peak
128 | that is the closest match to the "precursorMz" option. Default is "false".
129 | 11. ms1scanLabel: Label for the MS1 scan.
130 | 12. precursorPeakClickFn: This is the function that will be called when a precursor peak is clicked.
131 | 13. width: width of the MS/MS plot area. Default is 750.
132 | 14. height: height of the MS/MS plot area. Default is 450.
133 | 15. extraPeakSeries: An array of user defined peak series. Each series should be a set of key value pairs.
134 | Example: {data: [[10.0,2.0],[20.0,3.0]], color: "#00aa00",labelType: 'mz',labels: ['one','two']}
135 | "labelType" should not be used if custom labels are provided as value to the "labels" key.
136 | If "labelType" is 'mz', custom labels are ignored.
137 | 16. showIonTable: Show a table with theoretical fragment ion masses to the right of the annotated MS/MS scan.
138 | Default is true.
139 | 17. showViewingOptions: Show zooming and other options at the bottom of the MS/MS scan. Default is true.
140 | 18. showOptionsTable: Show a table with all the available options to the left of the annotated MS/MS scan.
141 | Default is true.
142 | 19. showSequenceInfo: Show sequence, m/z, filename, scan number, charge etc. at the top of the MS/MS scan.
143 | Default is true.
144 | 20. labelImmoniumIons: Label immonium ions in the MS/MS scan. Default is true.
145 | Example file: example_precursor_immonium.html
146 | 21. labelPrecursorPeaks: Label precursor ion if found in the MS/MS scan. Default is true.
147 | Example file: example_precursor_immonium.html
148 | 22. labelReporters: Label reporter ions such as iTRAQ and TMT. Default is false.
149 | Example file: example_itraq.html
150 | 23. showMassErrorPlot: Display a plot showing the mass errors for annoated peaks. Default is false.
151 | Example file: example_mass_error_plot.html
152 | 24. massErrorPlotDefaultUnit: Unit for mass error plot. Default is 'Da'. Set to 'ppm' to see mass error in
153 | parts per million.
154 | }
155 |
156 |
--------------------------------------------------------------------------------
/js/ion.js:
--------------------------------------------------------------------------------
1 | // $LastChangedDate$
2 | // $LastChangedBy$
3 | // $LastChangedRevision$
4 |
5 | function Ion (t, color, charge, terminus) {
6 | this.type = t;
7 | this.color = color;
8 | this.charge = charge;
9 | this.label = this.type;
10 | if(this.charge > 1)
11 | this.label += charge;
12 | this.label += "+";
13 | this.term = terminus;
14 | }
15 |
16 | // Source: http://en.wikipedia.org/wiki/Web_colors
17 |
18 | // charge +1
19 | Ion.A_1 = new Ion("a", "#008000", 1, "n"); // green
20 | Ion.B_1 = new Ion("b", "#0000ff", 1, "n"); // blue
21 | Ion.C_1 = new Ion("c", "#008B8B", 1, "n"); // dark cyan
22 | Ion.X_1 = new Ion("x", "#4B0082", 1, "c"); // indigo
23 | Ion.Y_1 = new Ion("y", "#ff0000", 1, "c"); // red
24 | Ion.Z_1 = new Ion("z", "#FF8C00", 1, "c"); // dark orange
25 |
26 | // charge +2
27 | Ion.A_2 = new Ion("a", "#2E8B57", 2, "n"); // sea green
28 | Ion.B_2 = new Ion("b", "#4169E1", 2, "n"); // royal blue
29 | Ion.C_2 = new Ion("c", "#20B2AA", 2, "n"); // light sea green
30 | Ion.X_2 = new Ion("x", "#800080", 2, "c"); // purple
31 | Ion.Y_2 = new Ion("y", "#FA8072", 2, "c"); // salmon
32 | Ion.Z_2 = new Ion("z", "#FFA500", 2, "c"); // orange
33 |
34 | // charge +3
35 | Ion.A_3 = new Ion("a", "#9ACD32", 3, "n"); // yellow green
36 | Ion.B_3 = new Ion("b", "#00BFFF", 3, "n"); // deep sky blue
37 | Ion.C_3 = new Ion("c", "#66CDAA", 3, "n"); // medium aquamarine
38 | Ion.X_3 = new Ion("x", "#9932CC", 3, "c"); // dark orchid
39 | Ion.Y_3 = new Ion("y", "#FFA07A", 3, "c"); // light salmon
40 | Ion.Z_3 = new Ion("z", "#FFD700", 3, "c"); // gold
41 |
42 | var _ions = [];
43 | _ions["a"] = [];
44 | _ions["a"][1] = Ion.A_1;
45 | _ions["a"][2] = Ion.A_2;
46 | _ions["a"][3] = Ion.A_3;
47 | _ions["b"] = [];
48 | _ions["b"][1] = Ion.B_1;
49 | _ions["b"][2] = Ion.B_2;
50 | _ions["b"][3] = Ion.B_3;
51 | _ions["c"] = [];
52 | _ions["c"][1] = Ion.C_1;
53 | _ions["c"][2] = Ion.C_2;
54 | _ions["c"][3] = Ion.C_3;
55 | _ions["x"] = [];
56 | _ions["x"][1] = Ion.X_1;
57 | _ions["x"][2] = Ion.X_2;
58 | _ions["x"][3] = Ion.X_3;
59 | _ions["y"] = [];
60 | _ions["y"][1] = Ion.Y_1;
61 | _ions["y"][2] = Ion.Y_2;
62 | _ions["y"][3] = Ion.Y_3;
63 | _ions["z"] = [];
64 | _ions["z"][1] = Ion.Z_1;
65 | _ions["z"][2] = Ion.Z_2;
66 | _ions["z"][3] = Ion.Z_3;
67 |
68 | Ion.get = function _getIon(type, charge) {
69 |
70 | return _ions[type][charge];
71 | }
72 |
73 | Ion.getSeriesColor = function _getSeriesColor(ion) {
74 |
75 | return _ions[ion.type][ion.charge].color;
76 | }
77 |
78 |
79 | //-----------------------------------------------------------------------------
80 | // Ion Series
81 | //-----------------------------------------------------------------------------
82 | var MASS_H_1 = 1.00782503207; // H(1) Source: http://en.wikipedia.org/wiki/Isotopes_of_hydrogen
83 | var MASS_C_12 = 12.0; // C(12) Source: http://en.wikipedia.org/wiki/Isotopes_of_carbon
84 | var MASS_C_13 = 13.0033548378; // C(13) Source: http://en.wikipedia.org/wiki/Isotopes_of_carbon
85 | var MASS_N_14 = 14.0030740048; // N(14) Source: http://en.wikipedia.org/wiki/Isotopes_of_nitrogen
86 | var MASS_N_15 = 15.0001088982; // N(15) Source: http://en.wikipedia.org/wiki/Isotopes_of_nitrogen
87 | var MASS_O_16 = 15.99491461956; // O(16) Source: http://en.wikipedia.org/wiki/Isotopes_of_oxygen
88 | var MASS_O_18 = 17.9991610; // O(18) Source: http://en.wikipedia.org/wiki/Isotopes_of_oxygen
89 | var MASS_P_31 = 30.97376163; // P(31) Source: http://en.wikipedia.org/wiki/Isotopes_of_phosphorus
90 |
91 | // average masses
92 | var MASS_H = 1.00794; // Source: http://www.unimod.org/masses.html
93 | var MASS_C = 12.0107; // Source: http://en.wikipedia.org/wiki/Isotopes_of_carbon
94 | var MASS_N = 14.0067; // Source: http://en.wikipedia.org/wiki/Isotopes_of_nitrogen
95 | var MASS_O = 15.9994; // Source: http://en.wikipedia.org/wiki/Isotopes_of_oxygen
96 | var MASS_P = 30.9738; // Source: http://en.wikipedia.org/wiki/Isotopes_of_phosphorus
97 |
98 | var MASS_PROTON = 1.007276;
99 |
100 | Ion.MASS_PROTON = MASS_PROTON;
101 | Ion.MASS_H = MASS_H;
102 | Ion.MASS_C = MASS_C;
103 | Ion.MASS_N = MASS_N;
104 | Ion.MASS_O = MASS_O;
105 | Ion.MASS_P = MASS_P;
106 |
107 | Ion.MASS_H_1 = MASS_H_1;
108 | Ion.MASS_C_12 = MASS_C_12;
109 | Ion.MASS_C_13 = MASS_C_13;
110 | Ion.MASS_N_14 = MASS_N_14;
111 | Ion.MASS_N_15 = MASS_N_15;
112 | Ion.MASS_O_16 = MASS_O_16;
113 | Ion.MASS_O_18 = MASS_O_18;
114 | Ion.MASS_P_31 = MASS_P_31;
115 |
116 | // massType can be "mono" or "avg"
117 | Ion.getSeriesIon = function _getSeriesIon(ion, peptide, idxInSeq, massType) {
118 | if(ion.type == "a")
119 | return new Ion_A (peptide, idxInSeq, ion.charge, massType);
120 | if(ion.type == "b")
121 | return new Ion_B (peptide, idxInSeq, ion.charge, massType);
122 | if(ion.type == "c")
123 | return new Ion_C (peptide, idxInSeq, ion.charge, massType);
124 | if(ion.type == "x")
125 | return new Ion_X (peptide, idxInSeq, ion.charge, massType);
126 | if(ion.type == "y")
127 | return new Ion_Y (peptide, idxInSeq, ion.charge, massType);
128 | if(ion.type == "z")
129 | return new Ion_Z (peptide, idxInSeq, ion.charge, massType);
130 | }
131 |
132 | function _makeIonLabel(type, index, charge) {
133 | var label = type+""+index;
134 | for(var i = 1; i <= charge; i+=1)
135 | label += "+";
136 | return label;
137 | }
138 |
139 | function _getMz(neutralMass, charge) {
140 | return ( neutralMass + (charge * MASS_PROTON) ) / charge;
141 | }
142 |
143 | Ion.AmmoniaLossMass_mono = MASS_H_1 * 3 + MASS_N_14;
144 | Ion.AmmoniaLossMass_avg = MASS_H * 3 + MASS_N;
145 |
146 | Ion.WaterLossMass_mono = MASS_H_1 * 2 + MASS_O_16;
147 | Ion.WaterLossMass_avg = MASS_H * 2 + MASS_O;
148 |
149 | Ion.PhosphoLossMass_mono = MASS_H_1 * 3 + MASS_P_31 + MASS_O_16 * 4;
150 | Ion.PhosphoLossMass_avg = MASS_H * 3 + MASS_P + MASS_O * 4;
151 |
152 | function _getIonMzWithLoss(sion, neutralLosses, massType) {
153 | var neutralMass = (sion.mz * sion.charge) - (sion.charge * MASS_PROTON);
154 | var lossMass = 0;
155 | if(neutralLosses)
156 | {
157 | if(massType == 'mono') lossMass += neutralLosses.getTotalLossMass('mono');
158 | else if(massType == 'avg') lossMass += neutralLosses.getTotalLossMass('avg');
159 | }
160 | return _getMz((neutralMass - lossMass), sion.charge);
161 | }
162 |
163 | Ion.getMz = _getMz;
164 | Ion.getIonMzWithLoss = _getIonMzWithLoss;
165 |
166 | function Ion_A (peptide, endIdxPlusOne, charge, massType) {
167 | // Neutral mass: [N]+[M]-CHO ; N = mass of neutral N terminal group
168 | var mass = 0;
169 | if(massType == "mono")
170 | mass = peptide.getSeqMassMono(endIdxPlusOne, "n") - (MASS_C_12 + MASS_O_16);
171 | else if(massType == "avg")
172 | mass = peptide.getSeqMassAvg(endIdxPlusOne, "n") - (MASS_C + MASS_O);
173 | this.charge = charge;
174 | this.mz = _getMz(mass, charge);
175 | this.fragmentIndex = endIdxPlusOne;
176 | this.label = _makeIonLabel("a",this.fragmentIndex, charge);
177 | this.match = false;
178 | this.term = "n";
179 | return this;
180 | }
181 |
182 | function Ion_B (peptide, endIdxPlusOne, charge, massType) {
183 | // Neutral mass: [N]+[M]-H ; N = mass of neutral N terminal group
184 | var mass = 0;
185 | if(massType == "mono")
186 | mass = peptide.getSeqMassMono(endIdxPlusOne, "n");
187 | else if(massType == "avg")
188 | mass = peptide.getSeqMassAvg(endIdxPlusOne, "n");
189 | this.charge = charge;
190 | this.mz = _getMz(mass, charge);
191 | this.fragmentIndex = endIdxPlusOne;
192 | this.label = _makeIonLabel("b", this.fragmentIndex, charge);
193 | this.match = false;
194 | this.term = "n";
195 | return this;
196 | }
197 |
198 | function Ion_C (peptide, endIdxPlusOne, charge, massType) {
199 | // Neutral mass: [N]+[M]+NH2 ; N = mass of neutral N terminal group
200 | var mass = 0;
201 | if(massType == "mono")
202 | mass = peptide.getSeqMassMono(endIdxPlusOne, "n") + MASS_H_1 + (MASS_N_14 + 2*MASS_H_1);
203 | else if(massType == "avg")
204 | mass = peptide.getSeqMassAvg(endIdxPlusOne, "n") + MASS_H + (MASS_N + 2*MASS_H);
205 | this.charge = charge;
206 | this.mz = _getMz(mass, charge);
207 | this.fragmentIndex = endIdxPlusOne;
208 | this.label = _makeIonLabel("c", this.fragmentIndex, charge);
209 | this.match = false;
210 | this.term = "n";
211 | return this;
212 | }
213 |
214 | function Ion_X (peptide, startIdx, charge, massType) {
215 | // Neutral mass = [C]+[M]+CO-H ; C = mass of neutral C-terminal group (OH)
216 | var mass = 0;
217 | if(massType == "mono")
218 | mass = peptide.getSeqMassMono(startIdx, "c") + 2*MASS_O_16 + MASS_C_12;
219 | else if(massType == "avg")
220 | mass = peptide.getSeqMassAvg(startIdx, "c") + 2*MASS_O + MASS_C;
221 | this.charge = charge;
222 | this.mz = _getMz(mass, charge);
223 | this.fragmentIndex = peptide.sequence().length - startIdx;
224 | this.label = _makeIonLabel("x", this.fragmentIndex, charge);
225 | this.match = false;
226 | this.term = "c";
227 | return this;
228 | }
229 |
230 | function Ion_Y (peptide, startIdx, charge, massType) {
231 | // Neutral mass = [C]+[M]+H ; C = mass of neutral C-terminal group (OH)
232 | var mass = 0;
233 | if(massType == "mono")
234 | mass = peptide.getSeqMassMono(startIdx, "c") + 2*MASS_H_1 + MASS_O_16;
235 | else if(massType == "avg")
236 | mass = peptide.getSeqMassAvg(startIdx, "c") + 2*MASS_H + MASS_O;
237 | this.charge = charge;
238 | this.mz = _getMz(mass, charge);
239 | this.fragmentIndex = peptide.sequence().length - startIdx;
240 | this.label = _makeIonLabel("y", this.fragmentIndex, charge);
241 | this.match = false;
242 | this.term = "c";
243 | return this;
244 | }
245 |
246 | function Ion_Z (peptide, startIdx, charge, massType) {
247 | // Neutral mass = [C]+[M]-NH2 ; C = mass of neutral C-terminal group (OH)
248 | // We're really printing Z-dot ions so we add an H to make it OH+[M]-NH2 +H = [M]+O-N
249 | var mass = 0;
250 | if(massType == "mono")
251 | mass = peptide.getSeqMassMono(startIdx, "c") + MASS_O_16 - MASS_N_14;
252 | else if(massType == "avg")
253 | mass = peptide.getSeqMassAvg(startIdx, "c") + MASS_O - MASS_N;
254 | this.charge = charge;
255 | this.mz = _getMz(mass, charge);
256 | this.fragmentIndex = peptide.sequence().length - startIdx;
257 | this.label = _makeIonLabel("z", this.fragmentIndex, charge);
258 | this.match = false;
259 | this.term = "c";
260 | return this;
261 | }
262 |
--------------------------------------------------------------------------------
/html/example_use_neutral_loss.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Lorikeet Spectrum Viewer
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
Lorikeet Plugin Example
27 |
28 |
29 | Lorikeet can display custom neutral losses and multiple neutral losses per amino acid.
30 |
31 | The default is to have one neutral loss per amino acid, but you can set it to a higher number with the
32 | following option:
33 |
34 |
35 | maxNeutralLossCount: 2
36 |
37 | Custom potential losses at a residue can be specified in the modification options, as the losses array.
38 |
39 |
27 |
28 |
29 |
30 |
31 |
795 |
796 |
797 |
798 |
--------------------------------------------------------------------------------
/js/peptide.js:
--------------------------------------------------------------------------------
1 | // $LastChangedDate$
2 | // $LastChangedBy$
3 | // $LastChangedRevision$
4 |
5 | // -----------------------------------------------------------------------------
6 | // Peptide sequence and modifications
7 | // -----------------------------------------------------------------------------
8 | function Peptide(seq, staticModifications, varModifications, ntermModification, ctermModification, maxNeutralLossCount) {
9 |
10 | var sequence = seq;
11 | if(!sequence) {
12 | sequence = "";
13 | }
14 |
15 | var ntermMod = ntermModification;
16 | var ctermMod = ctermModification;
17 | var staticMods = [];
18 | var varMods = [];
19 | var potentialLosses_custom = {};
20 | var potentialLosses_lorikeet = {};
21 | var potentialLossesAtIndex = [];
22 | var nterm_totalLossOptions = [];
23 | var cterm_totalLossOptions = [];
24 | var maxNeutralLossCount = maxNeutralLossCount;
25 |
26 | var debug = false;
27 |
28 | _initNeutralLosses();
29 | _initStaticMods();
30 | _initVarMods();
31 | // calculate the total loss options at each index using only custom neutral losses.
32 | _calculateTotalLossOptions(null, maxNeutralLossCount);
33 |
34 |
35 | //----------------------------------------------------------------------------------------
36 | //----------------------------------------------------------------------------------------
37 | this.sequence = function () {
38 | return sequence;
39 | }
40 |
41 | this.varMods = function() {
42 | return varMods;
43 | }
44 |
45 | // index: index in the seq.
46 | // If this is a N-term sequence we will sum up the mass of the amino acids in the sequence up-to index (exclusive).
47 | // If this is a C-term sequence we will sum up the mass of the amino acids in the sequence starting from index (inclusive)
48 | // modification masses are added
49 | this.getSeqMassMono = function _seqMassMono(index, term) {
50 | return _getSeqMass(index, term, "mono");
51 | }
52 |
53 | // index: index in the seq.
54 | // If this is a N-term sequence we will sum up the mass of the amino acids in the sequence up-to index (exclusive).
55 | // If this is a C-term sequence we will sum up the mass of the amino acids in the sequence starting from index (inclusive)
56 | // modification masses are added
57 | this.getSeqMassAvg = function _seqMassAvg(index, term) {
58 | return _getSeqMass(index, term, "avg");
59 | }
60 |
61 | // Returns the monoisotopic neutral mass of the peptide; modifications added. N-term H and C-term OH are added
62 | this.getNeutralMassMono = function _massNeutralMono() {
63 |
64 | var mass = 0;
65 | var aa_obj = new AminoAcid();
66 | if(sequence) {
67 | for(var i = 0; i < sequence.length; i++) {
68 | var aa = aa_obj.get(sequence.charAt(i));
69 | mass += aa.mono;
70 | }
71 | }
72 |
73 | mass = _addTerminalModMass(mass, "n");
74 | mass = _addTerminalModMass(mass, "c");
75 | mass = _addResidueModMasses(mass, sequence.length, "n");
76 | // add N-terminal H
77 | mass = mass + Ion.MASS_H_1;
78 | // add C-terminal OH
79 | mass = mass + Ion.MASS_O_16 + Ion.MASS_H_1;
80 |
81 | return mass;
82 | }
83 |
84 | //Returns the avg neutral mass of the peptide; modifications added. N-term H and C-term OH are added
85 | this.getNeutralMassAvg = function _massNeutralAvg() {
86 |
87 | var mass = 0;
88 | var aa_obj = new AminoAcid();
89 | if(sequence) {
90 | for(var i = 0; i < sequence.length; i++) {
91 | var aa = aa_obj.get(sequence.charAt(i));
92 | mass += aa.avg;
93 | }
94 | }
95 |
96 | mass = _addTerminalModMass(mass, "n");
97 | mass = _addTerminalModMass(mass, "c");
98 | mass = _addResidueModMasses(mass, sequence.length, "n");
99 | // add N-terminal H
100 | mass = mass + Ion.MASS_H;
101 | // add C-terminal OH
102 | mass = mass + Ion.MASS_O + Ion.MASS_H;
103 |
104 | return mass;
105 | }
106 |
107 | this.getPotentialLosses = function _getPotentialLosses(sion)
108 | {
109 | var term = sion.term;
110 | var fragmentIndex = sion.fragmentIndex;
111 | if(term == 'n')
112 | {
113 | return nterm_totalLossOptions[fragmentIndex - 1];
114 | }
115 | if(term == 'c')
116 | {
117 | return cterm_totalLossOptions[sequence.length - fragmentIndex];
118 | }
119 | }
120 |
121 | this.customPotentialLosses = potentialLosses_custom;
122 | this.lorikeetPotentialLosses = potentialLosses_lorikeet;
123 | this.getLossForLabel = function _getLossForLabel(lossLabel)
124 | {
125 | var loss = potentialLosses_custom[lossLabel];
126 | if(loss) return loss;
127 | loss = potentialLosses_lorikeet[lossLabel];
128 | if(loss) return loss;
129 | }
130 | this.recalculateLossOptions = function _recalculate(selectedLossOptions, maxLossCount)
131 | {
132 | _calculateTotalLossOptions(selectedLossOptions, maxLossCount);
133 | }
134 |
135 | //----------------------------------------------------------------------------------------
136 | //----------------------------------------------------------------------------------------
137 |
138 | function _initStaticMods()
139 | {
140 | if(staticModifications) {
141 | for(var i = 0; i < staticModifications.length; i += 1) {
142 | var mod = staticModifications[i];
143 | staticMods[mod.aa.code] = mod;
144 | }
145 |
146 | for(var i = 0; i < sequence.length; i += 1) {
147 | var mod = staticMods[sequence.charAt(i)];
148 | if(mod && mod.losses) {
149 | for(var j = 0; j < mod.losses.length; j++) {
150 | _addCustomLoss(i, mod.losses[j]);
151 | }
152 | }
153 | }
154 | }
155 | }
156 |
157 | function _initVarMods()
158 | {
159 | if(varModifications) {
160 | for(var i = 0; i < varModifications.length; i += 1) {
161 | var mod = varModifications[i];
162 | if(mod) {
163 | varMods[mod.position] = mod;
164 |
165 | if(mod.losses) {
166 | for(var j = 0; j < mod.losses.length; j++) {
167 | var modIndex_0based = mod.position - 1; // mod.position is a 1-based index
168 | _addCustomLoss(modIndex_0based, mod.losses[j]);
169 | }
170 | }
171 | }
172 | }
173 | }
174 | }
175 |
176 | function _addCustomLoss(index, loss)
177 | {
178 | // Example: {avgLossMass: "97.995", monoLossMass: "97.977", formula: "H3PO4"}
179 | if(loss && loss.avgLossMass && loss.avgLossMass > 0.0 && loss.monoLossMass && loss.monoLossMass > 0.0)
180 | {
181 | var neutralLoss = new NeutralLoss(loss.monoLossMass, loss.avgLossMass, loss.formula, loss.label);
182 | potentialLossesAtIndex[index].push(neutralLoss);
183 | potentialLosses_custom[neutralLoss.label()] = neutralLoss;
184 | }
185 | }
186 |
187 | function _initNeutralLosses()
188 | {
189 | for(var i = 0; i < sequence.length; i++) {
190 | potentialLossesAtIndex[i] = []; // potential neutral loss possibilities at an index in the peptide sequence
191 | }
192 |
193 | var ammoniaLoss = NeutralLoss.AmmoniaLoss();
194 | var waterLoss = NeutralLoss.WaterLoss();
195 | var phosphoLoss = NeutralLoss.PhosphoLoss();
196 | potentialLosses_lorikeet[ammoniaLoss.label()] = ammoniaLoss;
197 | potentialLosses_lorikeet[waterLoss.label()] = waterLoss;
198 | potentialLosses_lorikeet[phosphoLoss.label()] = phosphoLoss;
199 |
200 | for(var i = 0; i < sequence.length; i += 1)
201 | {
202 | var aa = sequence.charAt(i);
203 | if(aa == 'K' || aa == 'R' || aa == 'Q' || aa == 'N')
204 | {
205 | potentialLossesAtIndex[i].push(ammoniaLoss);
206 | }
207 | if (aa == 'S' || aa == 'T' || aa == 'E' || aa == 'D')
208 | {
209 | potentialLossesAtIndex[i].push(waterLoss);
210 | }
211 | if (aa == 'S' || aa == 'T' || aa == 'Y')
212 | {
213 | potentialLossesAtIndex[i].push(phosphoLoss);
214 | }
215 | }
216 | }
217 |
218 | function _calculateTotalLossOptions(selectedLosses, maxLossCount)
219 | {
220 | if(!maxLossCount)
221 | maxLossCount = 1;
222 |
223 |
224 | var selectedLossLabels = {};
225 | if(!selectedLosses)
226 | {
227 | for(var lossLabel in potentialLosses_custom)
228 | {
229 | selectedLossLabels[lossLabel] = true;
230 | }
231 | }
232 | else
233 | {
234 | for(var i = 0; i < selectedLosses.length; i += 1)
235 | {
236 | if(selectedLosses[i])
237 | {
238 | selectedLossLabels[selectedLosses[i].label()] = true;
239 | }
240 | }
241 | }
242 | _initNeutralLossArrays(maxLossCount);
243 | _calculateTotalLossOptionsForTerm('n', selectedLossLabels, maxLossCount);
244 | _calculateTotalLossOptionsForTerm('c', selectedLossLabels, maxLossCount);
245 |
246 | if(debug)
247 | {
248 | _printPotentialLosses();
249 | _printNeutralLossCombinations();
250 | }
251 | }
252 |
253 | function _initNeutralLossArrays(maxLossCount)
254 | {
255 | for(var i = 0; i < sequence.length; i += 1)
256 | {
257 | nterm_totalLossOptions[i] = [];
258 | cterm_totalLossOptions[i] = [];
259 | for(var j = 0; j <= maxLossCount; j += 1)
260 | {
261 | nterm_totalLossOptions[i][j] = [];
262 | cterm_totalLossOptions[i][j] = [];
263 | }
264 | }
265 | }
266 |
267 | function _calculateTotalLossOptionsForTerm(term, selectedLossLabels, maxLossCount)
268 | {
269 | if(term == 'n')
270 | {
271 | for(var i = 0; i < sequence.length; i += 1) {
272 | _calculate(i, 0, 1, selectedLossLabels, nterm_totalLossOptions, maxLossCount);
273 | }
274 | }
275 | if(term == 'c')
276 | {
277 | var s = sequence.length - 1;
278 | for(var i = s; i >= 0; i -= 1) {
279 | _calculate(i, s, -1, selectedLossLabels, cterm_totalLossOptions, maxLossCount);
280 | }
281 | }
282 | }
283 |
284 | // totalLossOptionsArray[i] = lossOptions at index i in sequence.
285 | // totalLossOptionsArray[i][j] = LossCombinationList with j losses at index i in the sequence.
286 | // Each LossCombinationList contains an array of possible LossCombinations of j losses;
287 | function _calculate(i, s, incr, selectedLossLabels, totalLossOptionsArray, maxLossCount) {
288 |
289 | var lossOptions = potentialLossesAtIndex[i];
290 | var validLossOptions = [];
291 | for (var l = 0; l < lossOptions.length; l += 1) { // these are the potential losses at index i in the sequence.
292 | var loss = lossOptions[l];
293 | if(!(loss.label() in selectedLossLabels))
294 | continue;
295 | else
296 | validLossOptions.push(loss);
297 | }
298 |
299 | if(validLossOptions.length == 0)
300 | {
301 | if (i != s)
302 | {
303 | totalLossOptionsArray[i] = totalLossOptionsArray[i - incr];
304 | }
305 | else
306 | {
307 | for(var j = 1; j <= maxLossCount; j += 1)
308 | {
309 | totalLossOptionsArray[i][j] = new LossCombinationList(j);
310 | }
311 | }
312 | return;
313 | }
314 |
315 | var loss_options_at_i = [];
316 | totalLossOptionsArray[i] = loss_options_at_i;
317 | if(i == s)
318 | {
319 | for(j = 1; j <= maxLossCount; j += 1)
320 | {
321 | loss_options_at_i[j] = new LossCombinationList(j);
322 | }
323 | }
324 | else
325 | {
326 | var loss_options_before_i = totalLossOptionsArray[i - incr];
327 | for(j = 1; j <= maxLossCount; j += 1)
328 | {
329 | loss_options_at_i[j] = LossCombinationList.copyLossCombinationList(loss_options_before_i[j]);
330 | }
331 | }
332 |
333 | for(var l = 0; l < validLossOptions.length; l += 1)
334 | {
335 | var loss = validLossOptions[l];
336 |
337 | // iterate in reverse order so that we don't add the loss
338 | // in each iteration.
339 | for(var j = maxLossCount; j >= 1; j -= 1)
340 | {
341 | if(j == 1)
342 | {
343 | var loss_combi_list_at_j = loss_options_at_i[j];
344 | var loss_combi = new LossCombination();
345 | loss_combi.addLoss(loss);
346 | loss_combi_list_at_j.addLossCombination(loss_combi);
347 | }
348 | else
349 | {
350 | var loss_combi_list_at_jminus1 = loss_options_at_i[j-1];
351 | var loss_combi_list_at_j = LossCombinationList.copyLossCombinationList(loss_combi_list_at_jminus1);
352 | loss_options_at_i[j] = loss_combi_list_at_j;
353 | for(var k = 0; k < loss_combi_list_at_j.lossCombinationCount(); k += 1)
354 | {
355 | loss_combi_list_at_j.getLossCombination(k).addLoss(loss);
356 | }
357 | }
358 | }
359 | }
360 | }
361 |
362 | function _getMassesWithLoss(lossOptions, mass) {
363 | var massesWithLoss = [];
364 | var j = 0;
365 | for (var i = 0; i < lossOptions.length; i += 1) {
366 | var loss = lossOptions[i];
367 | if (loss > 0.0) {
368 | var massWithLoss = mass - loss;
369 | massesWithLoss[j] = {mass:massWithLoss, loss:loss};
370 | j++;
371 | }
372 | }
373 | return massesWithLoss;
374 | }
375 |
376 | function _addResidueModMasses(seqMass, index, term) {
377 |
378 | var mass = seqMass;
379 | var slice = new _Slice(index, term);
380 | for( var i = slice.from; i < slice.to; i += 1) {
381 | // add any static modifications
382 | var mod = staticMods[sequence.charAt(i)];
383 | if(mod) {
384 | mass += mod.modMass;
385 | }
386 | // add any variable modifications
387 | mod = varMods[i+1]; // varMods index in the sequence is 1-based
388 | if(mod) {
389 | mass += mod.modMass;
390 | }
391 | }
392 |
393 | return mass;
394 | }
395 |
396 | function _getSeqMass(index, term, massType) {
397 |
398 | var mass = 0;
399 | var aa_obj = new AminoAcid();
400 | if(sequence) {
401 | var slice = new _Slice(index, term);
402 | for( var i = slice.from; i < slice.to; i += 1) {
403 | var aa = aa_obj.get(sequence[i]);
404 | mass += aa[massType];
405 | }
406 | }
407 |
408 | mass = _addTerminalModMass(mass, term);
409 | mass = _addResidueModMasses(mass, index, term);
410 | return mass;
411 | }
412 |
413 | function _addTerminalModMass(seqMass, term) {
414 |
415 | var mass = seqMass;
416 | // add any terminal modifications
417 | if(term == "n" && ntermMod)
418 | mass += ntermMod;
419 | if(term == "c" && ctermMod)
420 | mass += ctermMod;
421 |
422 | return mass;
423 | }
424 |
425 | function _Slice(index, term) {
426 | if(term == "n") {
427 | this.from = 0;
428 | this.to = index;
429 | }
430 | if(term == "c") {
431 | this.from = index;
432 | this.to = sequence.length;
433 | }
434 | }
435 |
436 | function _printNeutralLossCombinations() {
437 |
438 | for(var i = 1; i < sequence.length; i += 1)
439 | {
440 | var subseq = sequence.substring(0, i);
441 | var lossOpts = nterm_totalLossOptions[i];
442 | _log(subseq + " -- ");
443 | for(var j = 1; j < lossOpts.length; j += 1)
444 | {
445 | _log(" -- "+j);
446 | var lossesAt_j = lossOpts[j];
447 | var count = lossesAt_j.lossCombinationCount();
448 | for (var k = 0; k < count; k += 1)
449 | {
450 | var lossCombo = lossesAt_j.getLossCombination(k);
451 | _log("---- " + lossCombo.getLabels());
452 | }
453 | }
454 | }
455 |
456 | for(var i = sequence.length - 1; i >= 0; i -= 1)
457 | {
458 | var subseq = sequence.substring(i, sequence.length);
459 | var lossOpts = cterm_totalLossOptions[i];
460 | _log(subseq + " -- ");
461 | for(var j = 1; j < lossOpts.length; j += 1)
462 | {
463 | _log(" -- "+j);
464 | var lossesAt_j = lossOpts[j];
465 | var count = lossesAt_j.lossCombinationCount();
466 | for (var k = 0; k < count; k += 1)
467 | {
468 | var lossCombo = lossesAt_j.getLossCombination(k);
469 | _log("---- " + lossCombo.getLabels());
470 | }
471 | }
472 | }
473 | }
474 |
475 | function _printPotentialLosses() {
476 | for (var i = 0; i < potentialLossesAtIndex.length; i += 1) {
477 | var losses = potentialLossesAtIndex[i];
478 | if (losses.length > 0)
479 | _log("Potential Losses at " + i + " " + sequence.charAt(i));
480 | for (var j = 0; j < losses.length; j++) {
481 | var loss = losses[j];
482 | _log(loss.monoLossMass + ", " + loss.avgLossMass + ", " + loss.formula + ", " + loss.label());
483 | }
484 | }
485 | }
486 |
487 | function _log(message)
488 | {
489 | if(debug)
490 | console.log(message);
491 | }
492 | }
493 |
494 |
495 | //-----------------------------------------------------------------------------
496 | // Modification
497 | //-----------------------------------------------------------------------------
498 | function Modification(aminoAcid, mass, losses) {
499 | this.aa = aminoAcid;
500 | this.modMass = mass;
501 | this.losses = losses;
502 | }
503 |
504 | function VariableModification(pos, mass, aminoAcid, losses) {
505 | this.position = parseInt(pos);
506 | this.aa = aminoAcid;
507 | this.modMass = mass;
508 | this.losses = losses;
509 | }
510 | //-----------------------------------------------------------------------------
511 | // Neutral loss
512 | //-----------------------------------------------------------------------------
513 | function NeutralLoss(lossMassMono, lossMassAvg, formula, label)
514 | {
515 | this.monoLossMass = lossMassMono;
516 | if(!this.monoLossMass)
517 | this.monoLossMass = 0.0;
518 | this.avgLossMass = lossMassAvg;
519 | if(!this.avgLossMass)
520 | this.avgLossMass = 0.0;
521 | this.formula = formula;
522 | this.userLabel = label;
523 | var _htmlLabel;
524 |
525 | this.longLabel = function _getLongLabel()
526 | {
527 | if(formula)
528 | {
529 | return formula + " ("+this.label()+")";
530 | }
531 | else
532 | {
533 | return this.label;
534 | }
535 | }
536 |
537 | this.label = function _getLabel()
538 | {
539 | if(this.userLabel) return this.userLabel;
540 | return "-"+Math.round(this.monoLossMass);
541 | }
542 |
543 | this.htmlLabel = function _getHtmlLabel()
544 | {
545 | if(_htmlLabel)
546 | return _htmlLabel;
547 |
548 | _htmlLabel = "";
549 | // html += H2O (o)
550 | if(formula)
551 | {
552 | for (var i = 0; i < formula.length; i++)
553 | {
554 | var charAt = formula.charAt(i);
555 | if(!isNaN(charAt))
556 | {
557 | _htmlLabel += ''+charAt+'';
558 | }
559 | else
560 | {
561 | _htmlLabel += charAt;
562 | }
563 | }
564 | _htmlLabel += " (";
565 | }
566 | _htmlLabel += ''+this.label()+'';
567 | if(formula)
568 | {
569 | _htmlLabel += ")";
570 | }
571 |
572 | return _htmlLabel;
573 | }
574 | }
575 |
576 | NeutralLoss.AmmoniaLoss = function _getAmmoniaLoss()
577 | {
578 | return new NeutralLoss(Ion.AmmoniaLossMass_mono, Ion.AmmoniaLossMass_avg, "NH3", "*");
579 | }
580 | NeutralLoss.WaterLoss = function _getWaterLoss()
581 | {
582 | return new NeutralLoss(Ion.WaterLossMass_mono, Ion.WaterLossMass_avg, "H2O", "o");
583 | }
584 | NeutralLoss.PhosphoLoss = function _getPhosphoLoss()
585 | {
586 | return new NeutralLoss(Ion.PhosphoLossMass_mono, Ion.PhosphoLossMass_avg, "H3PO4", "p");
587 | }
588 |
589 | function LossCombination()
590 | {
591 | this.losses = [];
592 |
593 | this.addLoss = function _addLoss(loss)
594 | {
595 | this.losses.push(loss);
596 | }
597 |
598 | this.getLabels = function _getLabels()
599 | {
600 | var label = "";
601 | for(var l = 0; l < this.losses.length; l += 1)
602 | {
603 | label += ", "+this.losses[l].label();
604 | }
605 | return label;
606 | }
607 |
608 | this.getLabel = function _getLabel()
609 | {
610 | if(this.losses.length == 1)
611 | {
612 | return " " + this.losses[0].label();
613 | }
614 | else
615 | {
616 | var lossMass = 0;
617 | for(var i = 0; i < this.losses.length; i += 1)
618 | {
619 | lossMass += this.losses[i].monoLossMass;
620 | }
621 | return " -" + Math.round(lossMass);
622 | }
623 | }
624 |
625 | this.getTotalLossMass = function _getTotalLossMass(massType)
626 | {
627 | var totalLoss = 0;
628 | for(var l = 0; l < this.losses.length; l += 1)
629 | {
630 | if(massType == 'mono')
631 | {
632 | totalLoss += this.losses[l].monoLossMass;
633 | }
634 | else if(massType == 'avg')
635 | {
636 | totalLoss += this.losses[l].avgLossMass;
637 | }
638 | }
639 | return totalLoss;
640 | }
641 | }
642 |
643 | LossCombination.copyLossCombination = function _copyLossCombination(originalLossCombination)
644 | {
645 | var newLossCombination = new LossCombination();
646 | var losses = originalLossCombination.losses;
647 | for(var l = 0; l < losses.length; l += 1)
648 | {
649 | newLossCombination.addLoss(losses[l]);
650 | }
651 | return newLossCombination;
652 | }
653 |
654 | function LossCombinationList(numLosses)
655 | {
656 | this.numLosses = numLosses;
657 | this.lossCombinations = [];
658 |
659 | this.lossCombinationCount = function _getLossCombinationCount()
660 | {
661 | return this.lossCombinations.length;
662 | }
663 |
664 | this.addLossCombination = function _addLossCombination(lossCombination)
665 | {
666 | var found = false;
667 |
668 | for(var l = 0; l < this.lossCombinationCount(); l += 1)
669 | {
670 | if(this.lossCombinations[l].getTotalLossMass('mono') == lossCombination.getTotalLossMass('mono'))
671 | {
672 | found = true;
673 | }
674 | }
675 | if(!found)
676 | {
677 | this.lossCombinations.push(lossCombination);
678 | }
679 | }
680 |
681 | this.getLossCombination = function _getLossCombinationAtIndex(index)
682 | {
683 | if(index >= 0 && index < this.lossCombinationCount())
684 | {
685 | return this.lossCombinations[index];
686 | }
687 | }
688 | }
689 | LossCombinationList.copyLossCombinationList = function _copyLossCombinationList(originalList)
690 | {
691 | var newLossCombinationList = new LossCombinationList(originalList.numLosses);
692 | var count = originalList.lossCombinationCount();
693 | for(var l = 0; l < count; l += 1)
694 | {
695 | var originalLossCombination = originalList.getLossCombination(l);
696 | var lossCombination = LossCombination.copyLossCombination(originalLossCombination);
697 | newLossCombinationList.addLossCombination(lossCombination);
698 | }
699 | return newLossCombinationList;
700 | }
701 |
702 |
703 |
704 |
--------------------------------------------------------------------------------
/html/example_user_reporter_ions.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Lorikeet Spectrum Viewer
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
Lorikeet Plugin Example
27 |
28 |
29 | The userReporterIons option allows you to find and label specific peaks in the MS2
30 | spectrum based on their expected m/z value. In the example below, 498.24 and 1608.54 were
31 | passed in as reporter ion masses using the following option:
32 |
33 |
34 |