@teselagen/sequence-utils 0.1.22 → 0.1.23

package/src/bioData.js

@@ -0,0 +1,431 @@
+//Adapted from biopython. Check the BIOPYTHON_LICENSE for licensing info
+
+export const protein_letters = "ACDEFGHIKLMNPQRSTVWY";
+
+export const extended_protein_letters = "ACDEFGHIKLMNPQRSTVWYBXZJUO.*-";
+
+// #   B = "Asx";  aspartic acid or asparagine (D or N)
+// #   X = "Xxx";  unknown or 'other' amino acid
+// #   Z = "Glx";  glutamic acid or glutamine (E or Q)
+// #   http://www.chem.qmul.ac.uk/iupac/AminoAcid/A2021.html#AA212
+// #
+// #   J = "Xle";  leucine or isoleucine (L or I, used in NMR)
+// #   Mentioned in http://www.chem.qmul.ac.uk/iubmb/newsletter/1999/item3.html
+// #   Also the International Nucleotide Sequence Database Collaboration (INSDC)
+// #   (i.e. GenBank, EMBL, DDBJ) adopted this in 2006
+// #   http://www.ddbj.nig.ac.jp/insdc/icm2006-e.html
+// #
+// #   Xle (J); Leucine or Isoleucine
+// #   The residue abbreviations, Xle (the three-letter abbreviation) and J
+// #   (the one-letter abbreviation) are reserved for the case that cannot
+// #   experimentally distinguish leucine from isoleucine.
+// #
+// #   U = "Sec";  selenocysteine
+// #   http://www.chem.qmul.ac.uk/iubmb/newsletter/1999/item3.html
+// #
+// #   O = "Pyl";  pyrrolysine
+// #   http://www.chem.qmul.ac.uk/iubmb/newsletter/2009.html#item35
+
+export const protein_letters_1to3 = {
+  A: "Ala",
+  C: "Cys",
+  D: "Asp",
+  E: "Glu",
+  F: "Phe",
+  G: "Gly",
+  H: "His",
+  I: "Ile",
+  K: "Lys",
+  L: "Leu",
+  M: "Met",
+  N: "Asn",
+  P: "Pro",
+  Q: "Gln",
+  R: "Arg",
+  S: "Ser",
+  T: "Thr",
+  V: "Val",
+  W: "Trp",
+  Y: "Tyr",
+  O: "Pyl",
+  U: "Sec"
+};
+
+// module.exports.protein_letters_1to3_extended = dict(
+//   list(protein_letters_1to3.items()) +
+//     list(
+//       {
+//         B: "Asx",
+//         X: "Xaa",
+//         Z: "Glx",
+//         J: "Xle",
+//         U: "Sel",
+//         O: "Pyl"
+//       }.items()
+//     )
+// );
+
+export const ambiguous_dna_letters = "GATCRYWSMKHBVDN";
+
+export const unambiguous_dna_letters = "GATC";
+export const ambiguous_rna_letters = "GAUCRYWSMKHBVDN";
+export const unambiguous_rna_letters = "GAUC";
+
+// #   B == 5-bromouridine
+// #   D == 5,6-dihydrouridine
+// #   S == thiouridine
+// #   W == wyosine
+export const extended_dna_letters = "GATCBDSW";
+
+// # are there extended forms?
+// # extended_rna_letters = "GAUCBDSW"
+
+export const ambiguous_dna_values = {
+  ".": ".",
+  A: "A",
+  C: "C",
+  G: "G",
+  T: "T",
+  M: "AC",
+  R: "AG",
+  W: "AT",
+  S: "CG",
+  Y: "CT",
+  K: "GT",
+  V: "ACG",
+  H: "ACT",
+  D: "AGT",
+  B: "CGT",
+  X: "GATC",
+  N: "GATC"
+};
+
+export const ambiguous_rna_values = {
+  ".": ".",
+  A: "A",
+  C: "C",
+  G: "G",
+  U: "U",
+  M: "AC",
+  R: "AG",
+  W: "AU",
+  S: "CG",
+  Y: "CU",
+  K: "GU",
+  V: "ACG",
+  H: "ACU",
+  D: "AGU",
+  B: "CGU",
+  X: "GAUC",
+  N: "GAUC"
+};
+
+export const ambiguous_dna_complement = {
+  ".": ".",
+  A: "T",
+  C: "G",
+  G: "C",
+  T: "A",
+  M: "K",
+  R: "Y",
+  W: "W",
+  S: "S",
+  Y: "R",
+  K: "M",
+  V: "B",
+  H: "D",
+  D: "H",
+  B: "V",
+  X: "X",
+  N: "N"
+};
+
+export const ambiguous_rna_complement = {
+  ".": ".",
+  A: "U",
+  C: "G",
+  G: "C",
+  U: "A",
+  M: "K",
+  R: "Y",
+  W: "W",
+  S: "S",
+  Y: "R",
+  K: "M",
+  V: "B",
+  H: "D",
+  D: "H",
+  B: "V",
+  X: "X",
+  N: "N"
+};
+
+// # Mass data taken from PubChem
+
+// # Average masses of monophosphate deoxy nucleotides
+export const unambiguous_dna_weights = {
+  A: 331.2218,
+  C: 307.1971,
+  G: 347.2212,
+  T: 322.2085
+};
+
+// # Monoisotopic masses of monophospate deoxy nucleotides
+export const monoisotopic_unambiguous_dna_weights = {
+  A: 331.06817,
+  C: 307.056936,
+  G: 347.063084,
+  T: 322.056602
+};
+
+// module.exports.unambiguous_dna_weight_ranges = _make_ranges(
+//   unambiguous_dna_weights
+// );
+
+export const unambiguous_rna_weights = {
+  A: 347.2212,
+  C: 323.1965,
+  G: 363.2206,
+  U: 324.1813
+};
+
+export const monoisotopic_unambiguous_rna_weights = {
+  A: 347.063084,
+  C: 323.051851,
+  G: 363.057999,
+  U: 324.035867
+};
+
+// module.exports.unambiguous_rna_weight_ranges = _make_ranges(
+//   unambiguous_rna_weights
+// );
+
+// def _make_ambiguous_ranges(mydict, weight_table):
+//     range_d = {}
+//     avg_d = {}
+//     for letter, values in mydict.items():
+//         # Following line is a quick hack to skip undefined weights for U and O
+//         if len(values) == 1 and values[0] not in weight_table:
+//             continue
+
+//         weights = [weight_table.get(x) for x in values]
+//         range_d[letter] = (min(weights), max(weights))
+//         total_w = 0.0
+//         for w in weights:
+//             total_w = total_w + w
+//         avg_d[letter] = total_w / len(weights)
+//     return range_d, avg_d
+
+// ambiguous_dna_weight_ranges, avg_ambiguous_dna_weights = \
+//                _make_ambiguous_ranges(ambiguous_dna_values,
+//                                       unambiguous_dna_weights)
+
+// ambiguous_rna_weight_ranges, avg_ambiguous_rna_weights = \
+//                _make_ambiguous_ranges(ambiguous_rna_values,
+//                                       unambiguous_rna_weights)
+
+export const protein_weights = {
+  A: 89.0932,
+  C: 121.1582,
+  D: 133.1027,
+  E: 147.1293,
+  F: 165.1891,
+  G: 75.0666,
+  H: 155.1546,
+  I: 131.1729,
+  K: 146.1876,
+  L: 131.1729,
+  M: 149.2113,
+  N: 132.1179,
+  O: 255.3134,
+  P: 115.1305,
+  Q: 146.1445,
+  R: 174.201,
+  S: 105.0926,
+  T: 119.1192,
+  U: 168.0532,
+  V: 117.1463,
+  W: 204.2252,
+  Y: 181.1885
+};
+
+export const monoisotopic_protein_weights = {
+  A: 89.047678,
+  C: 121.019749,
+  D: 133.037508,
+  E: 147.053158,
+  F: 165.078979,
+  G: 75.032028,
+  H: 155.069477,
+  I: 131.094629,
+  K: 146.105528,
+  L: 131.094629,
+  M: 149.051049,
+  N: 132.053492,
+  O: 255.158292,
+  P: 115.063329,
+  Q: 146.069142,
+  R: 174.111676,
+  S: 105.042593,
+  T: 119.058243,
+  U: 168.964203,
+  V: 117.078979,
+  W: 204.089878,
+  Y: 181.073893
+};
+
+export const extended_protein_values = {
+  A: "A",
+  B: "ND",
+  C: "C",
+  D: "D",
+  E: "E",
+  F: "F",
+  G: "G",
+  H: "H",
+  I: "I",
+  J: "IL",
+  K: "K",
+  L: "L",
+  M: "M",
+  N: "N",
+  O: "O",
+  P: "P",
+  Q: "Q",
+  R: "R",
+  S: "S",
+  T: "T",
+  U: "U",
+  V: "V",
+  W: "W",
+  X: "ACDEFGHIKLMNPQRSTVWY",
+  // # TODO - Include U and O in the possible values of X?
+  // # This could alter the extended_protein_weight_ranges ...
+  // # by MP: Won't do this, because they are so rare.
+  Y: "Y",
+  Z: "QE",
+  "*": "\\*\\.",
+  ".": "\\.\\.",
+  "-": "\\-"
+};
+
+// protein_weight_ranges = _make_ranges(protein_weights)
+
+// extended_protein_weight_ranges, avg_extended_protein_weights = \
+//                _make_ambiguous_ranges(extended_protein_values,
+//                                       protein_weights)
+
+// # For Center of Mass Calculation.
+// # Taken from http://www.chem.qmul.ac.uk/iupac/AtWt/ & PyMol
+export const atom_weights = {
+  H: 1.00794,
+  D: 2.0141,
+  He: 4.002602,
+  Li: 6.941,
+  Be: 9.012182,
+  B: 10.811,
+  C: 12.0107,
+  N: 14.0067,
+  O: 15.9994,
+  F: 18.9984032,
+  Ne: 20.1797,
+  Na: 22.98977,
+  Mg: 24.305,
+  Al: 26.981538,
+  Si: 28.0855,
+  P: 30.973761,
+  S: 32.065,
+  Cl: 35.453,
+  Ar: 39.948,
+  K: 39.0983,
+  Ca: 40.078,
+  Sc: 44.95591,
+  Ti: 47.867,
+  V: 50.9415,
+  Cr: 51.9961,
+  Mn: 54.938049,
+  Fe: 55.845,
+  Co: 58.9332,
+  Ni: 58.6934,
+  Cu: 63.546,
+  Zn: 65.39,
+  Ga: 69.723,
+  Ge: 72.64,
+  As: 74.9216,
+  Se: 78.96,
+  Br: 79.904,
+  Kr: 83.8,
+  Rb: 85.4678,
+  Sr: 87.62,
+  Y: 88.90585,
+  Zr: 91.224,
+  Nb: 92.90638,
+  Mo: 95.94,
+  Tc: 98.0,
+  Ru: 101.07,
+  Rh: 102.9055,
+  Pd: 106.42,
+  Ag: 107.8682,
+  Cd: 112.411,
+  In: 114.818,
+  Sn: 118.71,
+  Sb: 121.76,
+  Te: 127.6,
+  I: 126.90447,
+  Xe: 131.293,
+  Cs: 132.90545,
+  Ba: 137.327,
+  La: 138.9055,
+  Ce: 140.116,
+  Pr: 140.90765,
+  Nd: 144.24,
+  Pm: 145.0,
+  Sm: 150.36,
+  Eu: 151.964,
+  Gd: 157.25,
+  Tb: 158.92534,
+  Dy: 162.5,
+  Ho: 164.93032,
+  Er: 167.259,
+  Tm: 168.93421,
+  Yb: 173.04,
+  Lu: 174.967,
+  Hf: 178.49,
+  Ta: 180.9479,
+  W: 183.84,
+  Re: 186.207,
+  Os: 190.23,
+  Ir: 192.217,
+  Pt: 195.078,
+  Au: 196.96655,
+  Hg: 200.59,
+  Tl: 204.3833,
+  Pb: 207.2,
+  Bi: 208.98038,
+  Po: 208.98,
+  At: 209.99,
+  Rn: 222.02,
+  Fr: 223.02,
+  Ra: 226.03,
+  Ac: 227.03,
+  Th: 232.0381,
+  Pa: 231.03588,
+  U: 238.02891,
+  Np: 237.05,
+  Pu: 244.06,
+  Am: 243.06,
+  Cm: 247.07,
+  Bk: 247.07,
+  Cf: 251.08,
+  Es: 252.08,
+  Fm: 257.1,
+  Md: 258.1,
+  No: 259.1,
+  Lr: 262.11,
+  Rf: 261.11,
+  Db: 262.11,
+  Sg: 266.12,
+  Bh: 264.12,
+  Hs: 269.13,
+  Mt: 268.14
+};

