TDCRPy 1.11.2__py3-none-any.whl → 2.15.8__py3-none-any.whl

tdcrpy/TDCR_model_lib.py

@@ -11,7 +11,6 @@ Bureau International des Poids et Mesures
 """
 ======= Import Python Module =======
 """
-
 import importlib.resources
 from importlib.resources import files
 import pkg_resources
@@ -23,42 +22,94 @@ import os
 import scipy.interpolate as  interp
 import matplotlib.pyplot as plt
 from tqdm import tqdm
+import tempfile
+import math
 
 """
 ======= Import ressource data =======
 """
 
 # import advanced configuration data
-
 config = configparser.ConfigParser()
-with importlib.resources.as_file(files('tdcrpy').joinpath('config.toml')) as data_path:
-    file_conf = data_path       
-config.read(file_conf)
-
-nE_electron = config["Inputs"].getint("nE_electron")
-nE_alpha = config["Inputs"].getint("nE_alpha")
-tau = config["Inputs"].getint("tau")
-RHO = config["Inputs"].getfloat("density")
-Z = config["Inputs"].getfloat("Z")
-A = config["Inputs"].getfloat("A")
-depthSpline = config["Inputs"].getint("depthSpline")
-Einterp_a = config["Inputs"].getfloat("Einterp_a")
-Einterp_e = config["Inputs"].getfloat("Einterp_e")
-diam_micelle = config["Inputs"].getfloat("diam_micelle")
-fAq = config["Inputs"].getfloat("fAq")
-
-def readParameters():
-    print(f"number of integration bins for electrons = {nE_electron}")
-    print(f"number of integration bins for alpha = {nE_alpha}")
-    print(f"density = {RHO} g/cm3")
-    print(f"Z = {Z}")
-    print(f"A = {A}")
-    print(f"depth of spline interp. = {depthSpline}")
-    print(f"energy above which interp. in implemented (for alpha) = {Einterp_a} keV")
-    print(f"energy above which interp. in implemented (for electron) = {Einterp_e} keV")
-    print(f"diameter of micelle = {diam_micelle} nm")
-    print(f"acqueous fraction = {fAq}")
-    return nE_electron, nE_alpha, RHO, Z, A, depthSpline, Einterp_a, Einterp_e, diam_micelle, fAq, tau
+
+def readEffQ0():
+    global config, file_conf
+    config = configparser.ConfigParser()
+    with importlib.resources.as_file(files('tdcrpy').joinpath('config.toml')) as data_path:
+        file_conf = data_path       
+    config.read(file_conf)
+    
+    effQuantic0 = config["Inputs"].get("effQuantum")
+    return effQuantic0
+
+def readParameters(disp=False):
+    global config, file_conf
+    config = configparser.ConfigParser()
+    with importlib.resources.as_file(files('tdcrpy').joinpath('config.toml')) as data_path:
+        file_conf = data_path       
+    config.read(file_conf)
+
+    nE_electron = config["Inputs"].getint("nE_electron")
+    nE_alpha = config["Inputs"].getint("nE_alpha")
+    tau = config["Inputs"].getint("tau")
+    extDT = config["Inputs"].getint("extDT")
+    measTime = config["Inputs"].getint("measTime")
+    RHO = config["Inputs"].getfloat("density")
+    Z = config["Inputs"].getfloat("Z")
+    A = config["Inputs"].getfloat("A")
+    pH = config["Inputs"].getfloat("pH")
+    pC = config["Inputs"].getfloat("pC")
+    pN = config["Inputs"].getfloat("pN")
+    pO = config["Inputs"].getfloat("pO")
+    pP = config["Inputs"].getfloat("pP")
+    pCl = config["Inputs"].getfloat("pCl")
+    
+    depthSpline = config["Inputs"].getint("depthSpline")
+    Einterp_a = config["Inputs"].getfloat("Einterp_a")
+    Einterp_e = config["Inputs"].getfloat("Einterp_e")
+    diam_micelle = config["Inputs"].getfloat("diam_micelle")
+    fAq = config["Inputs"].getfloat("fAq")
+    micCorr = config["Inputs"].getboolean("micCorr")
+    # alphaDir = config["Inputs"].getfloat("alphaDir")
+    effQuantic0 = config["Inputs"].get("effQuantum")
+    effQuantic = effQuantic0.split(',')
+    for i, iS in enumerate(effQuantic):
+        iS=iS.replace(" ","")
+        if iS != 'None':  effQuantic[i]=float(iS)
+    optionModel = config["Inputs"].get("optionModel")
+    diffP = config["Inputs"].getfloat("diffP")
+    PMTspace = config["Inputs"].getfloat("PMTspace")
+    
+    if disp:
+        print(f"number of integration bins for electrons = {nE_electron}")
+        print(f"number of integration bins for alpha = {nE_alpha}")
+        print(f"density = {RHO} g/cm3")
+        print(f"Z = {Z}")
+        print(f"A = {A}")
+        print(f"Atomic fraction: [H] = {pH:.6f}, [C] = {pC:.6f}")
+        print(f"[N] = {pN:.6f}, [O] = {pO:.6f}")
+        print(f"[P] = {pP:.6f}, [Cl] = {pCl:.6f}")
+        print(f"depth of spline interp. = {depthSpline}")
+        print(f"energy above which interp. in implemented (for alpha) = {Einterp_a} keV")
+        print(f"energy above which interp. in implemented (for electron) = {Einterp_e} keV")
+        print(f"activation of the micelle correction = {micCorr}")
+        print(f"diameter of micelle = {diam_micelle} nm")
+        print(f"acqueous fraction = {fAq}")
+        # print(f"alpha parameter of the hidden Dirichlet process = {alphaDir}")
+        print(f"quantum efficiency of the photocathodes = {effQuantic}")
+        print(f"Monte Carlo model of the optics = {optionModel}")
+        print(f"fraction of diffused scintillation photons = {diffP*100:.1f} %")
+        print(f"relative distance from vials border to PMT entrance = {PMTspace*100:.1f} %")
+        print(f"coincidence resolving time = {tau} ns")
+        print(f"extended dead time = {extDT} µs")
+        print(f"measurement time = {measTime} min")
+    
+    return nE_electron, nE_alpha, RHO, Z, A, depthSpline, Einterp_a, Einterp_e, diam_micelle, fAq, tau, extDT, measTime, micCorr, effQuantic, optionModel, diffP, PMTspace, pH,pC,pN,pO,pP,pCl
+
+nE_electron, nE_alpha, RHO, Z, A, depthSpline, Einterp_a, Einterp_e, diam_micelle, fAq, tau, extDT, measTime, micCorr, effQuantic, optionModel, diffP, PMTspace, pH,pC,pN,pO,pP,pCl = readParameters()
+
+p_atom = np.array([pH,pC,pN,pO,pP,pCl]) # atom abondance in the scintillator
+p_atom /= sum(p_atom) 
 
 def readConfigAsstr():
     path2config = str(config.read(file_conf)[0])
