TDCRPy 2.12.13__tar.gz → 2.14.0__tar.gz

{tdcrpy-2.12.13/TDCRPy.egg-info → tdcrpy-2.14.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: TDCRPy
-Version: 2.12.13
+Version: 2.14.0
 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

{tdcrpy-2.12.13 → tdcrpy-2.14.0/TDCRPy.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: TDCRPy
-Version: 2.12.13
+Version: 2.14.0
 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

{tdcrpy-2.12.13 → tdcrpy-2.14.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import codecs
 import os
 
-VERSION = "2.12.13"
+VERSION = "2.14.0"
 
 DESCRIPTION = "TDCR model"
 
@@ -30,7 +30,7 @@ setup(
     python_requires='>=3.11',
     keywords = ["Python","TDCR","Monte-Carlo","radionuclide","scintillation","counting"],
     classifiers=[
-        "Development Status :: 4 - Beta",
+        "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Science/Research",
         "License :: OSI Approved :: MIT License",
         "Natural Language :: English",

{tdcrpy-2.12.13 → tdcrpy-2.14.0}/tdcrpy/TDCRPy.py

@@ -1108,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 = (0.01, 50), options={'disp': disp, 'maxiter':maxiter})
+    else: r=opt.minimize_scalar(objectFct, args=(TD[0], Rad, pmf_1, N, kB, V), method='bounded', bounds = (0.01, 50), options={'disp': disp, 'maxiter':maxiter})
     L0=r.x
     L=(L0, L0, L0)
     print(f"global free parameter = {L0} keV-1")
@@ -1204,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 = (0.01, 50), 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.01, 50), options={'disp': disp, 'maxiter':maxiter})
     L0=r.x
     L=(L0, L0, L0)
     print(f"global free parameter = {L0} keV-1")

{tdcrpy-2.12.13 → tdcrpy-2.14.0}/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
@@ -121,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()
@@ -2907,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 
 
@@ -2948,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:
         
         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
@@ -2968,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
@@ -2987,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
@@ -2995,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
@@ -3021,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
@@ -3051,9 +3053,9 @@ 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
             
@@ -3207,7 +3209,7 @@ def detectProbabilitiesMC(L, e_quenching, e_quenching2, t1, evenement, extDT, me
     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)/np.mean(mu)) # sample the number of scintillation photons
+        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)

{tdcrpy-2.12.13 → tdcrpy-2.14.0}/tdcrpy/test_randomGen.py

@@ -19,39 +19,35 @@ import numpy as np
 # print(ps0-ps1,ups1)
 # print(abs(ps0-ps1)<2*ups1)
 
-
+import importlib
 import tdcrpy
-tdcrpy.TDCR_model_lib.modifyEffQ("0.2, 0.2, 0.2")
+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 = [9.0, 9.0, 9.0]
-e_q = [0.5]
-tdcrpy.TDCR_model_lib.readParameters(disp=True)
-
-import tdcrpy
+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)]
-print("EffQ = ", Q)
-print("EffQ*L = ", QL)
 
 e_q2 = [0]; t1 = 0; evenement = 1; extDT = 50; measTime = 60000
 
-# S,D,T,_,_,_,_ = detectProbabilities(QL, e_q, e_q2, t1, evenement, extDT, measTime)
 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,
-                                            PMTspace=0, diffP=diffP, effQuantic = Q)
-    # Smc,Dmc,Tmc,_,_,_,_ = detectProbabilitiesMC(L, e_q, e_q2, t1, evenement, extDT, measTime,
-    #                                         PMTspace=0,diffP=diffP)
+    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))