package/src/calculateNebTa.js

@@ -0,0 +1,34 @@
+import calculateTm from "./calculateNebTm";
+
+export default function calculateNebTa(
+  sequences,
+  primerConc,
+  { monovalentCationConc, polymerase } = {}
+) {
+  try {
+    if (sequences.length !== 2) {
+      throw new Error(
+        `${sequences.length} sequences received when 2 primers were expected`
+      );
+    }
+    const meltingTemperatures = sequences.map(seq =>
+      calculateTm(seq, primerConc, { monovalentCationConc })
+    );
+    meltingTemperatures.sort((a, b) => a - b);
+    const lowerMeltingTemp = meltingTemperatures[0];
+    let annealingTemp;
+    if (polymerase === "Q5") {
+      // Ta = Tm_lower+1°C is standard for Q5
+      annealingTemp = lowerMeltingTemp + 1;
+      if (annealingTemp > 72) {
+        // "Annealing temperature for experiments with this enzyme should typically not exceed 72°C"
+        annealingTemp = 72;
+      }
+    } else {
+      annealingTemp = lowerMeltingTemp - 3;
+    }
+    return annealingTemp;
+  } catch (err) {
+    return `Error calculating annealing temperature: ${err}`;
+  }
+};

package/src/calculateNebTa.test.js

