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

tdcrpy/TDCRPy.py

@@ -289,6 +289,7 @@ def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smode
                 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)
@@ -1038,7 +1039,7 @@ def objectFct(L, TD, Rad, pmf_1, N, kB, V):
     
     return res
 
-def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False):
+def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False, Lbounds=[0.1, 10]):
     """
     Caclulation of the efficiency of a TDCR system based on the model TDCRPy.
     This function includes optimization procedures from scipy.
@@ -1107,8 +1108,8 @@ def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False)
     
     TDCRPy(L, Rad, pmf_1, N, kB, V, record = True)
        
-    if symm: r=opt.minimize_scalar(objectFct, args=(TD, Rad, pmf_1, N, kB, V), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
-    else: r=opt.minimize_scalar(objectFct, args=(TD[0], Rad, pmf_1, N, kB, V), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
+    if symm: r=opt.minimize_scalar(objectFct, args=(TD, Rad, pmf_1, N, kB, V), method='bounded', bounds = (Lbounds[0], Lbounds[1]), options={'disp': disp, 'maxiter':maxiter})
+    else: r=opt.minimize_scalar(objectFct, args=(TD[0], Rad, pmf_1, N, kB, V), method='bounded', bounds = (Lbounds[0], Lbounds[1]), options={'disp': disp, 'maxiter':maxiter})
     L0=r.x
     L=(L0, L0, L0)
     print(f"global free parameter = {L0} keV-1")
@@ -1138,7 +1139,7 @@ def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False)
     return L0, L, eff_S, u_eff_S, eff_D, u_eff_D, eff_T, u_eff_T, eff_AB, u_eff_AB, eff_BC, u_eff_BC, eff_AC, u_eff_AC, eff_D2, u_eff_D2
 
 
-def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False):
+def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False, Lbounds=[0.1, 10]):
     """
     Caclulation of the efficiency of a TDCR system based on the model TDCRPy (analytical model).
     This function includes optimization procedures from scipy.
@@ -1203,8 +1204,8 @@ def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False):
     else:
         symm = True
 
-    if symm: r=opt.minimize_scalar(tl.modelAnalytical, args=(TD, TD, TD, TD, Rad, kB, V, "res", 1e3), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
-    else: r=opt.minimize_scalar(tl.modelAnalytical, args=(TD[0], TD[1], TD[2], TD[3], Rad, kB, V, "res", 1e3), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
+    if symm: r=opt.minimize_scalar(tl.modelAnalytical, args=(TD, TD, TD, TD, Rad, kB, V, "res", 1e3), method='bounded', bounds = (Lbounds[0], Lbounds[1]), options={'disp': disp, 'maxiter':maxiter})
+    else: r=opt.minimize_scalar(tl.modelAnalytical, args=(TD[0], TD[1], TD[2], TD[3], Rad, kB, V, "res", 1e3), method='bounded', bounds = (Lbounds[0], Lbounds[1]), options={'disp': disp, 'maxiter':maxiter})
     L0=r.x
     L=(L0, L0, L0)
     print(f"global free parameter = {L0} keV-1")
@@ -1236,20 +1237,20 @@ 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
+# Rad="Fe-55"                 # 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
+# L=np.logspace(-1,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)
+# TDCRPy(L[0], Rad, pmf_1, N, kB, V, mode, barp=False, record=True, fullMC=False)
+# # TDCRPy(100, Rad, pmf_1, N, kB, V, mode, barp=False, record=True, fullMC=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)
+#   out = TDCRPy(l, Rad, pmf_1, N, kB, V, mode, readRecHist=True, fullMC=False)
 #   effS.append(out[2])
 #   u_effS.append(out[3])
 #   effD.append(out[2])

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
@@ -24,6 +23,7 @@ import scipy.interpolate as  interp
 import matplotlib.pyplot as plt
 from tqdm import tqdm
 import tempfile
+import math
 
 """
 ======= Import ressource data =======
@@ -32,6 +32,16 @@ import tempfile
 # import advanced configuration data
 config = configparser.ConfigParser()
 
+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()
@@ -60,6 +70,15 @@ def readParameters(disp=False):
     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}")
@@ -76,13 +95,18 @@ def readParameters(disp=False):
         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, pH,pC,pN,pO,pP,pCl
+    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, pH,pC,pN,pO,pP,pCl = readParameters()
+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) 
@@ -96,7 +120,7 @@ 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()
@@ -190,7 +214,38 @@ def modifyMeasTime(x):
 def modifyMicCorr(x):
     data0 = readConfigAsstr()
     x0 = readParameters()[13]
-    data1 = data0.replace(f"micCorr = {x0}",f"micCorr= {x}")
+    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:"):
@@ -2851,7 +2906,7 @@ def buildBetaSpectra(rad, V, N, prt=False):
                 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):
+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 
 
@@ -2892,17 +2947,20 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
     """
     if isinstance(L, (tuple, list)):
         symm = False
+        mu = effQuantic
     else:
         symm = True
+        mu = np.mean(effQuantic)
          
+    
         
     if symm:
-        # print(evenement !=1, t1 > extDT*1e-6, t1 < measTime*60)
+        
         if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
             # TDCR
-            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            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*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 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
@@ -2912,16 +2970,16 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
             efficiency0_AC = efficiency0_AB
             
             # CN
-            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            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*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 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*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            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
@@ -2931,7 +2989,7 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
             efficiency0_AC = efficiency0_AB
             
             # CN
-            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            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
@@ -2939,18 +2997,18 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
     else:
         if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
             # TDCR            
-            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            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]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 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]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 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]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 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]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 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]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 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
@@ -2965,24 +3023,24 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
             
             
             # CN
