TDCRPy 2.1.0__tar.gz → 2.4.0__tar.gz

{tdcrpy-2.1.0/TDCRPy.egg-info → tdcrpy-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: TDCRPy
-Version: 2.1.0
+Version: 2.4.0
 Summary: TDCR model
 Home-page: https://pypi.org/project/TDCRPy/
 Author: RomainCoulon (Romain Coulon)
@@ -27,6 +27,18 @@ Requires-Dist: scipy
 Requires-Dist: configparser
 Requires-Dist: importlib.resources
 Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # 1. About TDCRPy
 

{tdcrpy-2.1.0 → tdcrpy-2.4.0/TDCRPy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: TDCRPy
-Version: 2.1.0
+Version: 2.4.0
 Summary: TDCR model
 Home-page: https://pypi.org/project/TDCRPy/
 Author: RomainCoulon (Romain Coulon)
@@ -27,6 +27,18 @@ Requires-Dist: scipy
 Requires-Dist: configparser
 Requires-Dist: importlib.resources
 Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # 1. About TDCRPy
 

{tdcrpy-2.1.0 → tdcrpy-2.4.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import codecs
 import os
 
-VERSION = "2.1.0"
+VERSION = "2.4.0"
 
 DESCRIPTION = "TDCR model"
 

{tdcrpy-2.1.0 → tdcrpy-2.4.0}/tdcrpy/TDCRPy.py

@@ -84,7 +84,7 @@ def relaxAtom(daughter_relax,particle_vec,energy_vec,rad,Display=False,uncData=F
                 relaxation = False
     return particle_vec, energy_vec
 
-def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smodel=True, record = False, readRecHist = False, uncData=False):
+def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smodel=True, record = False, readRecHist = False, uncData = False, fullMC = False):
     """
     This is the main function of the TDCRPy package.
     The computation is made for a given solution containing a radionuclide (or a mixture of radionuclides), a given volume of scintillator V and a given Birks constant kB. 
@@ -254,7 +254,10 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                     if decay != decaym:
                         if decay>0:
                             # print(decay-1,e_quenching,e_quenching2, evenement)
-                            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
+                            if fullMC:
+                                efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
+                            else:
+                                efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
                             efficiency_S.append(efficiency0_S)
                             efficiency_T.append(efficiency0_T)
                             efficiency_D.append(efficiency0_D)
@@ -281,8 +284,11 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                             e_quenching2.append(energy)
                         else:
                             e_quenching.append(energy)
-                            
-            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
+            
+            if fullMC:
+                efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
+            else:
+                efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
             efficiency_S.append(efficiency0_S)
             efficiency_T.append(efficiency0_T)
             efficiency_D.append(efficiency0_D)
@@ -691,7 +697,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                         
                         if p == "electron" or ("Auger" in p): col1 = "1"
                         elif p == "gamma" or ("X" in p): col1 = "2"
-                        elif p == "beta+": col1 = "3"
+                        elif p == "positron": col1 = "3"
                         elif p == "alpha": col1 = "4"
                         else: writeOn = False
 
@@ -709,7 +715,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                             
                             if p == "electron" or ("Auger" in p): col1 = "1"
                             elif p == "gamma" or ("X" in p): col1 = "2"
-                            elif p == "beta+": col1 = "3"
+                            elif p == "positron": col1 = "3"
                             elif p == "alpha": col1 = "4"
                             else: writeOn = False
     
@@ -825,7 +831,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                         
                         if p == "electron" or ("Auger" in p): col1 = "1"
                         elif p == "gamma" or ("X" in p): col1 = "2"
-                        elif p == "beta+": col1 = "3"
+                        elif p == "positron": col1 = "3"
                         elif p == "alpha": col1 = "4"
                         else: writeOn = False
 
@@ -843,7 +849,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                             
                             if p == "electron" or ("Auger" in p): col1 = "1"
                             elif p == "gamma" or ("X" in p): col1 = "2"
-                            elif p == "beta+": col1 = "3"
+                            elif p == "positron": col1 = "3"
                             elif p == "alpha": col1 = "4"
                             else: writeOn = False
     
@@ -911,7 +917,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                         
                         if p == "electron" or ("Auger" in p): col1 = "1"
                         elif p == "gamma" or ("X" in p): col1 = "2"
-                        elif p == "beta+": col1 = "3"
+                        elif p == "positron": col1 = "3"
                         elif p == "alpha": col1 = "4"
                         else: writeOn = False
 
@@ -929,7 +935,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                             
                             if p == "electron" or ("Auger" in p): col1 = "1"
                             elif p == "gamma" or ("X" in p): col1 = "2"
-                            elif p == "beta+": col1 = "3"
+                            elif p == "positron": col1 = "3"
                             elif p == "alpha": col1 = "4"
                             else: writeOn = False
     
@@ -949,7 +955,10 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
             ====================
             '''
             if evenement == 1: e_quenching2 = 0; t1=0
-            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
+            if fullMC:
+                efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
+            else:
+                efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
             efficiency_S.append(efficiency0_S)
             efficiency_T.append(efficiency0_T)
             efficiency_D.append(efficiency0_D)
@@ -1137,7 +1146,7 @@ def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False):
     Parameters
     ----------
     TD : float or tuple
-        measurements. If TD is float, then TD is the measured TDCR parameter. If TD is tuple, then TD must contain the global TDCR parameter followed by specific ones (T/B, T/AB, T/BC, T/AC)
+        measurements. If TD is float, then TD is the measured TDCR parameter. If TD is tuple, then TD must contain the global TDCR parameter followed by specific ones (T/D, T/AB, T/BC, T/AC)
     Rad : string
         List of radionuclides (eg. "H-3, Co-60").
     pmf_1 : string
@@ -1226,18 +1235,74 @@ def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False):
 
 
 
+# mode = "eff"                # ask for efficiency calculation
+# Rad="Na-22"                 # radionuclides
+# pmf_1="1"                   # relatives fractions of the radionulides
+# N = 1000                    # number of Monte Carlo trials
+# kB =1.0e-5                  # Birks constant in cm keV-1
+# V = 10                      # volume of scintillator in mL
+# L=np.logspace(-3,2,num=100) # free parameter in keV-1
+
+# # TDCRPy(1, Rad, pmf_1, 10, kB, V, mode, Display= True, barp=False, record=True)
+# # Record decay histories in temporary files
+# TDCRPy(L[0], Rad, pmf_1, N, kB, V, mode, barp=False, record=True)
+
+# effS, u_effS, effD, u_effD, effT, u_effT, effD2, u_effD2 = [], [],[], [],[], [], [], []
+# for l in tqdm(L, desc="free parameters ", unit=" iterations"):
+#   out = TDCRPy(l, Rad, pmf_1, N, kB, V, mode, readRecHist=True)
+#   effS.append(out[2])
+#   u_effS.append(out[3])
+#   effD.append(out[2])
+#   u_effD.append(out[3])
+#   effT.append(out[4])
+#   u_effT.append(out[5])
+#   effD2.append(out[12])
+#   u_effD2.append(out[13])
+
+# effS=np.asarray(effS)
+# effT=np.asarray(effT)
+# effD=np.asarray(effD)
+# effD2=np.asarray(effD2)
+# u_effS=np.asarray(u_effS)
+# u_effT=np.asarray(u_effT)
+# u_effD=np.asarray(u_effD)
+# u_effD2=np.asarray(u_effD2)
+
+# tdcr=effT/effD
+# u_tdcr=np.sqrt(u_effD**2*effT**2/effD**4+u_effT**2/effD**2)
+
+# import matplotlib.pyplot as plt
+# plt.figure("efficiency vs free parameter")
+# plt.clf()
+# plt.errorbar(L,effD,yerr=u_effD,fmt="-k",label="double coincidences")
+# plt.errorbar(L,effT,yerr=u_effT,fmt="-r",label="triple coincidences")
+# plt.errorbar(L,effD2,yerr=u_effD2,fmt="-g",label="double coincidences (CIEMAT/NIST)")
+# plt.xscale('log')
+# plt.xlabel(r'$L$ /keV$^{-1}$', fontsize=14)
+# plt.ylabel(r'$\epsilon$', fontsize=14)
+# plt.legend()
+
+# plt.figure("efficiency vs TDCR")
+# plt.clf()
+# plt.errorbar(tdcr,effD,xerr=u_tdcr,yerr=u_effD,fmt="-k")
+# #plt.xscale('log')
+# plt.xlabel(r'$R_T/R_D$', fontsize=14)
+# plt.ylabel(r'$\epsilon_{D}$', fontsize=14)
+# plt.show()
 
 
 # L = 1
 # # L = (1.1, 1.05, 1.15)
-# TD = 0.977667386529166
-# # TD = (0.977667386529166, 0.992232838598821, 0.992343419459002, 0.99275350064608)
-# # # TD = (0.977667386529166, 0.995232838598821, 0.990343419459002, 0.99275350064608)
-# Rad="Co-60"
+# # TD = 0.977667386529166
+# # TD = (0.9767359812638453, 0.9925429293804757, 0.991829757077315, 0.9919970813639295) # source 1
+# # TD = (0.9768862920127371, 0.9928478299182348, 0.9912531441227223, 0.9924249578285456) # source 2
+# # TD = (0.9769014488454436, 0.9918130431206161, 0.9920156754198314, 0.9927119011073454) # source 3
+# TD = (0.9764032345164899, 0.9928417189012709, 0.9911455450383777, 0.9920402844839974) # source 4
+# Rad="Tc-99"
 # pmf_1="1"
-# N = 1000
-# kB =1.0e-5
-# V = 10
+# N = 10000
+# kB =1.4e-5
+# V = 16
 # mode = "eff"
 
 
@@ -1246,6 +1311,7 @@ def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False):
 # # # out = TDCRPy(L, Rad, pmf_1, N, kB, V, Display = False, record = False, readRecHist = True)
 # # # print("result", out)
 
-# # out = eff(TD, Rad, pmf_1, kB, V, N=1000, L=1, maxiter=20, xatol=1e-7)
-# out = effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7)
-# print(out)
+# outS = eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7)
+# outA = effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7)
+# print(outS)
+# print(outA)

{tdcrpy-2.1.0 → tdcrpy-2.4.0}/tdcrpy/TDCR_model_lib.py

@@ -2894,6 +2894,7 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
         symm = False
     else:
         symm = True
+         
         
     if symm:
         # print(evenement !=1, t1 > extDT*1e-6, t1 < measTime*60)
@@ -2935,8 +2936,6 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
             efficiency0_A2 = p_single
             efficiency0_B2 = efficiency0_A2
             efficiency0_D2 = p_single**2
-        
-                            
     else:
         if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
             # TDCR            
@@ -3005,6 +3004,164 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
     return efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2        
 
 
+def detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime):
+    """
+    Calculate detection probabilities for LS counting systems - see Broda, R., Cassette, P., Kossert, K., 2007. Radionuclide metrology using liquid scintillation counting. Metrologia 44. https://doi.org/10.1088/0026-1394/44/4/S06 
+
+    Parameters
+    ----------
+    L : float or tuple
+        If L is float, then L is the global free parameter. If L is tuple, then L is a triplet of free parameters. unit keV-1
+    e_quenching : list
+        List of quenched deposited energies from prompt particles in keV.
+    e_quenching2 : list
+        List of quenched deposited energies from delayed particles in keV.
+    t1 : float
+        decay time of the delayed transitions in s.
+    evenement : interger
+        number of pulses per decay (prompt (1), prompt + delayed (2)).
+    extDT : float
+        extended dead time of the system in ns.
+    measTime : float
+        measurement time in minutes.
+
+    Returns
+    -------
+    efficiency0_S : float
+        detection probability of single event.
+    efficiency0_D : float
+        detection probability of double coincidences.
+    efficiency0_T : float
+        detection probability of triple coincidences.
+    efficiency0_AB : float
+        detection probability of coincidences between channels A and B.
+    efficiency0_BC : float
+        detection probability of coincidences between channels B and C.
+    efficiency0_AC : float
+        detection probability of coincidences between channels A and C.
+    efficiency0_D2 : float
+        detection probability of coincidences in a C/N system.
+
+    """
+    if isinstance(L, (tuple, list)):
+        symm = False
+    else:
+        symm = True
+    
+    if symm:
+        if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+            m = len(e_quenching)
+            n_ph = np.random.poisson(np.asarray((e_quenching+e_quenching2)*L))
+            n_S = 0; n_D = 0; n_T = 0; n_AB = 0;  n_BC = 0;  n_AC = 0; n_D2 = 0; n_A2 = 0; n_B2 = 0;
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [1/3, 1/3, 1/3])
+                if sum(n_phPMT>1)>0: n_S +=1
+                if sum(n_phPMT>1)>1: n_D +=1
+                if sum(n_phPMT>1)>2: n_T +=1
+                if n_phPMT[0]>1 and n_phPMT[1]>1: n_AB +=1 
+                if n_phPMT[1]>1 and n_phPMT[2]>1: n_BC +=1 
+                if n_phPMT[0]>1 and n_phPMT[2]>1: n_AC +=1 
+            efficiency0_S = n_S/m
+            efficiency0_T = n_T/m
+            efficiency0_D = n_D/m
+            efficiency0_AB = n_AB/m
+            efficiency0_BC = n_BC/m
+            efficiency0_AC = n_AC/m
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [1/2, 1/2])
+                if sum(n_phPMT>1)>1: n_D2 +=1
+                if n_phPMT[0]>1: n_A2 +=1 
+                if n_phPMT[1]>1: n_B2 +=1
+            # efficiency0_A2 = n_A2/m
+            # efficiency0_B2 = n_B2/m     
+            efficiency0_D2 = n_D2/m  
+        else: # symm and no deleayed event sum
+            m = len(e_quenching)
+            n_ph = np.random.poisson(np.asarray(e_quenching*L))
+            n_S = 0; n_D = 0; n_T = 0; n_AB = 0;  n_BC = 0;  n_AC = 0; n_D2 = 0; n_A2 = 0; n_B2 = 0;
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [1/3, 1/3, 1/3])
+                if sum(n_phPMT>1)>0: n_S +=1
+                if sum(n_phPMT>1)>1: n_D +=1
+                if sum(n_phPMT>1)>2: n_T +=1
+                if n_phPMT[0]>1 and n_phPMT[1]>1: n_AB +=1 
+                if n_phPMT[1]>1 and n_phPMT[2]>1: n_BC +=1 
+                if n_phPMT[0]>1 and n_phPMT[2]>1: n_AC +=1 
+            efficiency0_S = n_S/m
+            efficiency0_T = n_T/m
+            efficiency0_D = n_D/m
+            efficiency0_AB = n_AB/m
+            efficiency0_BC = n_BC/m
+            efficiency0_AC = n_AC/m
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [1/2, 1/2])
+                if sum(n_phPMT>1)>1: n_D2 +=1
+                if n_phPMT[0]>1: n_A2 +=1 
+                if n_phPMT[1]>1: n_B2 +=1 
+            # efficiency0_A2 = n_A2/m
+            # efficiency0_B2 = n_B2/m     
+            efficiency0_D2 = n_D2/m  
+    else: # asym
+        if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60: # sum of delayed event
+            m = len(e_quenching)
+            Lm = np.mean(L)
+            n_ph = np.random.poisson(np.asarray(e_quenching+e_quenching2)*Lm)
+            n_S = 0; n_D = 0; n_T = 0; n_AB = 0;  n_BC = 0;  n_AC = 0; n_D2 = 0; n_A2 = 0; n_B2 = 0;
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [L[0]/(3*Lm), L[1]/(3*Lm), L[2]/(3*Lm)])
+                if sum(n_phPMT>1)>0: n_S +=1
+                if sum(n_phPMT>1)>1: n_D +=1
+                if sum(n_phPMT>1)>2: n_T +=1
+                if n_phPMT[0]>1 and n_phPMT[1]>1: n_AB +=1 
+                if n_phPMT[1]>1 and n_phPMT[2]>1: n_BC +=1 
+                if n_phPMT[0]>1 and n_phPMT[2]>1: n_AC +=1 
+            efficiency0_S = n_S/m
+            efficiency0_T = n_T/m
+            efficiency0_D = n_D/m
+            efficiency0_AB = n_AB/m
+            efficiency0_BC = n_BC/m
+            efficiency0_AC = n_AC/m
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [L[0]/(2*Lm), L[1]/(2*Lm)])
+                if sum(n_phPMT>1)>1: n_D2 +=1
+                if n_phPMT[0]>1: n_A2 +=1 
+                if n_phPMT[1]>1: n_B2 +=1 
+            # efficiency0_A2 = n_A2/m
+            # efficiency0_B2 = n_B2/m     
+            efficiency0_D2 = n_D2/m  
+        else: # asym and no sum of delayed events
+            m = len(e_quenching)
+            Lm = np.mean(L)
+            n_ph = np.random.poisson(np.asarray((e_quenching+e_quenching2)*Lm))
+            n_S = 0; n_D = 0; n_T = 0; n_AB = 0;  n_BC = 0;  n_AC = 0; n_D2 = 0; n_A2 = 0; n_B2 = 0;
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [L[0]/(3*Lm), L[1]/(3*Lm), L[2]/(3*Lm)])
+                if sum(n_phPMT>1)>0: n_S +=1
+                if sum(n_phPMT>1)>1: n_D +=1
+                if sum(n_phPMT>1)>2: n_T +=1
+                if n_phPMT[0]>1 and n_phPMT[1]>1: n_AB +=1 
+                if n_phPMT[1]>1 and n_phPMT[2]>1: n_BC +=1 
+                if n_phPMT[0]>1 and n_phPMT[2]>1: n_AC +=1 
+            efficiency0_S = n_S/m
+            efficiency0_T = n_T/m
+            efficiency0_D = n_D/m
+            efficiency0_AB = n_AB/m
+            efficiency0_BC = n_BC/m
+            efficiency0_AC = n_AC/m
+            for j in n_ph:
+                n_phPMT = np.random.multinomial(j, [L[0]/(2*Lm), L[1]/(2*Lm)])
+                if sum(n_phPMT>1)>1: n_D2 +=1
+                if n_phPMT[0]>1: n_A2 +=1 
+                if n_phPMT[1]>1: n_B2 +=1 
+            # efficiency0_A2 = n_A2/m
+            # efficiency0_B2 = n_B2/m     
+            efficiency0_D2 = n_D2/m
+    return efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2        
+
+
+
+
+
 def efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_AB, efficiency_BC, efficiency_AC, efficiency_D2, N):
     """
     Calculate detection efficiencies from list of detection probabilities per decays.