@@ -0,0 +1,57 @@
+import assert from "assert";
+import calculateTa from "./calculateNebTa";
+
+describe("calculate Ta", () => {
+  it("should return the annealing temperature of two primers based on Q5 protocol", () => {
+    // primer concentration in Q5 protocol is 500 nM
+    const primerConc = 0.0000005;
+    const options = {
+      // 50 mM KCl in Q5 protocol
+      monovalentCationConc: 0.05,
+      polymerase: "Q5"
+    };
+
+    const sequenceSet1 = ["AGCGGATAACAATTTCACACAGGA", "GTAAAACGACGGCCAGT"];
+    assert.equal(
+      calculateTa(sequenceSet1, primerConc, options),
+      63.54033701264342
+    );
+    const sequenceSet2 = ["AGCGGATAAGGGCAATTTCAC", "GTAAAACGACGGCCA"];
+    assert.equal(
+      calculateTa(sequenceSet2, primerConc, options),
+      59.95638912652805
+    );
+    const sequenceSet3 = [
+      "AGCGGATAAGGGCAATTTCAC",
+      "GTAAAACGACGGCCA",
+      "AGCGGATAACAATTTCAC"
+    ];
+    assert.equal(
+      calculateTa(sequenceSet3, primerConc, options),
+      "Error calculating annealing temperature: Error: 3 sequences received when 2 primers were expected"
+    );
+    // "Annealing temperature for experiments with this enzyme should typically not exceed 72°C"
+    const sequenceSet4 = [
+      "CACACCAGGTCTCAGATATACATATGACAGACAAACCGGCCAAAGG",
+      "CACACCAGGTCTCACTCCTTCTTAAATCATCGGGTCAGCACGTAGG"
+    ];
+    assert.equal(calculateTa(sequenceSet4, primerConc, options), 72);
+  });
+
+  it("should return the annealing temperature of two primers without a specified polymerase", () => {
+    // primer concentration 500 nM
+    const primerConc = 0.0000005;
+    const options = {
+      // 50 mM KCl
+      monovalentCationConc: 0.05
+    };
+    const sequenceSet = [
+      "CACACCAGGTCTCAGATATACATATGACAGACAAACCGGCCAAAGG",
+      "CACACCAGGTCTCACTCCTTCTTAAATCATCGGGTCAGCACGTAGG"
+    ];
+    assert.equal(
+      calculateTa(sequenceSet, primerConc, options),
+      74.49383180968016
+    );
+  });
+});