-            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            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]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 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]*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 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]*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 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]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            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]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 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]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 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
@@ -2995,16 +3053,114 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, meas
             efficiency0_S = 1-pA_nosingle*pB_nosingle*pC_nosingle
             
             # CN
-            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            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]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 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 detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime):
+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 
 
@@ -3043,123 +3199,79 @@ def detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, me
         detection probability of coincidences in a C/N system.
 
     """
-    if isinstance(L, (tuple, list)):
-        symm = False
-    else:
-        symm = True
+    mu = effQuantic
+        
+    if type(L) == float:
+        L = [L, L, L]
     
-    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        
-
-
-
+    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):
@@ -3271,6 +3383,9 @@ def readRecQuenchedEnergies():
                         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')

tdcrpy/config.toml

@@ -31,6 +31,16 @@ diam_micelle = 2
 # acqueous fraction of the scintillator
 fAq = 0.1
 
+## OPTICAL PROPERTIES
+# Quantum efficiency
+effQuantum = 0.25, 0.25, 0.25
+# Optical MC model
+optionModel = stochastic-dependence
+# fraction of diffused scintillation photons
+diffP = 1.0
+# relative distance from vials border to PMT entrance
+PMTspace = 0.1
+
 ## PROPERTIES OF THE COUNTER
 # Coincidence resolving time (ns)
 tau = 50

tdcrpy/test_randomGen.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 14 16:17:16 2025
+
+@author: romain.coulon
+"""
+import numpy as np
+
+# m = 0.1
+# N = 1000000
+
+# ps0 = 1-np.exp(-m)
+
+# psi=np.random.poisson(m,N)
+# ps1 = sum(psi>0)/N
+# ups1 = np.sqrt(sum(psi>0))/N
+
+# print(ps0,ps1,ups1)
+# print(ps0-ps1,ups1)
+# print(abs(ps0-ps1)<2*ups1)
+
+import importlib
+import tdcrpy
+tdcrpy.TDCR_model_lib.modifyEffQ("0.1, 0.1, 0.1")
+# tdcrpy.TDCR_model_lib.modifyOptModel("stochastic-dependence")
+tdcrpy.TDCR_model_lib.modifyOptModel("poisson")
+L = [1.0, 1.0, 1.0]
+e_q = [100]
+diffP = 1
+importlib.reload(tdcrpy.TDCR_model_lib)
+
+Q = tdcrpy.TDCR_model_lib.readEffQ0()
+Q = Q.split(",")
+Q = [float(i) for i in Q]
+QL = [float(Qi)*L[i] for i, Qi in enumerate(Q)]
+
+e_q2 = [0]; t1 = 0; evenement = 1; extDT = 50; measTime = 60000
+
+S,D,T,_,_,_,_ = tdcrpy.TDCR_model_lib.detectProbabilities(QL, e_q, e_q2, t1, evenement, extDT, measTime)
+SmcI=[];DmcI=[];TmcI=[]
+nIter=100000
+for i in range(nIter):
+    Smc,Dmc,Tmc,_,_,_,_ = tdcrpy.TDCR_model_lib.detectProbabilitiesMC(L, e_q, e_q2, t1, evenement, extDT, measTime, dispParam=True)
+    SmcI.append(Smc); DmcI.append(Dmc); TmcI.append(Tmc)
+
+print('\n')
+tdcrpy.TDCR_model_lib.readParameters(disp=True)
+
+print("\nEffQ = ", Q, "\tEffQ*L = ", QL, "\n")
+
+print("\nEFF, EFFmc, +/-")
+print("single eff = ",round(S,4),round(np.mean(SmcI),4),round(np.std(SmcI)/np.sqrt(nIter),4))
+print("double eff = ",round(D,4),round(np.mean(DmcI),4),round(np.std(DmcI)/np.sqrt(nIter),4))
+print("triple eff = ",round(T,4),round(np.mean(TmcI),4),round(np.std(TmcI)/np.sqrt(nIter),4))
+print('\nDEVIATION < 2 sigma')
+print("single eff = ",abs(round(S,4)-round(np.mean(SmcI),4))<2*round(np.std(SmcI)/np.sqrt(nIter),4))
+print("double eff = ",abs(round(D,4)-round(np.mean(DmcI),4))<2*round(np.std(DmcI)/np.sqrt(nIter),4))
+print("triple eff = ",abs(round(T,4)-round(np.mean(TmcI),4))<2*round(np.std(TmcI)/np.sqrt(nIter),4))
+print('\nPRECISION')
+print("single eff = ",round(100*np.std(SmcI)/(np.sqrt(nIter)*round(np.mean(SmcI),4)),4)," %")
+print("double eff = ",round(100*np.std(DmcI)/(np.sqrt(nIter)*round(np.mean(DmcI),4)),4)," %")
+print("triple eff = ",round(100*np.std(TmcI)/(np.sqrt(nIter)*round(np.mean(TmcI),4)),4)," %")