@@ -69,14 +120,14 @@ def readConfigAsstr():
 def writeConfifAsstr(data):
     path2config = str(config.read(file_conf)[0])
     with open(path2config, 'w') as file:
-        file.write(data)    
+        file.write(data)
 
 def modifynE_electron(x):
     data0 = readConfigAsstr()
     x0 = readParameters()[0]
     data1 = data0.replace(f"nE_electron = {x0}",f"nE_electron = {x}")
     writeConfifAsstr(data1)
-
+   
 def modifynE_alpha(x):
     data0 = readConfigAsstr()
     x0 = readParameters()[1]
@@ -101,6 +152,17 @@ def modifyA(x):
     data1 = data0.replace(f"A = {x0}",f"A = {x}")
     writeConfifAsstr(data1)
 
+def modifyAtmConc(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[-6:]
+    data1 = data0.replace(f"pH = {x0[0]:.6f}",f"pH = {x[0]:.6f}")
+    data1 = data1.replace(f"pC = {x0[1]:.6f}",f"pC = {x[1]:.6f}")
+    data1 = data1.replace(f"pN = {x0[2]:.6f}",f"pN = {x[2]:.6f}")
+    data1 = data1.replace(f"pO = {x0[3]:.6f}",f"pO = {x[3]:.6f}")
+    data1 = data1.replace(f"pP = {x0[4]:.6f}",f"pP = {x[4]:.6f}") #
+    data1 = data1.replace(f"pCl = {x0[5]:.6f}",f"pCl = {x[5]:.6f}")
+    writeConfifAsstr(data1)
+
 def modifyDepthSpline(x):
     data0 = readConfigAsstr()
     x0 = readParameters()[5]
@@ -137,6 +199,165 @@ def modifyTau(x):
     data1 = data0.replace(f"tau = {x0}",f"tau = {x}")
     writeConfifAsstr(data1)
 
+def modifyDeadTime(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[11]
+    data1 = data0.replace(f"extDT = {x0}",f"extDT = {x}")
+    writeConfifAsstr(data1)
+
+def modifyMeasTime(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[12]
+    data1 = data0.replace(f"measTime = {x0}",f"measTime = {x}")
+    writeConfifAsstr(data1)
+
+def modifyMicCorr(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[13]
+    data1 = data0.replace(f"micCorr = {x0}",f"micCorr = {x}")
+    writeConfifAsstr(data1)
+    
+# def modifyAlphaDir(x):
+#     data0 = readConfigAsstr()
+#     x0 = readParameters()[14]
+#     data1 = data0.replace(f"alphaDir = {x0}",f"alphaDir = {x}")
+#     writeConfifAsstr(data1)
+    
+def modifyEffQ(x):
+    data0 = readConfigAsstr()
+    # x0 = readParameters()[14]
+    x0 = readEffQ0()
+    data1 = data0.replace(f"effQuantum = {x0}",f"effQuantum = {x}")
+    writeConfifAsstr(data1)
+
+def modifyOptModel(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[15]
+    data1 = data0.replace(f"optionModel = {x0}",f"optionModel = {x}")
+    writeConfifAsstr(data1)
+
+def modifyDiffP(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[16]
+    data1 = data0.replace(f"diffP = {x0:.1f}",f"diffP = {x:.1f}")
+    writeConfifAsstr(data1)
+
+def modifyPMTspace(x):
+    data0 = readConfigAsstr()
+    x0 = readParameters()[17]
+    data1 = data0.replace(f"PMTspace = {x0:.1f}",f"PMTspace = {x:.1f}")
+    writeConfifAsstr(data1)
+
+def read_temp_files(copy=False, path="C:"):
+    
+    temp_dir = tempfile.gettempdir()
+    file_path1 = os.path.join(temp_dir, 'Temp_E0.txt')
+    file_path2 = os.path.join(temp_dir, 'Temp_E1.txt')
+    file_path3 = os.path.join(temp_dir, 'Temp_E2.txt')
+    file_path4 = os.path.join(temp_dir, 'Temp_E3.txt')
+    with open(file_path1, 'r') as temp_file: content1 = temp_file.read()
+    with open(file_path2, 'r') as temp_file: content2 = temp_file.read()
+    with open(file_path3, 'r') as temp_file: content3 = temp_file.read()
+    with open(file_path4, 'r') as temp_file: content4 = temp_file.read()
+    
+    if copy:
+        with open(path+'Temp_E0.txt', 'w') as temp_file: temp_file.write(content1)
+        with open(path+'Temp_E1.txt', 'w') as temp_file: temp_file.write(content2)
+        with open(path+'Temp_E2.txt', 'w') as temp_file: temp_file.write(content3)
+        with open(path+'Temp_E3.txt', 'w') as temp_file: temp_file.write(content4)      
+    
+    return content1, content2, content3, content4, 
+
+def energyVectors1(temp):
+    temp = temp.split("\n")
+    row_m = ""
+    ee_vec, eg_vec, ep_vec, ea_vec = [], [], [], []
+    ee=0; eg=0; ep=0; ea=0 
+    for row in temp:
+        if row=="": row = "#"
+        if row[0] != "#":
+            row = row.split(" ")
+            if "" in row: row.pop(2)
+            if row[0]=='1': ee+=float(row[1])*1e-3
+            if row[0]=='2': eg+=float(row[1])*1e-3
+            if row[0]=='3': ep+=float(row[1])*1e-3
+            if row[0]=='4': ea+=float(row[1])*1e-3
+            if row[2] != row_m:
+                ee_vec.append(ee)
+                eg_vec.append(eg)
+                ep_vec.append(ep)
+                ea_vec.append(ea)
+                eg=0; ee=0; ep=0; ea=0
+        #else: print(row)
+    ee_vec = [num for num in ee_vec if num != 0]
+    eg_vec = [num for num in eg_vec if num != 0]
+    ep_vec = [num for num in ep_vec if num != 0]
+    ea_vec = [num for num in ea_vec if num != 0]
+    return ee_vec, eg_vec, ep_vec, ea_vec
+
+def energyVectors2(temp):
+    temp = temp.split("\n")
+    row_m = ""
+    ee_vec, ep_vec, ea_vec = [], [], []
+    ee=0; ep=0; ea=0 
+    for row in temp:
+        if row=="": row = "#"
+        if row[0] != "#":
+            row = row.split(" ")
+            if "" in row: row.pop(2)
+            if row[0]=='1': ee+=float(row[1])*1e-3
+            if row[0]=='3': ep+=float(row[1])*1e-3
+            if row[0]=='4': ea+=float(row[1])*1e-3
+            if row[2] != row_m:
+                ee_vec.append(ee)
+                ep_vec.append(ep)
+                ea_vec.append(ea)
+                ee=0; ep=0; ea=0
+        #else: print(row)
+    ee_vec = [num for num in ee_vec if num != 0]
+    ep_vec = [num for num in ep_vec if num != 0]
+    ea_vec = [num for num in ea_vec if num != 0]
+    return ee_vec, ep_vec, ea_vec
+
+
+def energyVectors3(temp):
+    temp = temp.split("\n")
+    row_m = ""
+    ee_vec = []; ee=0 
+    for row in temp:
+        if row=="": row = "#"
+        if row[0] != "#":
+            row = row.split(" ")
+            if "" in row: row.pop(2)
+            ee+=float(row[1])*1e-3
+            if row[2] != row_m:
+                ee_vec.append(ee)
+                ee=0
+        #else: print(row)
+    ee_vec = [num for num in ee_vec if num != 0]
+    return ee_vec
+
+def effVector(temp):
+    temp = temp.split("\n")
+    row_m = ""
+    s_vec, d_vec, t_vec = [], [], []
+    s=0; d=0; t=0 
+    for row in temp:
+        if row=="": row = "#"
+        if row[0] != "#":
+            row = row.split(" ")
+            s+=float(row[1])
+            d+=float(row[2])
+            t+=float(row[3])
+            if row[0] != row_m:
+                s_vec.append(s)
+                d_vec.append(d)
+                t_vec.append(t)
+                s=0; d=0; t=0
+        #else: print(row)
+    return s_vec, d_vec, t_vec
+
+
 # import PenNuc data
 with importlib.resources.as_file(files('tdcrpy').joinpath('decayData')) as data_path:
 #with importlib.resources.path('tdcrpy', 'decayData') as data_path:
@@ -331,7 +552,7 @@ def sampling(p_x):
     Returns
     -------
     i : integer
-        index in x pointing the sampled value of the random variable X.
+        index in x pointing the sampled value of the random variable X. in case of pdf use i+1
     """
 
     cf = np.cumsum(p_x) # Cummulative Density (or mass) Function (CDF or CMF)
@@ -758,7 +979,7 @@ def stoppingpower(e,rho=RHO,Z=Z,A=A,emin=0,file=data_TanXia_f):
 
 #====================  Fonction pour lire BetaShape   ========================================
 
-def readBetaShape(rad,mode,level,z=z_betashape,contH=True):
+def readBetaShape(rad,mode,level,z=z_betashape,contH=False):
     """
     This funcion reads the beta spectra calculated by the code BetaShape and published in the DDEP web page.
     
@@ -825,7 +1046,7 @@ def readBetaShape(rad,mode,level,z=z_betashape,contH=True):
 
     if contH: e=(np.asarray(e[:-1])+np.asarray(e[1:]))/2 # deal with the continuity hypothesis
     p.pop(-1)
-    if contH: p /= sum(np.asarray(p)) # normalization
+    p /= sum(np.asarray(p)) # normalization
     p = list(p); e = list(e)
     return e, p
 
@@ -1111,7 +1332,7 @@ def Em_e(Ei, Ed, kB, nE, Et = Einterp_e*1e3, kB_vec = kB_e):
     """    
     if Ed <= Et or Ei != Ed:
         # run the accurate quenching model
-        r = E_quench_e(Ei,Ed,kB,nE)
+        r = E_quench_e(Ei,Ed,kB,int(nE))
     else:
         # run interpolation
         r = run_interpolate(kB_vec, kB , Ei_electron, Em_electron, Ed)
@@ -1149,7 +1370,7 @@ def micelleLoss(E,*, fAq=fAq, diam_micelle=diam_micelle, e_vec=micelle_E, data=m
     S : float
         energy deposited ratio (keV)
     """
-    micDiam = np.array([0.5, 1.0, 2.0, 3.0, 4.0]) #nm
+    micDiam = np.array([0.5, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0]) #nm
     S=np.interp(E*1e3, e_vec, micelle_S[:,np.argwhere(micDiam==diam_micelle)[0][0]])*(1-fAq)/0.9
     return S
 
@@ -1227,7 +1448,9 @@ Matrice16_e_3 = read_matrice(fe6,2)
 #Matrice_e = read_matrice(fe,'e')
 
 def energie_dep_gamma(e_inci,v,matrice10_1=Matrice10_p_1,matrice10_2=Matrice10_p_2,matrice10_3=Matrice10_p_3,matrice16_1=Matrice16_p_1,matrice16_2=Matrice16_p_2,matrice16_3=Matrice16_p_3,matrice13_1=Matrice13_p_1,matrice13_2=Matrice13_p_2,matrice13_3=Matrice13_p_3,ed=Matrice_e):
-    """ This function samples the energy deposited by a x or gamma rays in the scintillator using response calculated by the Monte-Carlo code MCNP6. 
+    """
+    Deprecated!
+    This function samples the energy deposited by a x or gamma rays in the scintillator using response calculated by the Monte-Carlo code MCNP6. 
     
     Parameters
     ----------
@@ -1390,6 +1613,10 @@ def energie_dep_gamma2(e_inci,v,matrice10_1=Matrice10_p_1,matrice10_2=Matrice10_
     return result
 
 def energie_dep_beta(e_inci,*,matrice10_1=Matrice10_e_1,matrice10_2=Matrice10_e_2,matrice10_3=Matrice10_e_3,matrice16_1=Matrice16_e_1,matrice16_2=Matrice16_e_2,matrice16_3=Matrice16_e_3,ed=Matrice_e):
+    """
+    Deprecated
+    """
+    
     ## sort keV / entrée : keV
     if e_inci <= 200:
         if e_inci < 1:
@@ -2036,7 +2263,7 @@ def read_ENDF_photon(atom,z=z_endf_ph):
 
 
 
-def interaction_scintillation(e_p):
+def interaction_scintillation(e_p, p_atom=p_atom):
     """
     Simulation of the photoelectric interaction
 
@@ -2055,7 +2282,7 @@ def interaction_scintillation(e_p):
         target atom ('H', ...).
 
     """
-    p_atom = np.array([0.578772,0.338741,0.000302,0.082022,0.000092,0.000071]) # atom abondance in the scintillator
+    # p_atom = np.array([0.578772,0.338741,0.000302,0.082022,0.000092,0.000071]) # atom abondance in the scintillator
     atom = ['H','C','N','O','P','Cl']
     # sampling atom 
     
@@ -2476,7 +2703,7 @@ def relaxation_atom_ph(lacune,element,v):
 
 
 
-def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,mode2,ne):
+def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,ne):
     """
     TDCR analytical model that is used for pure beta emitting radionuclides
     
@@ -2500,8 +2727,6 @@ def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,mode2,ne):
         volume of the scintillator in ml. run only for 10 ml
     mode : string
         "res" to return the residual, "eff" to return efficiencies.
-    mode2 : string
-        "sym" for symetrical model, "asym" for symetrical model.
     nE : integer
          Number of bins for the quenching function.
     
@@ -2527,14 +2752,13 @@ def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,mode2,ne):
         em[i] = Em_e(ei*1e3,ei*1e3,kB*1e3,ne)*1e-3
         
         
-    if mode2=="sym":
+    if type(L)==float or isinstance(L, np.float64):
         eff_S = sum(p*(1-np.exp(-L*em/3)))
         eff_T = sum(p*(1-np.exp(-L*em/3))**3)
         eff_D = sum(p*(3*(1-np.exp(-L*em/3))**2-2*(1-np.exp(-L*em/3))**3))
         TDCR_calcul=eff_T/eff_D
         res=(TDCR_calcul-TD)**2
-
-    if mode2=="asym":
+    else:
         # eff_A = sum(p*(1-np.exp(-L[0]*em/3)))
         # eff_B = sum(p*(1-np.exp(-L[1]*em/3)))
         # eff_C = sum(p*(1-np.exp(-L[2]*em/3)))
@@ -2637,20 +2861,27 @@ def buildBetaSpectra(rad, V, N, prt=False):
     N = int(N)
     ev=[]
     for i in tqdm(range(N), desc="Processing", unit=" bins"):
-        ind = sampling(p)
+        ind = sampling(p) # sample in pdf
         ev.append(energie_dep_beta2(e[ind],V))
+        # ev.append(e[ind])
     counts, bins = np.histogram(ev, bins=e, density=True)
     p2=counts/sum(counts)
     
-    bin_centers = (bins[:-1] + bins[1:]) / 2
+    # bin_centers = (bins[:-1] + bins[1:]) / 2
     plt.figure(rad)
     plt.clf()
-    plt.bar(bin_centers, p2, width=(bins[1] - bins[0]), color='g', alpha=0.6, label="deposited")
-    plt.plot(e, p,'-r', alpha=0.6, label="betaShape")
+    # plt.bar(bin_centers, p2, width=(bins[1] - bins[0]), color='g', alpha=0.6, label="deposited")
+    plt.plot(bins[:-1], p2, '-g', alpha=0.6, label="deposited")
+    plt.plot(e[:-1], p,'-r', alpha=0.6, label="betaShape")
     plt.legend()
     plt.xlabel("$E$ /keV")
     plt.ylabel(r"$p$ /keV$^{-1}$")
     
+    em0 = sum(np.asarray(e[:-1])*np.asarray(p))
+    em1 = sum(bins[:-1]*p2)
+    print(f"\nmean emitted E = {em0} keV {len(e)} {len(p)}")
+    print(f"mean deposited E = {em1} keV {len(bins)} {len(p2)}\n")
+    
     if rad == "H-3": file_path = sH3
     elif rad == "C-14": file_path = sC14
     elif rad == "S-35": file_path = sS35
@@ -2665,15 +2896,496 @@ def buildBetaSpectra(rad, V, N, prt=False):
     
     if prt:
         with open(file_path, "w") as file:
-            for i, b in enumerate(bin_centers):
-                file.write(f"{b}\t{p2[i]}\n")
+            for i, b in enumerate(bins):
+                if i==len(bins)-1: file.write(f"{b}\t{0}\n")
+                else: file.write(f"{b}\t{p2[i]}\n")
         print("file written in distrib.")
         with open(f"./MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_{rad}.txt", "w") as file:
-            for i, b in enumerate(bin_centers):
-                file.write(f"{b}\t{p2[i]}\n")
+            for i, b in enumerate(bins):
+                if i==len(bins)-1: file.write(f"{b}\t{0}\n")
+                else: file.write(f"{b}\t{p2[i]}\n")
         print("file written in local")        
                 
+def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime, effQuantic = effQuantic):
+    """
+    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
+        mu = effQuantic
+    else:
+        symm = True
+        mu = np.mean(effQuantic)
+         
+    
+        
+    if symm:
+        
+        if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+            # TDCR
+            p_nosingle = np.exp(-L*mu*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+            p_nosingle2 = np.exp(-L*mu*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            p_single2 = 1-p_nosingle2
+            efficiency0_S = 1-p_nosingle**3+1-p_nosingle2**3
+            efficiency0_T = p_single**3+p_single2**3
+            efficiency0_D = 3*(p_single)**2-2*p_single**3+(3*(p_single2)**2-2*p_single2**3)
+            efficiency0_AB = (efficiency0_D+2*efficiency0_T)/3
+            efficiency0_BC = efficiency0_AB
+            efficiency0_AC = efficiency0_AB
+            
+            # CN
+            p_nosingle = np.exp(-L*mu*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+            p_nosingle2 = np.exp(-L*mu*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 electrons in a PMT
+            p_single2 = 1-p_nosingle2            
+            efficiency0_A2 = p_single+p_single2
+            efficiency0_B2 = efficiency0_A2
+            efficiency0_D2 = p_single**2+p_single2**2
+        else:
+            # TDCR
+            p_nosingle = np.exp(-L*mu*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+            efficiency0_S = 1-p_nosingle**3
+            efficiency0_T = p_single**3
+            efficiency0_D = 3*(p_single)**2-2*efficiency0_T
+            efficiency0_AB = (efficiency0_D+2*efficiency0_T)/3
+            efficiency0_BC = efficiency0_AB
+            efficiency0_AC = efficiency0_AB
+            
+            # CN
+            p_nosingle = np.exp(-L*mu*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT            
+            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            
+            pA_nosingle = np.exp(-L[0]*mu[0]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pA_single = 1-pA_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle = np.exp(-L[1]*mu[1]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pB_single = 1-pB_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pC_nosingle = np.exp(-L[2]*mu[2]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pC_single = 1-pC_nosingle                                    # probability to have at least 1 electrons in a PMT
+            
+            pA_nosingle2 = np.exp(-L[0]*mu[0]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            pA_single2 = 1-pA_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle2 = np.exp(-L[1]*mu[1]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            pB_single2 = 1-pB_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            pC_nosingle2 = np.exp(-L[2]*mu[2]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            pC_single2 = 1-pC_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            
+            efficiency0_A2 = pA_single+pA_single2
+            efficiency0_B2 = pB_single+pB_single2
+            efficiency0_AB = pA_single*pB_single+pA_single2*pB_single2
+            efficiency0_BC = pB_single*pC_single+pB_single2*pC_single2
+            efficiency0_AC = pA_single*pC_single+pA_single2*pC_single2
+            efficiency0_T = pA_single*pB_single*pC_single+pA_single2*pB_single2*pC_single2
+            efficiency0_D = pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single+(pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2)
+            #efficiency_S = pA_single+pB_single+pC_single-pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single-pA_single*pB_single*pC_single+(pA_single2+pB_single2+pC_single2-pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2-pA_single2*pB_single2*pC_single2)
+            efficiency0_S = 1-pA_nosingle*pB_nosingle*pC_nosingle+1-pA_nosingle2*pB_nosingle2*pC_nosingle2
+            
+            
+            # CN
+            pA_nosingle = np.exp(-L[0]*mu[0]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pA_single = 1-pA_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle = np.exp(-L[1]*mu[1]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pB_single = 1-pB_nosingle                                    # probability to have at least 1 electrons in a PMT
+            
+            pA_nosingle2 = np.exp(-L[0]*mu[0]*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 electrons in a PMT
+            pA_single2 = 1-pA_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle2 = np.exp(-L[1]*mu[1]*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 electrons in a PMT
+            pB_single2 = 1-pB_nosingle2                                    # probability to have at least 1 electrons in a PMT
+
+            efficiency0_D2 = pA_single*pB_single+pA_single2*pB_single2
+        else:
+            # TDCR
+            pA_nosingle = np.exp(-L[0]*mu[0]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pA_single = 1-pA_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle = np.exp(-L[1]*mu[1]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pB_single = 1-pB_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pC_nosingle = np.exp(-L[2]*mu[2]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pC_single = 1-pC_nosingle                                    # probability to have at least 1 electrons in a PMT
                 
+            efficiency0_A2 = pA_single
+            efficiency0_B2 = pB_single
+            efficiency0_AB = pA_single*pB_single
+            efficiency0_BC = pB_single*pC_single
+            efficiency0_AC = pA_single*pC_single
+            efficiency0_T = pA_single*pB_single*pC_single
+            efficiency0_D = efficiency0_AB+efficiency0_BC+efficiency0_AC-2*efficiency0_T
+            efficiency0_S = 1-pA_nosingle*pB_nosingle*pC_nosingle
+            
+            # CN
+            pA_nosingle = np.exp(-L[0]*mu[0]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pA_single = 1-pA_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle = np.exp(-L[1]*mu[1]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pB_single = 1-pB_nosingle                                    # probability to have at least 1 electrons in a PMT            
+            efficiency0_D2 = pA_single*pB_single
+            
+    return efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2        
+
+
+def stochasticDepTD(diffP, PMTspace):
+    """
+    Generate the probability
+
+    Parameters
+    ----------
+    diffP : TYPE
+        DESCRIPTION.
+    PMTspace : TYPE
+        DESCRIPTION.
+
+    Returns
+    -------
+    TYPE
+        DESCRIPTION.
+
+    """
+    detA = np.array([[2*(1+PMTspace), 0], [-(1+PMTspace), np.sqrt(3)*(1+PMTspace)]])
+    detB = np.array([[-(1+PMTspace), np.sqrt(3)*(1+PMTspace)], [-(1+PMTspace), -np.sqrt(3)*(1+PMTspace)]])
+    detC = np.array([[-(1+PMTspace), -np.sqrt(3)*(1+PMTspace)], [2*(1+PMTspace), 0]])
+
+    def simulate_photon_groups():
+        rho = 1 * np.sqrt(np.random.uniform(0, 1, 1))  # Radial distance
+        theta = np.random.uniform(0, 2 * np.pi, 1)     # Angular position
+        x = rho * np.cos(theta)
+        y = rho * np.sin(theta)
+        return x, y
+
+    def calculate_angle(O, det):
+        A=det[0]
+        B=det[1]
+        OA = (A[0] - O[0], A[1] - O[1]) # Vecteurs OA et OB
+        OB = (B[0] - O[0], B[1] - O[1])
+        dot_product = OA[0] * OB[0] + OA[1] * OB[1] # Produit scalaire OA . OB
+        norm_OA = math.sqrt((OA[0]**2 + OA[1]**2)[0]) # Normes des vecteurs OA et OB
+        norm_OB = math.sqrt((OB[0]**2 + OB[1]**2)[0])
+        cos_angle = dot_product / (norm_OA * norm_OB) # Cosinus de l'angle
+        angle_rad = math.acos(cos_angle[0]) # Angle en radians
+        angle_deg = math.degrees(angle_rad) # Convertir en degrés
+        return angle_deg
+
+    x, y = simulate_photon_groups()
+
+    pa=(1-diffP)*calculate_angle([x, y], detA)/360+diffP/3
+    pb=(1-diffP)*calculate_angle([x, y], detB)/360+diffP/3
+    pc=(1-diffP)*calculate_angle([x, y], detC)/360+diffP/3
+        
+    return pa, pb, pc
+
+# Di = []; Ti = []
+# n=1000000
+# for i in range(n):
+#     A = stochasticDepTD(1, 0)
+#     B = np.random.poisson(2)
+#     n_phPMT = np.random.multinomial(B, A) # sample the number of photons in each PMTs (TDCR configuration)
+#     nA=np.random.binomial(n_phPMT[0],0.25) # sample the conversion to photoelectrons PMT A
+#     nB=np.random.binomial(n_phPMT[1],0.25) # sample the conversion to photoelectrons PMT B
+#     nC=np.random.binomial(n_phPMT[2],0.25) # sample the conversion to photoelectrons PMT C
+#     Di.append(sum([nA>0, nB>0, nC>0])>1)
+#     Ti.append(sum([nA>0, nB>0, nC>0])>2)
+# D = sum(Di)/n
+# uD = D/np.sqrt(sum(Di))#np.sqrt(n)
+# T = sum(Ti)/n
+# uT = T/np.sqrt(sum(Ti))#/np.sqrt(n)
+# print(D, uD)
+# print(T, uT)
+
+def stochasticDepCN(diffP, PMTspace):
+    def simulate_photon_groups():
+        rho = 1 * np.sqrt(np.random.uniform(0, 1, 1))  # Radial distance
+        theta = np.random.uniform(0, 2 * np.pi, 1)     # Angular position
+        x = rho * np.cos(theta)
+        y = rho * np.sin(theta)
+        return x, y
+    
+    def calculate_angle(O):
+        OA = (-1-PMTspace - O[0], 0 - O[1]) # Vecteurs OA et OB
+        OB = (1+PMTspace - O[0], 0 - O[1])
+        dot_product = OA[0] * OB[0] + OA[1] * OB[1] # Produit scalaire OA . OB
+        norm_OA = math.sqrt((OA[0]**2 + OA[1]**2)[0]) # Normes des vecteurs OA et OB
+        norm_OB = math.sqrt((OB[0]**2 + OB[1]**2)[0])
+        cos_angle = dot_product / (norm_OA * norm_OB) # Cosinus de l'angle
+        angle_rad = math.acos(cos_angle[0]) # Angle en radians
+        angle_deg = math.degrees(angle_rad) # Convertir en degrés
+        return angle_deg
+    
+    x, y = simulate_photon_groups()
+
+    if np.random.randint(0, high=2)==0:
+        pa=(1-diffP)*calculate_angle([x, y])/360+diffP/2
+        pb=1-pa
+    else:
+        pb=(1-diffP)*calculate_angle([x, y])/360+diffP/2
+        pa=1-pb        
+        
+    return pa, pb
+
+
+def detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime, effQuantic = effQuantic, optionModel=optionModel, diffP = diffP, PMTspace = PMTspace, dispParam=False):
+    """
+    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.
+
+    """
+    mu = effQuantic
+        
+    if type(L) == float:
+        L = [L, L, L]
+    
+    if dispParam: print(f"EffQ = {mu} - model = {optionModel} - diffP = {diffP} - PMTspace = {PMTspace}")
+    
+    def stochasOpticModel(e_q, L, mu):
+        n_e=np.zeros(3); n_eCN=np.zeros(2) # initilize the number of photoelectrons
+        
+        n_ph = np.random.poisson(sum(np.asarray(e_q))*np.mean(L)) # sample the number of scintillation photons
+        
+        pTD = stochasticDepTD(diffP, PMTspace) # probabilities for photons to move towards the different PMTs (TDCR configuration)
+        n_phPMT = np.random.multinomial(n_ph, pTD) # sample the number of photons in each PMTs (TDCR configuration)
+        n_e[0]=np.random.binomial(n_phPMT[0],mu[0]) # sample the conversion to photoelectrons PMT A
+        n_e[1]=np.random.binomial(n_phPMT[1],mu[1]) # sample the conversion to photoelectrons PMT B
+        n_e[2]=np.random.binomial(n_phPMT[2],mu[2]) # sample the conversion to photoelectrons PMT C
+        
+        pCN = stochasticDepCN(diffP, PMTspace) # probabilities for photons to move towards the different PMTs (C/N configuration)
+        n_phPMTCN = np.random.multinomial(n_ph, pCN) # sample the number of photons in each PMTs (C/N configuration)
+        n_eCN[0]=np.random.binomial(n_phPMTCN[0],mu[0]) # sample the conversion to photoelectrons PMT A
+        n_eCN[1]=np.random.binomial(n_phPMTCN[1],mu[1]) # sample the conversion to photoelectrons PMT B
+        
+        return n_e, n_eCN        
+    
+    def Pmodel(e_q, pTD_ideal, pCN_ideal, L, mu):
+        n_e=np.zeros(3); n_eCN=np.zeros(2) # initilize the number of photoelectrons
+        
+        n_e[0] = np.random.poisson(sum(np.asarray(e_q))*L[0]*mu[0]*pTD_ideal[0]) # sample the conversion to photoelectrons PMT A
+        n_e[1] = np.random.poisson(sum(np.asarray(e_q))*L[1]*mu[1]*pTD_ideal[1]) # sample the conversion to photoelectrons PMT B
+        n_e[2] = np.random.poisson(sum(np.asarray(e_q))*L[2]*mu[2]*pTD_ideal[2]) # sample the conversion to photoelectrons PMT C
+        n_eCN[0] = np.random.poisson(sum(np.asarray(e_q))*L[0]*mu[0]*pCN_ideal[0]) # sample the conversion to photoelectrons PMT A
+        n_eCN[1] = np.random.poisson(sum(np.asarray(e_q))*L[1]*mu[1]*pCN_ideal[1]) # sample the conversion to photoelectrons PMT B
+        
+        return n_e, n_eCN
+     
+    
+    efficiency0_S = 0;    efficiency0_T = 0;    efficiency0_D = 0
+    efficiency0_AB = 0;    efficiency0_BC = 0;    efficiency0_AC = 0
+    efficiency0_D2 = 0;
+    # n_e = np.zeros(3); n_eCN = np.zeros(2); n_e2 = np.zeros(3); n_e2CN = np.zeros(2)
+    if optionModel == "stochastic-dependence":
+        n_e, n_eCN = stochasOpticModel(e_quenching, L, mu)
+    elif optionModel == "poisson":
+        n_e, n_eCN = Pmodel(e_quenching, [1/3, 1/3, 1/3], [1/2, 1/2], L, mu)
+    else:
+        print("unknown model")        
+            
+    if sum(n_e>0)>0: efficiency0_S =1
+    if sum(n_e>0)>1: efficiency0_D =1
+    if sum(n_e>0)>2: efficiency0_T =1
+    if n_e[0]>0 and n_e[1]>0: efficiency0_AB =1 
+    if n_e[1]>0 and n_e[2]>0: efficiency0_BC =1 
+    if n_e[0]>0 and n_e[2]>0: efficiency0_AC =1
+    if sum(n_eCN>1)>1: efficiency0_D2 =1
+    
+    if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+        if optionModel == "stochastic-dependence":
+            n_e2, n_e2CN = stochasOpticModel(e_quenching2, L, mu)
+        elif optionModel == "poisson":
+            n_e2, n_e2CN = Pmodel(e_quenching2, [1/3, 1/3, 1/3], [1/2, 1/2], L, mu) 
+        else:
+            print("unknown model")        
+        
+        if sum(n_e2>0)>0: efficiency0_S +=1
+        if sum(n_e2>0)>1: efficiency0_D +=1
+        if sum(n_e2>0)>2: efficiency0_T +=1
+        if n_e2[0]>0 and n_e2[1]>0: efficiency0_AB +=1 
+        if n_e2[1]>0 and n_e2[2]>0: efficiency0_BC +=1 
+        if n_e2[0]>0 and n_e2[2]>0: efficiency0_AC +=1
+        if sum(n_e2CN>1)>1: efficiency0_D2 +=1           
+                    
+    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.
+
+    Parameters
+    ----------
+    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.
+    N : interger
+        number of simulated decays.
+
+    Returns
+    -------
+    mean_efficiency_S : float
+        detection efficiency of single event.
+    std_efficiency_S : float
+        standard uncertainty of detection efficiency of single event.
+    mean_efficiency_D : float
+        detection efficiency of double coincidences.
+    std_efficiency_D : float
+        standard uncertainty of detection efficiency of double coincidences.
+    mean_efficiency_T : float
+        detection efficiency of triple coincidences.
+    std_efficiency_T : float
+        standard uncertainty of detection efficiency of triple coincidences.
+    mean_efficiency_AB : float
+        detection efficiency of coincidences between channels A and B.
+    std_efficiency_AB : float
+        standard uncertainty of detection efficiency of coincidences between channels A and B.
+    mean_efficiency_BC : float
+        detection efficiency of coincidences between channels B and C.
+    std_efficiency_BC : float
+        standard uncertainty of Ddetection efficiency of coincidences between channels B and C.
+    mean_efficiency_AC : float
+        detection efficiency of coincidences between channels A and C.
+    std_efficiency_AC : float
+        standard uncertainty of detection efficiency of coincidences between channels A and C.
+    mean_efficiency_D2 : float
+        detection efficiency of coincidences in a C/N system.
+    std_efficiency_D2 : float
+        standard uncertainty of detection efficiency of coincidences in a C/N system.
+
+    """
+    mean_efficiency_S = np.mean(efficiency_S)
+    std_efficiency_S = np.std(efficiency_S)/np.sqrt(N)
+    mean_efficiency_D = np.mean(efficiency_D)
+    std_efficiency_D = np.std(efficiency_D)/np.sqrt(N)
+    mean_efficiency_T = np.mean(efficiency_T) # average
+    std_efficiency_T = np.std(efficiency_T)/np.sqrt(N)   # standard deviation
+    mean_efficiency_AB = np.mean(efficiency_AB)
+    std_efficiency_AB = np.std(efficiency_AB)/np.sqrt(N)
+    mean_efficiency_BC = np.mean(efficiency_BC)
+    std_efficiency_BC = np.std(efficiency_BC)/np.sqrt(N)
+    mean_efficiency_AC = np.mean(efficiency_AC)
+    std_efficiency_AC = np.std(efficiency_AC)/np.sqrt(N)
+    
+    mean_efficiency_D2 = np.mean(efficiency_D2)
+    std_efficiency_D2 = np.std(efficiency_D2)/np.sqrt(N)
+
+    return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_AB, std_efficiency_AB, mean_efficiency_BC, std_efficiency_BC, mean_efficiency_AC, std_efficiency_AC, mean_efficiency_D2, std_efficiency_D2
+    
+
+def readRecQuenchedEnergies():
+    temp_dir = tempfile.gettempdir()
+    recfile3 = os.path.join(temp_dir, "Temp_E2.txt")
+    with open(recfile3, "r") as file:
+        Epromt, Edelayed = [], []
+        decaym = -1
+        e_quenching = []; e_quenching2 = []; evenement=1; t1=0
+        for line in file:
+            if line[0] != "#":
+                line = line.split(' ')
+                line = [element for element in line if element != ""]
+                decay = int(line[2])                
+                if decay != decaym:
+                    if decay>0:
+                        Epromt.append(sum(e_quenching))
+                        Edelayed.append(sum(e_quenching2))
+                        
+                        
+                        energy = float(line[1])*1e-3
+                        t1 = float(line[4])
+                        decaym = decay
+                        e_quenching = []; e_quenching2 = []
+                        evenement=1
+                        e_quenching.append(energy)
+                else:
+                    energy = float(line[1])*1e-3
+                    t1 = float(line[4])
+                    # print(decay, energy, t1, extDT)
+                    if t1 > tau*1e-9:
+                        evenement = evenement + 1
+                        e_quenching2.append(energy)
+                    else:
+                        e_quenching.append(energy)
+    return Epromt, Edelayed
+
+
+
+
 # N = 1e7
 # buildBetaSpectra('H-3', 16, N, prt=True); print('H-3 - done')
 # buildBetaSpectra('C-14', 16, N, prt=True); print('C-14 - done')