295 lines
7.7 KiB
Python
295 lines
7.7 KiB
Python
import math
|
||
import numpy as np
|
||
|
||
#C=CC=C Butadien
|
||
CBUTADIEN = {
|
||
1: ([122.26], [2]),
|
||
2: ([145.21], [2]),
|
||
}
|
||
|
||
#C=C Ethylen
|
||
CP0 = {
|
||
1: ([128.33], [2]),
|
||
}
|
||
|
||
#C=C/C=C/C=C Hexatrien
|
||
CP1 = {
|
||
1: ([122.47], [2]),
|
||
2: ([144.32], [2]),
|
||
3: ([140.50], [2]),
|
||
}
|
||
|
||
#C1CCC(C=C)CC=1
|
||
CP2 = {
|
||
1: ([135.43], [1]),
|
||
2: ([31.80], [1]),
|
||
3: ([29.20], [1]),
|
||
4: ([42.60], [1]),
|
||
5: ([152.20], [1]),
|
||
6: ([114.57], [1]),
|
||
7: ([38.56], [1]),
|
||
8: ([134.81], [1]),
|
||
}
|
||
|
||
#C(CCC(C=C)CC=C)=C
|
||
CP3 = {
|
||
1: ([147.47], [1]),
|
||
2: ([37.13], [1]),
|
||
3: ([33.61], [1]),
|
||
4: ([52.35], [1]),
|
||
5: ([151.07], [1]),
|
||
6: ([119.60], [1]),
|
||
7: ([49.64], [1]),
|
||
8: ([143.68], [1]),
|
||
9: ([121.81], [1]),
|
||
10: ([115.67], [1]),
|
||
}
|
||
|
||
#C=CC=CC=CC=C Octatetraen
|
||
CP4 = {
|
||
1: ([122.10], [2]),
|
||
2: ([144.40], [2]),
|
||
3: ([140.76], [2]),
|
||
4: ([139.87], [2]),
|
||
}
|
||
|
||
#C1CCC(C=CC=C)CC=1
|
||
CP5 = {
|
||
1: ([135.39], [1]),
|
||
2: ([31.78], [1]),
|
||
3: ([30.01], [1]),
|
||
4: ([42.13], [1]),
|
||
5: ([147.99], [1]),
|
||
6: ([133.91], [1]),
|
||
7: ([144.86], [1]),
|
||
8: ([118.59], [1]),
|
||
9: ([38.62], [1]),
|
||
10: ([134.73], [1]),
|
||
}
|
||
|
||
#C=CC1C=CCCC1
|
||
CP6 = {
|
||
1: ([117.64], [1]),
|
||
2: ([152.55], [1]),
|
||
3: ([50.21], [1]),
|
||
4: ([138.81], [1]),
|
||
5: ([135.87], [1]),
|
||
6: ([31.05], [1]),
|
||
7: ([27.64], [1]),
|
||
8: ([35.53], [1]),
|
||
}
|
||
|
||
#C1CCCCC=1
|
||
CP7 = {
|
||
1: ([135.79], [2]),
|
||
2: ([31.39], [2]),
|
||
3: ([28.19], [2]),
|
||
}
|
||
|
||
#C=CC1CC=CCC1C=C
|
||
CP8 = {
|
||
1: ([119.30], [2]),
|
||
2: ([151.13], [2]),
|
||
3: ([46.76], [2]),
|
||
4: ([39.99], [2]),
|
||
5: ([134.37], [2]),
|
||
}
|
||
|
||
#C1CCC(C=C)C(C=C)C=1
|
||
CP9 = {
|
||
1: ([135.24], [1]),
|
||
2: ([31.15], [1]),
|
||
3: ([34.06], [1]),
|
||
4: ([52.33], [1]),
|
||
5: ([151.22], [1]),
|
||
6: ([118.67], [1]),
|
||
7: ([54.94], [1]),
|
||
8: ([150.28], [1]),
|
||
9: ([119.75], [1]),
|
||
10: ([138.06], [1]),
|
||
}
|
||
|
||
#C(C1CC(C=C)C=CC1)=C
|
||
CP10 = {
|
||
1: ([152.90], [1]),
|
||
2: ([47.12], [1]),
|
||
3: ([36.63], [1]),
|
||
4: ([46.21], [1]),
|
||
5: ([150.05], [1]),
|
||
6: ([115.14], [1]),
|
||
7: ([137.57], [1]),
|
||
8: ([132.93], [1]),
|
||
9: ([38.14], [1]),
|
||
10: ([117.15], [1]),
|
||
}
|
||
|
||
#C1C=CC=CC=1 Benzol
|
||
CP11 = {
|
||
1: ([132.96], [6])
|
||
}
|
||
|
||
#C(CCC1C=CC=CC1)=C
|
||
CP12 = {
|
||
1: ([148.24], [1]),
|
||
2: ([39.58], [1]),
|
||
3: ([40.28], [1]),
|
||
4: ([39.83], [1]),
|
||
5: ([138.15], [1]),
|
||
6: ([131.12], [1]),
|
||
7: ([131.68], [1]),
|
||
8: ([133.29], [1]),
|
||
9: ([35.91], [1]),
|
||
10: ([118.42], [1]),
|
||
}
|
||
|
||
#C1C(C=CC=C)CCCC=1
|
||
CP13 = {
|
||
1: ([137.84], [1]),
|
||
2: ([45.55], [1]),
|
||
3: ([147.44], [1]),
|
||
4: ([135.54], [1]),
|
||
5: ([144.68], [1]),
|
||
6: ([118.72], [1]),
|
||
7: ([36.87], [1]),
|
||
8: ([28.62], [1]),
|
||
9: ([31.29], [1]),
|
||
10: ([137.16], [1]),
|
||
}
|
||
|
||
#C=CC(C=C)CCCC=C
|
||
CP14 = {
|
||
1: ([118.15], [2]),
|
||
2: ([149.96], [2]),
|
||
3: ([51.02], [1]),
|
||
4: ([29.41], [1]),
|
||
5: ([32.52], [1]),
|
||
6: ([36.00], [1]),
|
||
7: ([146.13], [1]),
|
||
8: ([119.77], [1]),
|
||
}
|
||
|
||
#C=CCCCCC=C
|
||
CP15 = {
|
||
1: ([118.87], [2]),
|
||
2: ([147.62], [2]),
|
||
3: ([42.24], [2]),
|
||
4: ([36.95], [2]),
|
||
}
|
||
|
||
#C=CC1C=CC(C=C)CC1
|
||
CP16 = {
|
||
1: ([116.08], [2]),
|
||
2: ([150.56], [2]),
|
||
3: ([44.33], [2]),
|
||
4: ([140.69], [2]),
|
||
5: ([26.35], [2]),
|
||
}
|
||
|
||
#C1CC2CCCCC2CC=1
|
||
CP17 = {
|
||
1: ([135.03], [2]),
|
||
2: ([37.74], [2]),
|
||
3: ([34.32], [2]),
|
||
4: ([30.76], [2]),
|
||
5: ([24.84], [2]),
|
||
}
|
||
|
||
#C1CC2C=CC=CC2CC=1
|
||
CP18 = {
|
||
1: ([139.14], [2]),
|
||
2: ([36.29], [2]),
|
||
3: ([40.97], [2]),
|
||
4: ([137.28], [2]),
|
||
5: ([127.67], [2]),
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
def overlap(listref, listnew):
|
||
twoleft = np.sum(np.multiply(np.concatenate((listref, [0, 0])), np.concatenate(([0, 0], listnew))))
|
||
oneleft = np.sum(np.multiply(np.concatenate((listref, [0])), np.concatenate(([0], listnew))))
|
||
neutral = np.sum(np.multiply(listref,listnew))
|
||
oneright = np.sum(np.multiply(np.concatenate(([0], listref)), np.concatenate((listnew, [0]))))
|
||
tworight = np.sum(np.multiply(np.concatenate(([0, 0], listref)), np.concatenate((listnew, [0, 0]))))
|
||
overlap = (oneleft + oneright)* 0.5 + neutral
|
||
return overlap
|
||
|
||
def bin_array(spectra, highest_ppm, lowest_ppm, bin_width):
|
||
binnumber = math.ceil((highest_ppm - lowest_ppm)/bin_width)
|
||
bin = [0] * binnumber
|
||
for peak in spectra:
|
||
(shift, height) = spectra[peak]
|
||
binindex = math.floor((shift[0] - lowest_ppm) / bin_width)
|
||
bin[binindex] += height[0]
|
||
normalizedbin = np.divide(bin, np.sum(bin))
|
||
return normalizedbin
|
||
|
||
def define_border_values(spectraref, spectranew, bin_width):
|
||
shifts = []
|
||
for _,(shift,_) in spectraref.items():
|
||
shifts.append(shift[0])
|
||
for _,(shift,_) in spectranew.items():
|
||
shifts.append(shift[0])
|
||
highest_ppm = math.ceil(max(shifts)) + bin_width
|
||
lowest_ppm = math.floor(min(shifts)) - bin_width
|
||
#lowest_ppm = min(shifts) - bin_width/2 #Worse result. None of the previously wrong (except 0.6) become right
|
||
return (lowest_ppm, highest_ppm)
|
||
|
||
def similarity_nmr(spectraref, spectranew, bin_width):
|
||
#Maximize likelihood or minimize Deviation
|
||
#Values for two spectra and optimize largest for both different?
|
||
#Spectra in Nodes to allow maximize overlapp with both spectra or one spectra.
|
||
#5.4.2 Eliminating X–H signals from 1H NMR spectra
|
||
lowest_ppm, highest_ppm = define_border_values(spectraref, spectranew, bin_width)
|
||
binref = bin_array(spectraref, highest_ppm, lowest_ppm, bin_width)
|
||
binnew = bin_array(spectranew, highest_ppm, lowest_ppm, bin_width)
|
||
crosscorr = overlap(binref, binnew)
|
||
refselfcorr = overlap(binref, binref)
|
||
newselfcorr = overlap(binnew, binnew)
|
||
simidx = crosscorr / math.sqrt(refselfcorr * newselfcorr)
|
||
return(simidx)
|
||
|
||
def correction(spectra, corretionppm):
|
||
newspectra = {}
|
||
for id, (shift, height) in spectra.items():
|
||
shiftvalue = shift[0]
|
||
adjustedshift = shiftvalue + corretionppm
|
||
newspectra[id] = ([adjustedshift], height)
|
||
return newspectra
|
||
|
||
def addspectra(spectrum1, spectrum2):
|
||
spectrum = spectrum1.copy()
|
||
for _, ([ppm2], [height2]) in spectrum2.items():
|
||
for peak, ([ppm1], [height1]) in spectrum1.items():
|
||
if ppm1 == ppm2:
|
||
spectrum[peak] == ([ppm1], [height1 + height2])
|
||
continue
|
||
spectrum[len(spectrum) + 1] = ([ppm2], [height2])
|
||
return(spectrum)
|
||
|
||
|
||
def main():
|
||
normalize = False
|
||
spectrumrefs = [addspectra(CP0, CP1), addspectra(CP0, CP4), addspectra(CP0, CP11)]
|
||
spectra = [CBUTADIEN, CP0, CP1, CP2, CP3, CP4, CP5, CP6, CP7, CP8, CP9, CP10, CP11, CP12, CP13, CP14, CP15, CP16, CP17, CP18]
|
||
spectranames = ['C=CC=C or Butadien', 'C=C or Ethyen or CP0', 'C=CC=CC=C or Hexatrien or CP1', 'C1CCC(C=C)CC=1 or CP2', 'C(CCC(C=C)CC=C)=C or CP3', 'C=CC=CC=CC=C or Octatetraen or CP4', 'C1CCC(C=CC=C)CC=1 or CP5', 'C=CC1C=CCCC1 or CP6', 'C1CCCCC=1 or Cyclohexen or CP7', 'C=CC1CC=CCC1C=C or CP8', 'C1CCC(C=C)C(C=C)C=1 or CP9', 'C(C1CC(C=C)C=CC1)=C or CP10', 'C1C=CC=CC=1 or CP11', 'C(CCC1C=CC=CC1)=C or CP12', 'C1C(C=CC=C)CCCC=1 or CP13', 'C=CC(C=C)CCCC=C or CP14', 'C=CCCCCC=C or CP15', 'C=CC1C=CC(C=C)CC1 or CP16', 'C1CC2CCCCC2CC=1 or CP17', 'C1CC2C=CC=CC2CC=1 or CP18']
|
||
for spectrumref in spectrumrefs:
|
||
likelihoods = []
|
||
for spectrumtrue in spectra:
|
||
similaritylist = []
|
||
binwidthlist = np.arange(0.1, 1.1, 0.1)
|
||
for i in binwidthlist:
|
||
similaritylist.append(similarity_nmr(spectrumtrue, spectrumref, i))
|
||
similaritymean = sum(similaritylist) / len(similaritylist)
|
||
likelihoods.append(similaritymean)
|
||
if normalize:
|
||
normalizedlikelihood = [round(likelihood/np.sum(likelihoods), 2) for likelihood in likelihoods]
|
||
print(normalizedlikelihood)
|
||
if not normalize:
|
||
notnormalizedlikelihood = [round(likelihood, 2) for likelihood in likelihoods]
|
||
print(notnormalizedlikelihood)
|
||
if __name__ == "__main__":
|
||
main() |