package/src/calculateNebTm.js

@@ -0,0 +1,127 @@
+import getComplementSequenceString from "./getComplementSequenceString";
+import calculatePercentGc from "./calculatePercentGC";
+
+// sources of formulas:
+// - https://tmcalculator.neb.com/#!/help
+// - Tm calculation: SantaLucia (1998) PNAS 95:1460-5
+// - salt correction (for monovalent cations): Owczarzy (2004) Biochem 43:3537-54
+
+// primer concentration & monovalent cation concentration in M
+export default function calculateNebTm(
+  sequence,
+  primerConc,
+  { monovalentCationConc } = {}
+) {
+  try {
+    const checkForDegenerateBases = /[^atgc]/i.test(sequence);
+    if (checkForDegenerateBases) {
+      throw new Error(
+        `Degenerate bases prohibited in Tm calculation of sequence ${sequence}`
+      );
+    }
+    const seq = sequence.toUpperCase().split("");
+    // enthalpy, entropy
+    let h = 0;
+    let s = 0;
+    // adjustments for helix initiation
+    let hi = 0;
+    let si = 0;
+    // R = universal gas constant with units of cal/(K*mol)
+    const r = 1.987;
+    // to convert the units of Tm from kelvin to celsius and vice versa
+    const kelvinToCelsius = -273.15;
+    const celsiusToKelvin = 273.15;
+    // to convert the units of enthalpy from kilocal/mol to cal/mol
+    const kilocalToCal = 1000;
+    const sequenceToEnthalpyMap = {
+      "AA/TT": -7.9,
+      "AT/TA": -7.2,
+      "TA/AT": -7.2,
+      "CA/GT": -8.5,
+      "GT/CA": -8.4,
+      "CT/GA": -7.8,
+      "GA/CT": -8.2,
+      "CG/GC": -10.6,
+      "GC/CG": -9.8,
+      "GG/CC": -8.0,
+      "TT/AA": -7.9,
+      "TG/AC": -8.5,
+      "AC/TG": -8.4,
+      "AG/TC": -7.8,
+      "TC/AG": -8.2,
+      "CC/GG": -8.0,
+      initiationWithTerminalGC: 0.1,
+      initiationWithTerminalAT: 2.3
+    };
+    const sequenceToEntropyMap = {
+      "AA/TT": -22.2,
+      "AT/TA": -20.4,
+      "TA/AT": -21.3,
+      "CA/GT": -22.7,
+      "GT/CA": -22.4,
+      "CT/GA": -21.0,
+      "GA/CT": -22.2,
+      "CG/GC": -27.2,
+      "GC/CG": -24.4,
+      "GG/CC": -19.9,
+      "TT/AA": -22.2,
+      "TG/AC": -22.7,
+      "AC/TG": -22.4,
+      "AG/TC": -21.0,
+      "TC/AG": -22.2,
+      "CC/GG": -19.9,
+      initiationWithTerminalGC: -2.8,
+      initiationWithTerminalAT: 4.1
+    };
+    for (let i = 0; i < seq.length; i++) {
+      if (i === 0 || i === seq.length - 1) {
+        // first or last nucleotide
+        if (seq[i] === "G" || seq[i] === "C") {
+          hi += sequenceToEnthalpyMap.initiationWithTerminalGC;
+          si += sequenceToEntropyMap.initiationWithTerminalGC;
+        } else if (seq[i] === "A" || seq[i] === "T") {
+          hi += sequenceToEnthalpyMap.initiationWithTerminalAT;
+          si += sequenceToEntropyMap.initiationWithTerminalAT;
+        }
+      }
+      if (i < seq.length - 1) {
+        const dimer = seq[i] + seq[i + 1];
+        const complement = getComplementSequenceString(dimer).toUpperCase();
+        const dimerDuplex = `${dimer}/${complement}`;
+        if (
+          !sequenceToEnthalpyMap[dimerDuplex] ||
+          !sequenceToEntropyMap[dimerDuplex]
+        ) {
+          throw new Error(
+            `Could not find value for ${dimerDuplex} of sequence ${sequence}`
+          );
+        }
+        h += sequenceToEnthalpyMap[dimerDuplex];
+        s += sequenceToEntropyMap[dimerDuplex];
+      }
+    }
+    // this calculated Tm assumes 1 M monovalent cation concentration
+    const deltaH = h + hi;
+    const deltaS = s + si;
+    const numerator = deltaH * kilocalToCal;
+    const denominator = deltaS + r * Math.log(primerConc);
+    const meltingTemp = numerator / denominator + kelvinToCelsius;
+    if (monovalentCationConc) {
+      // adjusting Tm for actual monovalent cation concentration
+      const lnOfMonoConc = Math.log(monovalentCationConc);
+      const gcContent = calculatePercentGc(sequence) / 100;
+      const part = 4.29 * gcContent - 3.95;
+      const saltCorrection =
+        part * Math.pow(10, -5) * lnOfMonoConc +
+        Math.pow(9.4, -6) * Math.pow(lnOfMonoConc, 2);
+      const adjustedMeltingTemp =
+        1 / (1 / (meltingTemp + celsiusToKelvin) + saltCorrection) +
+        kelvinToCelsius;
+      return adjustedMeltingTemp;
+    } else {
+      return meltingTemp;
+    }
+  } catch (err) {
+    return `Error calculating Tm for sequence ${sequence}: ${err}`;
+  }
+};