{tdcrpy-2.4.0.dist-info → tdcrpy-2.15.8.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: TDCRPy
-Version: 2.4.0
+Version: 2.15.8
 Summary: TDCR model
 Home-page: https://pypi.org/project/TDCRPy/
 Author: RomainCoulon (Romain Coulon)
 Author-email: <romain.coulon@bipm.org>
 Project-URL: Documentation, https://github.com/RomainCoulon/TDCRPy/
 Keywords: Python,TDCR,Monte-Carlo,radionuclide,scintillation,counting
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
@@ -49,7 +49,8 @@ The code is developped and maintained by the BIPM (MIT license).
 
 Technical details can be found in
 
-http://dx.doi.org/10.13140/RG.2.2.15682.80321
+* http://dx.doi.org/10.13140/RG.2.2.15682.80321
+* https://doi.org/10.1016/j.apradiso.2024.111518
 
 ## 1.1 Installation
 

{tdcrpy-2.4.0.dist-info → tdcrpy-2.15.8.dist-info}/RECORD

@@ -1,10 +1,11 @@
-tdcrpy/TDCRPy.py,sha256=of9b8U2-Zl1pHj4YqoWLJ6Ibjpb8xFgdE7_-9gO-hEg,67823
+tdcrpy/TDCRPy.py,sha256=3puNWaySzWsCg08OYzI89rWRy5f2CV2aa5HuC0tVCFM,67965
 tdcrpy/TDCRPy1.py,sha256=QTBZh5B5JWnGB0BQfD-cFmwA9W080OD4sG-aj50-ejo,38106
-tdcrpy/TDCR_model_lib.py,sha256=yGvth6Fu1a6tWRu6Uajnpv604qyUMCviBXeifQ6-4Xg,133469
+tdcrpy/TDCR_model_lib.py,sha256=aaQfweMgml6_yzvEAMmVC0zXcYd2WBxqY-os-nzmktA,138157
 tdcrpy/TDCRoptimize.py,sha256=c2XIGveeLdVYYek4Rg6dygMvVA2xIrIkMb3L-_jUucM,6496
 tdcrpy/__init__.py,sha256=9Djir8dPNchcJVQvhl-oRHEOsoDkiZlkOhWT-eHR7wQ,95
-tdcrpy/config.toml,sha256=d_olKEgxfobBHkZ2wEj9EgKE7I8Wbpim9ZAsi5ImFxk,1470
+tdcrpy/config.toml,sha256=UvIV6oUFjkk96c0Z053l14vekVc0eZ2-C0xy8MTs2zQ,1725
 tdcrpy/test2.py,sha256=poLLXJyIaCeqh1VSkwgbi-udvY7lQjxz_YStKjJXGhU,501
+tdcrpy/test_randomGen.py,sha256=CWN8jWJ3VAu6WhkRIR9BHv-e4V4hGx5jSfWBqGE0TT4,2195
 tdcrpy/MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_C-14.txt,sha256=Eh3KaNbfYHakk_uStLu8K1aFciO6_i_rS2yKxGGppDE,8416
 tdcrpy/MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_Ca-45.txt,sha256=TymodcK4ttoO1duZuW3RGOwHFwPPzw2ESPc_H_QQN8k,8830
 tdcrpy/MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_Co-60.txt,sha256=kxD5E7tk_Gc1Ylg8qCG1r3oB21m7wUT4zBWsmbseiMU,40203
@@ -62,9 +63,9 @@ tdcrpy/Quenching/TandataUG.txt,sha256=AkUGz2dAZ6g3bQIIacR5f92aa8gmiklgRbN4Dyz-12
 tdcrpy/Quenching/alpha_toulene.txt,sha256=rJB9xCLM3GLg91EKfhu8sGwro281ySq6R0G5mXMt3f8,1553
 tdcrpy/Quenching/inputVecteurAlpha.txt,sha256=ee4emplX51vhomC7cGNP_eE5eqS9By5PaSSaa4hh1eg,178652
 tdcrpy/Quenching/inputVecteurElectron.txt,sha256=5NBRBaiB7op1SJ6v952w9gFKqh0x83pn8zYcoUpy33Y,181498
-tdcrpy/decayData/All-nuclides_BetaShape.zip,sha256=4aTyDeOLFWAWjfkmr7Fk5xHtsva3RTAUq-8_ii6fLf0,7881260
-tdcrpy/decayData/All-nuclides_Ensdf.zip,sha256=GL-X_IG6x4ykGrWYaMiZrjfMXOvYPM07G-Cp8WCPOu8,437902
-tdcrpy/decayData/All-nuclides_PenNuc.zip,sha256=DmhS2CYegWhL8qggc_MO6FgyiXE5qX73dOoH-SSQXoo,388954
+tdcrpy/decayData/All-nuclides_BetaShape.zip,sha256=k-UOym1MPPzGrOwal2mrlcXi3NSR1vAqzO15qTsW25c,8000329
+tdcrpy/decayData/All-nuclides_Ensdf.zip,sha256=J7m6Uq9UqEvBgazuu31NPDO-43xMh3Ktq6w6yMEWBF0,453398
+tdcrpy/decayData/All-nuclides_PenNuc.zip,sha256=o2DftXAJW6-zpBpi_ozHZiDIzl3XcEcAjFJZWAeHbI8,410519
 tdcrpy/decayData/atom-ENDF-VII0.zip,sha256=oP4Z7qWweWF4j12QAIfvLFLlqeY1RomXwXD2iFgQCqo,1624444
 tdcrpy/decayData/photo-ENDF.zip,sha256=eOiVUt6OKGl0a3pErfaibZzF_yoSzswdUCTbnGNlu7g,249674
 tdcrpy/docs/_build/html/genindex.html,sha256=FopjoEyhTbeh7qOem-A7er-6yCIfdhv1BIzs9dJocCc,2522
@@ -74,8 +75,8 @@ tdcrpy/docs/_build/html/source/modules.html,sha256=Jf-qxVBId0UgpwyvYuyjtMNG-ezPO
 tdcrpy/docs/_build/html/source/tdcrpy.html,sha256=-38lHMNFB22p1tWJEeN3yDqfDiCYE304vxDamO1-iRc,3779
 tdcrpy/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tdcrpy/test/test_tdcrpy.py,sha256=JINqSEMFoNpptE4f3h6ZzTYW1rBx90KkaoQzltSg-No,4692
-tdcrpy-2.4.0.dist-info/licenses/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
-tdcrpy-2.4.0.dist-info/METADATA,sha256=gjwfho2j7db0Q52y3Lg79Y9q1r2sg82zl9vS31004m8,45298
-tdcrpy-2.4.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-tdcrpy-2.4.0.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
-tdcrpy-2.4.0.dist-info/RECORD,,
+tdcrpy-2.15.8.dist-info/licenses/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
+tdcrpy-2.15.8.dist-info/METADATA,sha256=G68HRdhNUqMMynusKChlR44rsKGNXoD7qFWHo-qisY8,45363
+tdcrpy-2.15.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tdcrpy-2.15.8.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
+tdcrpy-2.15.8.dist-info/RECORD,,

{tdcrpy-2.4.0.dist-info → tdcrpy-2.15.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any