IsoSpecPy 2.5.0__py3-none-win32.whl

IsoSpecPy/Advanced.py

@@ -0,0 +1,32 @@
+'''This file contains a set of functions useful for the analysis of properties of
+isotopic envelopes. These are unlikely to be of any interest to end-users, only
+for developers interested in testing some properties of the isotopic envelopes.
+These are implemented mostly in Python, and so, not as fast as the rest of the
+package.'''
+
+def _int_neighbours(subisotopologue_conf):
+    conf = list(subisotopologue_conf)
+    for i in range(len(conf)):
+        for j in range(len(conf)):
+            if i != j and conf[i] > 0:
+                conf[i] -= 1
+                conf[j] += 1
+                yield tuple(conf)
+                conf[i] += 1
+                conf[j] -= 1
+
+
+def neighbours(conf):
+    for i in range(len(conf)):
+        for si_neigh in _int_neighbours(conf[i]):
+            yield tuple(conf[j] if j != i else si_neigh for j in range(len(conf)))
+
+
+
+
+def conf_mass(iso, conf):
+    return sum(sum(mass * cnt for mass, cnt in zip(masses, cnts)) for masses, cnts in zip(iso.isotopeMasses, conf))
+
+
+from IsoSpecPy import Iso
+Iso.conf_mass = conf_mass

IsoSpecPy/Distributions.py

@@ -0,0 +1,93 @@
+import math
+
+from .IsoSpecPy import IsoDistribution
+
+
+
+
+def simple_inverse(fun, prec = 0.01):
+    
+    def inverse(x):
+        start = -1.0
+        while fun(start) > x:
+            start *= 2.0
+        end = 1.0
+        while fun(end) < x:
+            end *= 2.0
+
+        while (end - start) > prec:
+            mid = (end + start) * 0.5
+            if fun(mid) < x:
+                start = mid
+            else:
+                end = mid
+
+        return (end + start) * 0.5
+
+    return inverse
+            
+
+
+class Distribution(IsoDistribution):
+    def __init__(self, cdf, bin_width = 0.01, precision = 0.99, inverse_cdf = None):
+        if inverse_cdf is None:
+            inverse_cdf = simple_inverse(cdf, prec = bin_width*0.125)
+
+        prec_missing = 0.5 * (1.0 - precision)
+
+        start = inverse_cdf(prec_missing)
+        end = inverse_cdf(1.0 - prec_missing)
+
+        half_bin_width = 0.5*bin_width
+
+        bw_inverse = 1.0 / bin_width
+
+        def bw_round(x):
+            return math.floor(x*bw_inverse + 0.5) / bw_inverse
+
+        start = bw_round(start)
+        end = bw_round(end)
+
+        last_bin_start = start - half_bin_width
+        last_cdf = cdf(last_bin_start)
+        
+        probs = [0.0]
+        masses = [last_bin_start - half_bin_width]
+
+        while last_bin_start < end:
+            next_bin_start = last_bin_start + bin_width
+            next_cdf = cdf(next_bin_start)
+
+            masses.append(last_bin_start + half_bin_width)
+            probs.append(next_cdf - last_cdf)
+
+            last_cdf = next_cdf
+            last_bin_start = next_bin_start
+
+        sprobs = 1.0/sum(probs)
+        probs = [p*sprobs for p in probs]
+
+        probs.append(0.0)
+        masses.append(last_bin_start + half_bin_width)
+
+        super(Distribution, self).__init__(masses = masses, probs = probs)
+
+        self.mass_sorted = True
+
+
+
+class Gaussian(Distribution):
+    def __init__(self, stdev, bin_width = 0.01, precision = 0.99):
+        varfactor = 1.0/(stdev * 1.4142135623730951)
+        cdf = lambda x: 0.5*(1.0+math.erf(x*varfactor))
+        inv_cdf = None
+        try:
+            # If scipy is available, use its ppf
+            from scipy.stats import norm
+            inv_cdf = lambda x: norm.ppf(x, loc = 0.0, scale = stdev)
+        except ImportError:
+            pass # oh well, no scipy, we'll just use binsearch-based inversion
+
+        super(Gaussian, self).__init__(cdf = cdf, bin_width = bin_width, precision = precision, inverse_cdf = inv_cdf)
+
+

IsoSpecPy/Formulas.py

@@ -0,0 +1,71 @@
+from .IsoSpecPy import Iso
+from collections import Counter
+
+
+
+loratadine = "C22H23N2O2Cl1"
+desloratadine = "C19H19N2Cl1"
+titin = "C169719H270466N45688O52238S911"
+bovine_insulin = "C254H377N65O75S6"
+ubiquitin = "C378H629N105O118S1"
+substance_p = "C63H98N18O13S1"
+protein_p16 = "C681H1100N216O208S5"
+cholesterol = "C27H46O1"
+caffeine = "C8H10N4O2"
+water = "H2O1"
+glucose = "C6H12O6"
+sucrose = "C12H22O11"
+horse_myoglobin = "C769H1212N210O218S2"
+oxygen = "O2"
+
+
+
+
+
+averagine_unit = Counter({
+'C' : 4.9384,
+'H' : 7.7583,
+'N' : 1.3577,
+'O' : 1.4773,
+'S' : 0.0417})
+
+averagine_mass = 111.1254
+
+def fillHs(d, target_avg_mass):
+    while True:
+        i = Iso(formula = d)
+        if i.getTheoreticalAverageMass() > target_avg_mass:
+            break
+        d['H'] += 1
+
+def averagine_dct(target_avg_mass):
+    units = float(target_avg_mass) / averagine_mass
+    d = dict((key, int(units*val)) for key, val in averagine_unit.items())
+    fillHs(d, target_avg_mass)
+    for x in list(d.keys()):
+        if d[x] == 0:
+            del d[x]
+    return d
+
+def averagine(target_avg_mass):
+    return ''.join(str(key)+str(val) for key, val in sorted(averagine_dct(target_avg_mass).items(), key= lambda x: x[0]))
+
+
+acgt_avg_base = Counter({
+'C' : 9.75,
+'H' : 12.25,
+'N' : 3.75,
+'O' : 6.0,
+'P' : 1.0
+})
+
+def acgt_dct(no_bases, add_water = True):
+    c = {key : int(val*no_bases+0.5) for key, val in acgt_avg_base.items()}
+    if add_water:
+        c['H'] += 2
+        c['O'] += 1
+    return c
+
+def acgt(no_bases, add_water = True):
+    c = acgt_dct(no_bases, add_water = add_water)
+    return ''.join(str(key)+str(val) for key, val in sorted(c.items(), key= lambda x: x[0]))