package/src/calculateNebTm.test.js

@@ -0,0 +1,32 @@
+import assert from "assert";
+import calculateTm from "./calculateNebTm";
+
+describe("calculate Tm based on SantaLucia 1998 & Owczarzy 2004", () => {
+  it("should return the melting temperature of a given sequence, if no degenerate bases are present", () => {
+    const options = {
+      // 50 mM KCl in Q5 protocol
+      monovalentCationConc: 0.05
+    };
+    // primer concentration in Q5 protocol is 500 nM
+    assert.equal(
+      calculateTm("AGCGGATAACAATTTCACACAGGA", 0.0000005, options),
+      65.8994505801345
+    );
+    assert.equal(
+      calculateTm("AGCGGATAACAATTTCAC", 0.0000005, options),
+      56.11037835109477
+    );
+    assert.equal(
+      calculateTm("AGCGGATAACAATTTcac", 0.0000005, options),
+      56.11037835109477
+    );
+    assert.equal(
+      calculateTm("AGCGGNNN", 0.0000005, options),
+      "Error calculating Tm for sequence AGCGGNNN: Error: Degenerate bases prohibited in Tm calculation of sequence AGCGGNNN"
+    );
+    assert.equal(
+      calculateTm("AGCGGnnn", 0.0000005, options),
+      "Error calculating Tm for sequence AGCGGnnn: Error: Degenerate bases prohibited in Tm calculation of sequence AGCGGnnn"
+    );
+  });
+});

package/src/calculatePercentGC.js

@@ -0,0 +1,3 @@
+export default function calculatePercentGC(bps) {
+  return (bps.match(/[cg]/gi) || []).length / bps.length * 100 || 0;
+};

package/src/calculatePercentGC.test.js

@@ -0,0 +1,14 @@
+import calculatePercentGC from "./calculatePercentGC";
+import assert from "assert";
+
+describe("calculatePercentGC", () => {
+  it("should return the percent GC of a given sequence string", () => {
+    assert.equal(calculatePercentGC("gact"), 50);
+    assert.equal(Math.floor(calculatePercentGC("gac")), 66);
+    assert.equal(calculatePercentGC("a"), 0);
+    assert.equal(calculatePercentGC(""), 0);
+    assert.equal(calculatePercentGC("ggg"), 100);
+    assert.equal(calculatePercentGC("GGG"), 100);
+    assert.equal(calculatePercentGC("ccc"), 100);
+  });
+});