TDCRPy 1.1.6__py3-none-any.whl → 1.3.0__py3-none-any.whl

{TDCRPy-1.1.6.dist-info → TDCRPy-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TDCRPy
-Version: 1.1.6
+Version: 1.3.0
 Summary: TDCR model
 Home-page: https://github.com/RomainCoulon/TDCRPy
 Author: RomainCoulon (Romain Coulon)
@@ -25,6 +25,7 @@ Requires-Dist: setuptools
 Requires-Dist: scipy
 Requires-Dist: configparser
 Requires-Dist: importlib.resources
+Requires-Dist: matplotlib
 
 # TDCRPy
 

{TDCRPy-1.1.6.dist-info → TDCRPy-1.3.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-tdcrpy/TDCRPy.py,sha256=1kG-hjft18Tp-IsRwebnBDdM1sgHqySvx7uDRNU8b9M,33821
-tdcrpy/TDCR_model_lib.py,sha256=QUMmKkUQxmY02xXoDe8b2iGBiMhFU35g7H1xcqUjBCo,64456
+tdcrpy/TDCRPy.py,sha256=ahqrcIyi9ZQ89ZWqfBBilq0Y66xyYt0OIZ5x6C9Mo1g,50044
+tdcrpy/TDCR_model_lib.py,sha256=eWD4jp8Bh1ytRJmzCNkJlbco4aQOIN1ZB3iWYlutxo8,67711
 tdcrpy/TDCRoptimize.py,sha256=ab1EzTNm2HALwKopitwX0BAS8v0pEgAXnye4NOUBazc,3132
 tdcrpy/__init__.py,sha256=pxZ5gMTFSEzeGQLzeRjy-Imu7bZIfhg9eqloOq5FTM4,130
-tdcrpy/config.toml,sha256=9cIERT8yqA0M-JH8AZJbIjlZj5KFZRrjG673sdi5dYM,1464
+tdcrpy/config.toml,sha256=P46cM2uvxD5NgcVK0J6zE2kFnh5AmAww5CMgxgtWCKE,1541
 tdcrpy/MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_C-14.txt,sha256=lio7tle1TdTU3kxunCYyyFKCLYM35uqQh2kRtIZkGQo,41268
 tdcrpy/MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_Ca-45.txt,sha256=-2O4JbuyqHqVa_WglC3BQyADlNIwNlFQwslsGAtFNvc,41227
 tdcrpy/MCNP-MATRIX/Spectra_for_analytical_model/dep_spectrum_H-3.txt,sha256=LaiH6eD0gxEoCRVcLPkPmrXB-1fQif8kxVbmLNMJHlo,41274
@@ -60,8 +60,8 @@ tdcrpy/docs/_build/html/source/modules.html,sha256=gJrhuEaMQHkYGewGHPWGmgVsPgVV6
 tdcrpy/docs/_build/html/source/tdcrpy.html,sha256=VZV_LFdrCCIvYBXzsZE9mZx8iGa7ZjhEsXtE8BqqU9g,90373
 tdcrpy/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tdcrpy/test/test_tdcrpy.py,sha256=dWZpfvarkr8lr_K_zUakt2AOcF0FfCOjBOQPl4vnTWc,4116
-TDCRPy-1.1.6.dist-info/LICENCE.md,sha256=fuYzrZRiOAjJBzA1tsGQwojCgGROArb2Ec48GDTjlWM,1086
-TDCRPy-1.1.6.dist-info/METADATA,sha256=XVfl-723xPwL8RQ__Ptz9mOXuXy-let2wHyl36A7bNk,15902
-TDCRPy-1.1.6.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
-TDCRPy-1.1.6.dist-info/top_level.txt,sha256=VgPJa9YJ7fi8wrr9qDJPLhu3tK1BcFRIP6Ib4r3BEfs,7
-TDCRPy-1.1.6.dist-info/RECORD,,
+TDCRPy-1.3.0.dist-info/LICENCE.md,sha256=fuYzrZRiOAjJBzA1tsGQwojCgGROArb2Ec48GDTjlWM,1086
+TDCRPy-1.3.0.dist-info/METADATA,sha256=OBMFgLB6kxsar_wlEWzthz3J0VqV7760cwyxqurFmGY,15929
+TDCRPy-1.3.0.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
+TDCRPy-1.3.0.dist-info/top_level.txt,sha256=VgPJa9YJ7fi8wrr9qDJPLhu3tK1BcFRIP6Ib4r3BEfs,7
+TDCRPy-1.3.0.dist-info/RECORD,,

tdcrpy/TDCRPy.py

@@ -10,12 +10,14 @@ Bureau International des Poids et Mesures
 
 ## IMPORT PYTHON MODULES
 import tdcrpy.TDCR_model_lib as tl
+# import TDCR_model_lib as tl
 import importlib.resources
 import configparser
 import numpy as np
 from tqdm import tqdm
+from importlib.resources import files
 
-def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=False, barp=False):
+def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=False, barp=False, uncData=False):
     """
     This is the main function of the TDCRPy package running the Monte-Carlo Triple-to-Double Coincidence Ratio model.
     The computation is made for a given solution containing a radionuclide (or a mixture of radionuclides), a given volume of scintillator V and a given Birks constant kB. 
@@ -25,6 +27,8 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
        --> In mode="eff", it calculates the efficiency of the TDCR system as a function of a value (triplet) of free parameter(s) L, the measurement data is not used;
        
        --> In mode="res", it calculates the residual of the TDCR model parametrized by a value (or triplet) of free parameter(s) L and the measurement data TD, TAB, TBC, TAC.
+       
+       --> In mode="dis", the distributions of coincidence probability are retruned
     
     also, two configuration can be set:
        
@@ -67,13 +71,15 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
     V : float
         volume of the scintillator in ml.
     mode : string
-        "res" to return the residual, "eff" to return efficiencies.
+        "res" to return the residual, "eff" to return efficiencies, "dis" to resturn distributions.
     mode2 : string
         "sym" for symetrical model, "asym" for symetrical model.
     Display : Boolean, optional
         "True" to display details on the decay sampling. The default is False.
     barp : Boolean, optional
-        "True" to display the calculation progress. The default is True.
+        "True" to display the calculation progress. The default is False.
+    uncData : Boolean, optional
+        "True" to propagate uncertainty from decay data. The default is False.
     
     Returns
     -------
@@ -94,9 +100,10 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
     """
     if barp: tl.display_header()
     config = configparser.ConfigParser()
-    with importlib.resources.path('tdcrpy', 'config.toml') as data_path:
-        file_conf = data_path       
+    with importlib.resources.as_file(files('tdcrpy').joinpath('config.toml')) as data_path:
+        file_conf = data_path           
     config.read(file_conf)
+    tau=config["Inputs"].getfloat("tau")
     Y=config["Inputs"].getboolean("Y")
     radListPureBeta=config["Inputs"].get("radListPureBeta")
     radListPureBeta=radListPureBeta.replace(" ","")
@@ -145,6 +152,8 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
         DaughterVec = []       # Daughters -- indice 0
         Pdaughter = []         # Probabiblity related to daughters -- indice 1
         Transition_prob_sum = []
+        u_prob_trans = []        # uncertainty of the probabilities for each transition -- indice 10
+        trans_halfLife = []      # half life of the transition
     
         for rad_i in Rad:
             out_PenNuc = tl.readPenNuc2(rad_i)
@@ -163,7 +172,10 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             DaughterVec.append(out_PenNuc[0])    # Daughters -- indice 0
             Pdaughter.append(out_PenNuc[1])      # Probabiblity related to daughters -- indice 1
             Transition_prob_sum.append(out_PenNuc[14])
-    
+            u_prob_trans.append(out_PenNuc[16])
+            trans_halfLife.append(out_PenNuc[15])
+        # print("\n",trans_halfLife)
+        
         efficiency_S = []
         efficiency_D = []
         efficiency_T = []
@@ -246,11 +258,24 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             if Display: print("\t Subsequent isomeric transition(s)")                       # finish with the mother / now with the daughter
             while levelOftheDaughter > 0:                                                # Go on the loop while the daughter nucleus is a its fundamental level (energy 0)
                 i_level = levelNumber[index_rad][iDaughter].index([levelOftheDaughter])  # Find the position in the daughter level vector
+                print(trans_halfLife)
+                # test whether the decay occurs within the coincidence resolving time or not
+                if np.random.exponential(trans_halfLife[index_rad][iDaughter][i_branch][i_level], size=1)[0] > tau: splitEvent = True
+                else: splitEvent = False
+                                
                 if transitionType[index_rad][iDaughter][i_level] != []:
                     #====================================================================
                     # Sampling of the transition in energy levels of the daughter nucleus
                     #====================================================================
-                    probability_tran = tl.normalise(prob_trans[index_rad][iDaughter][i_level])   # normaliser la proba de transition 
+                    if uncData:
+                        prob_trans_s=[]
+                        for ipt, xpt in enumerate(prob_trans[index_rad][iDaughter][i_level]):
+                            prob_trans_s.append(np.random.normal(xpt, u_prob_trans[index_rad][iDaughter][i_level][ipt], 1)[0])
+                            
+                        probability_tran = tl.normalise(prob_trans_s)   # normaliser la proba de transition
+                    else:
+                        probability_tran = tl.normalise(prob_trans[index_rad][iDaughter][i_level])   # normaliser la proba de transition 
+
                     index_t = tl.sampling(probability_tran)                                      # indice de la transition
                     if Display:
                         print("\t\t Energy of the level = ", levelEnergy[index_rad][iDaughter][i_level][0], " keV")
@@ -319,190 +344,423 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             II. LA RELAXATION ATOMIQUE
             ==========================
             '''
-            daughter_relax = DaughterVec[index_rad][iDaughter]
-            for i_part in range(len(particle_vec)):
-                relaxation = False
-                if "Atom_K" in particle_vec[i_part] or "Atom_L" in particle_vec[i_part] or "Atom_M" in particle_vec[i_part]:
-                    relaxation = True
-                while relaxation:
-                    tf,ef = tl.relaxation_atom(daughter_relax,Rad[index_rad],particle_vec[i_part])
-                    if tf == "XKA":
-                        particle_vec[i_part] = "Atom_L"
-                        particle_vec.append(tf)
-                        energy_vec.append(ef)
-                        relaxation = True
-                    elif tf == "XKB":
-                        particle_vec[i_part] = "Atom_M"
-                        particle_vec.append(tf)
-                        energy_vec.append(ef)
-                        relaxation = False
-                    elif tf == "XL":
-                        particle_vec[i_part] = "Atom_M"
-                        particle_vec.append(tf)
-                        energy_vec.append(ef)
-                        relaxation = False
-                    elif tf == "Auger K":
-                        particle_vec[i_part] = "Atom_L"
-                        particle_vec.append(tf)
-                        energy_vec.append(ef)
+            
+            if splitEvent:
+                particle_vec2=[]
+                energy_vec2=[]
+                
+                daughter_relax = DaughterVec[index_rad][iDaughter]
+                for i_part in range(len(particle_vec)):
+                    relaxation = False
+                    if "Atom_K" in particle_vec[i_part] or "Atom_L" in particle_vec[i_part] or "Atom_M" in particle_vec[i_part]:
                         relaxation = True
-                    elif tf == "Auger L":
-                        particle_vec[i_part] = "Atom_M"
-                        particle_vec.append(tf)
-                        energy_vec.append(ef)
-                        relaxation = False
-                    else:
-                        if Display: print("untermined x or Auger")
-                        relaxation = False
-                    e_sum += ef
-            if Display:
-                print("\t Summary of the atomic relaxation")
+                    while relaxation:
+                        tf,ef = tl.relaxation_atom(daughter_relax,Rad[index_rad],particle_vec[i_part])
+                        if tf == "XKA":
+                            particle_vec[i_part] = "Atom_L"
+                            particle_vec2.append(tf)
+                            energy_vec2.append(ef)
+                            relaxation = True
+                        elif tf == "XKB":
+                            particle_vec[i_part] = "Atom_M"
+                            particle_vec2.append(tf)
+                            energy_vec2.append(ef)
+                            relaxation = False
+                        elif tf == "XL":
+                            particle_vec[i_part] = "Atom_M"
+                            particle_vec2.append(tf)
+                            energy_vec2.append(ef)
+                            relaxation = False
+                        elif tf == "Auger K":
+                            particle_vec[i_part] = "Atom_L"
+                            particle_vec2.append(tf)
+                            energy_vec2.append(ef)
+                            relaxation = True
+                        elif tf == "Auger L":
+                            particle_vec[i_part] = "Atom_M"
+                            particle_vec2.append(tf)
+                            energy_vec2.append(ef)
+                            relaxation = False
+                        else:
+                            if Display: print("untermined x or Auger")
+                            relaxation = False
+                        e_sum += ef
+                if Display:
+                    print("\t Summary of the atomic relaxation (prompt emission)")
+                    for i, p in enumerate(particle_vec2):
+                        if p[:4] != "Atom":
+                            print(f"\t\t energy of {p} = ", round(energy_vec2[i],3), "keV")
+                
+                '''
+                ==========================================================
+                III.a SPECTRES D'EMISSION
+                ==========================================================
+                '''
+                
+                for i, p in enumerate(particle_vec2):
+                    if p == "beta":
+                        e_b,p_b = tl.readBetaShape(rad_i,"beta-",level_before_trans)   # read the data of BetaShape
+                        index_beta_energy = tl.sampling(p_b)                           # sampling energy of beta
+                        particle_vec2[i] = "electron"
+                        energy_vec2[i] = e_b[index_beta_energy]
+        
+                    if p == "beta+":
+                        e_b,p_b = tl.readBetaShape(rad_i,"beta+",level_before_trans)
+                        index_beta_energy = tl.sampling(p_b)
+                        particle_vec2[i] = "positron"
+                        energy_vec[i] = e_b[index_beta_energy]
+                        particle_vec2.append("gamma")
+                        particle_vec2.append("gamma")
+                        energy_vec2.append(511)
+                        energy_vec2.append(511)
+                energy_vec_initial2 = energy_vec2    
+                if Display:
+                    print("\t Summary of emitted particles from the promt atomic relaxation")
+                    for i, p in enumerate(particle_vec2):
+                        if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec2[i],3), "keV")
+                
+     
                 for i, p in enumerate(particle_vec):
-                    if p[:4] != "Atom":
-                        print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
-    
-            '''
-            ==========================================================
-            III.a SPECTRES D'EMISSION
-            ==========================================================
-            '''
-            # for i, p in enumerate(particle_vec):
-            #     if p == "beta":
-            #         e_b,p_b = tl.readBetaShape(rad_i,"beta-",level_before_trans)   # read the data of BetaShape
-            #         index_beta_energy = tl.sampling(p_b)                           # sampling energy of beta
-            #         particle_vec[i] = "electron"
-            #         energy_vec[i] = e_b[index_beta_energy]
-            #         energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
-    
-            #     if p == "beta+":
-            #         e_b,p_b = tl.readBetaShape(rad_i,"beta+",level_before_trans)
-            #         index_beta_energy = tl.sampling(p_b)
-            #         particle_vec[i] = "positron"
-            #         energy_vec[i] = e_b[index_beta_energy]
-            #         energy_vec[i] = tl.energie_dep_beta(energy_vec[i]) # treated as beta-
-            #         particle_vec.append("gamma")
-            #         particle_vec.append("gamma")
-            #         energy_vec.append(511)
-            #         energy_vec.append(511)
-    
-            #     if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
-            #         energy_vec[i] = tl.energie_dep_gamma(energy_vec[i],v=V)          # sampling energy free from photon
-            #         particle_vec[i] = "electron"
-            #     if p == "Auger K" or p == "Auger L":
-            #         particle_vec[i] = "electron"
-            #         energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
-            # if Display: print("\t Summary of the final charged particles")
-            # if Display: print("\t\t particles : ", particle_vec)
-            # if Display: print("\t\t energy after interaction : ", energy_vec, "keV")
- 
-            for i, p in enumerate(particle_vec):
-                if p == "beta":
-                    e_b,p_b = tl.readBetaShape(rad_i,"beta-",level_before_trans)   # read the data of BetaShape
-                    index_beta_energy = tl.sampling(p_b)                           # sampling energy of beta
-                    particle_vec[i] = "electron"
-                    energy_vec[i] = e_b[index_beta_energy]
+                    if p == "beta":
+                        e_b,p_b = tl.readBetaShape(rad_i,"beta-",level_before_trans)   # read the data of BetaShape
+                        index_beta_energy = tl.sampling(p_b)                           # sampling energy of beta
+                        particle_vec[i] = "electron"
+                        energy_vec[i] = e_b[index_beta_energy]
+        
+                    if p == "beta+":
+                        e_b,p_b = tl.readBetaShape(rad_i,"beta+",level_before_trans)
+                        index_beta_energy = tl.sampling(p_b)
+                        particle_vec[i] = "positron"
+                        energy_vec[i] = e_b[index_beta_energy]
+                        particle_vec.append("gamma")
+                        particle_vec.append("gamma")
+                        energy_vec.append(511)
+                        energy_vec.append(511)
+                energy_vec_initial = energy_vec    
+                if Display:
+                    print("\t Summary of emitted particles from the delayed nuclear relaxation")
+                    for i, p in enumerate(particle_vec):
+                        if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
     
-                if p == "beta+":
-                    e_b,p_b = tl.readBetaShape(rad_i,"beta+",level_before_trans)
-                    index_beta_energy = tl.sampling(p_b)
-                    particle_vec[i] = "positron"
-                    energy_vec[i] = e_b[index_beta_energy]
-                    particle_vec.append("gamma")
-                    particle_vec.append("gamma")
-                    energy_vec.append(511)
-                    energy_vec.append(511)
-            energy_vec_initial = energy_vec    
-            if Display:
-                print("\t Summary of emitted particles")
+     
+                '''
+                ==========================================================
+                III.b INTERACTION RAYONNEMENT/MATIERE
+                ==========================================================
+                '''
+                
+                for i, p in enumerate(particle_vec2):
+                    if p == "electron":
+                        energy_vec2[i] = tl.energie_dep_beta(energy_vec2[i])
+        
+                    if p == "beta+":
+                        energy_vec2[i] = tl.energie_dep_beta(energy_vec2[i])
+        
+                    if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
+                        energy_vec2[i] = tl.energie_dep_gamma(energy_vec2[i],v=V)          # sampling energy free from photon
+                        particle_vec2[i] = "electron"
+                        
+                    if p == "Auger K" or p == "Auger L":
+                        particle_vec2[i] = "electron"
+                        energy_vec2[i] = tl.energie_dep_beta(energy_vec2[i])
+                        
+                if Display:
+                    print("\t Summary of the energy deposited by charged particles by the prompt atomic relaxation")
+                    for i, p  in enumerate(particle_vec2):
+                        if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec2[i],3), "keV")
+                
+                
                 for i, p in enumerate(particle_vec):
-                    if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
-
- 
-            '''
-            ==========================================================
-            III.b INTERACTION RAYONNEMENT/MATIERE
-            ==========================================================
-            '''
-            for i, p in enumerate(particle_vec):
-                if p == "electron":
-                    energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
-    
-                if p == "beta+":
-                    energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
-    
-                if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
-                    energy_vec[i] = tl.energie_dep_gamma(energy_vec[i],v=V)          # sampling energy free from photon
-                    particle_vec[i] = "electron"
+                    if p == "electron":
+                        energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+        
+                    if p == "beta+":
+                        energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+        
+                    if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
+                        energy_vec[i] = tl.energie_dep_gamma(energy_vec[i],v=V)          # sampling energy free from photon
+                        particle_vec[i] = "electron"
+                        
+                    if p == "Auger K" or p == "Auger L":
+                        particle_vec[i] = "electron"
+                        energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+                        
+                if Display:
+                    print("\t Summary of the energy deposited by charged particles from the delayed nuclear relaxation")
+                    for i, p  in enumerate(particle_vec):
+                        if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
+                
+                '''
+                ====================
+                IV. LA SCINTILLATION
+                Calculation of the scintillation quenching with the Birks Model
+                ====================
+                '''
+                if Display: print("\t Summary of the estimation of quenched energies by the prompt atomic relaxation")
+                e_quenching2=[]
+                for i, p in enumerate(particle_vec2):
+                    if p == "alpha":
+                        energy_vec2[i] = tl.Em_a(energy_vec2[i],kB,nE_alpha)
+                        e_quenching2.append(energy_vec2[i])
+                    elif p == "electron" or p == "positron":
+                        energy_vec2[i] = tl.Em_e(energy_vec_initial2[i]*1e3,energy_vec2[i]*1e3,kB*1e3,nE_electron)*1e-3
+                        e_quenching2.append(energy_vec2[i])
+                    else:
+                        e_quenching2.append(0)
+                if Display: print("\t\t Birks constant = ", kB, ' cm/keV')
+                if Display:
+                    for i, p in enumerate(particle_vec2):
+                        if p[:4] != "Atom": print(f"\t\t quenched energy of {p} = ", round(e_quenching2[i],3), "keV")
+                
+                
+                # changer l'intégration E_i - E_d à E_i
+                if Display: print("\t Summary of the estimation of quenched energies from the delayed nuclear relaxation")
+                e_quenching=[]
+                for i, p in enumerate(particle_vec):
+                    if p == "alpha":
+                        energy_vec[i] = tl.Em_a(energy_vec[i],kB,nE_alpha)
+                        e_quenching.append(energy_vec[i])
+                    elif p == "electron" or p == "positron":
+                        energy_vec[i] = tl.Em_e(energy_vec_initial[i]*1e3,energy_vec[i]*1e3,kB*1e3,nE_electron)*1e-3
+                        e_quenching.append(energy_vec[i])
+                    else:
+                        e_quenching.append(0)
+                if Display: print("\t\t Birks constant = ", kB, ' cm/keV')
+                if Display:
+                    for i, p in enumerate(particle_vec):
+                        if p[:4] != "Atom": print(f"\t\t quenched energy of {p} = ", round(e_quenching[i],3), "keV")
+        
+                '''
+                ====================
+                V. LE MESURE TDCR
+                ====================
+                '''
+                
+                if mode2=="sym":
+                    p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+                    p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+                    efficiency_S.append(p_single)
+                    efficiency_T.append(p_single**3)
+                    efficiency_D.append(3*(p_single)**2-2*efficiency_T[-1])
+                    if Display: print("\t Summary of TDCR measurement (prompt)")
+                    if Display: print("\t\t Free parameter = ", L, "keV-1")
+                    if Display: print("\t\t Efficiency of single events = ", round(efficiency_S[-1],5))
+                    if Display: print("\t\t Efficiency of double events = ", round(efficiency_D[-1],5))
+                    if Display: print("\t\t Efficiency of triple events = ", round(efficiency_T[-1],5))
+                elif mode2=="asym":
+                    pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching2))/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_quenching2))/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_quenching2))/3) # probability to have 0 electrons in a PMT
+                    pC_single = 1-pC_nosingle                                    # probability to have at least 1 electrons in a PMT
                     
-                if p == "Auger K" or p == "Auger L":
-                    particle_vec[i] = "electron"
-                    energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+                    efficiency_AB.append(pA_single*pB_single)
+                    efficiency_BC.append(pB_single*pC_single)
+                    efficiency_AC.append(pA_single*pC_single)
+                    efficiency_T.append(pA_single*pB_single*pC_single)
+                    efficiency_D.append(efficiency_AB[-1]+efficiency_BC[-1]+efficiency_AC[-1]-2*efficiency_T[-1])
+                    efficiency_S.append(pA_single+pB_single+pC_single-efficiency_D[-1]-efficiency_T[-1])
+                    if Display: print("\t Summary of TDCR measurement (prompt)")
+                    if Display: print("\t\t Free parameter PMT A: ", L[0], "keV-1")
+                    if Display: print("\t\t Free parameter PMT B: ", L[1], "keV-1")
+                    if Display: print("\t\t Free parameter PMT C: ", L[2], "keV-1")
+                    if Display: print("\t\t Efficiency of single events: ", round(efficiency_S[-1],5))
+                    if Display: print("\t\t Efficiency of double events: ", round(efficiency_D[-1],5))
+                    if Display: print("\t\t Efficiency of triple events: ", round(efficiency_T[-1],5))
+                
+                
+                if mode2=="sym":
+                    p_nosingle = np.exp(-L*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
+                    efficiency_S.append(p_single)
+                    efficiency_T.append(p_single**3)
+                    efficiency_D.append(3*(p_single)**2-2*efficiency_T[-1])
+                    if Display: print("\t Summary of TDCR measurement (delayed)")
+                    if Display: print("\t\t Free parameter = ", L, "keV-1")
+                    if Display: print("\t\t Efficiency of single events = ", round(efficiency_S[-1],5))
+                    if Display: print("\t\t Efficiency of double events = ", round(efficiency_D[-1],5))
+                    if Display: print("\t\t Efficiency of triple events = ", round(efficiency_T[-1],5))
+                elif mode2=="asym":
+                    pA_nosingle = np.exp(-L[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_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_single = 1-pC_nosingle                                    # probability to have at least 1 electrons in a PMT
                     
-            if Display:
-                print("\t Summary of the energy deposited by charged particles")
-                for i, p  in enumerate(particle_vec):
-                    if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
-            
-            '''
-            ====================
-            IV. LA SCINTILLATION
-            Calculation of the scintillation quenching with the Birks Model
-            ====================
-            '''
-            # changer l'intégration E_i - E_d à E_i
-            if Display: print("\t Summary of the estimation of quenched energies")
-            e_quenching=[]
-            for i, p in enumerate(particle_vec):
-                if p == "alpha":
-                    energy_vec[i] = tl.Em_a(energy_vec[i],kB,nE_alpha)
-                    e_quenching.append(energy_vec[i])
-                elif p == "electron" or p == "positron":
-                    energy_vec[i] = tl.Em_e(energy_vec_initial[i]*1e3,energy_vec[i]*1e3,kB*1e3,nE_electron)*1e-3
-                    e_quenching.append(energy_vec[i])
-                else:
-                    e_quenching.append(0)
-            if Display: print("\t\t Birks constant = ", kB, ' cm/keV')
-            if Display:
+                    efficiency_AB.append(pA_single*pB_single)
+                    efficiency_BC.append(pB_single*pC_single)
+                    efficiency_AC.append(pA_single*pC_single)
+                    efficiency_T.append(pA_single*pB_single*pC_single)
+                    efficiency_D.append(efficiency_AB[-1]+efficiency_BC[-1]+efficiency_AC[-1]-2*efficiency_T[-1])
+                    efficiency_S.append(pA_single+pB_single+pC_single-efficiency_D[-1]-efficiency_T[-1])
+                    if Display: print("\t Summary of TDCR measurement (delayed)")
+                    if Display: print("\t\t Free parameter PMT A: ", L[0], "keV-1")
+                    if Display: print("\t\t Free parameter PMT B: ", L[1], "keV-1")
+                    if Display: print("\t\t Free parameter PMT C: ", L[2], "keV-1")
+                    if Display: print("\t\t Efficiency of single events: ", round(efficiency_S[-1],5))
+                    if Display: print("\t\t Efficiency of double events: ", round(efficiency_D[-1],5))
+                    if Display: print("\t\t Efficiency of triple events: ", round(efficiency_T[-1],5))
+                
+            else: # One decay event into the resolving time
+                
+                daughter_relax = DaughterVec[index_rad][iDaughter]
+                for i_part in range(len(particle_vec)):
+                    relaxation = False
+                    if "Atom_K" in particle_vec[i_part] or "Atom_L" in particle_vec[i_part] or "Atom_M" in particle_vec[i_part]:
+                        relaxation = True
+                    while relaxation:
+                        tf,ef = tl.relaxation_atom(daughter_relax,Rad[index_rad],particle_vec[i_part])
+                        if tf == "XKA":
+                            particle_vec[i_part] = "Atom_L"
+                            particle_vec.append(tf)
+                            energy_vec.append(ef)
+                            relaxation = True
+                        elif tf == "XKB":
+                            particle_vec[i_part] = "Atom_M"
+                            particle_vec.append(tf)
+                            energy_vec.append(ef)
+                            relaxation = False
+                        elif tf == "XL":
+                            particle_vec[i_part] = "Atom_M"
+                            particle_vec.append(tf)
+                            energy_vec.append(ef)
+                            relaxation = False
+                        elif tf == "Auger K":
+                            particle_vec[i_part] = "Atom_L"
+                            particle_vec.append(tf)
+                            energy_vec.append(ef)
+                            relaxation = True
+                        elif tf == "Auger L":
+                            particle_vec[i_part] = "Atom_M"
+                            particle_vec.append(tf)
+                            energy_vec.append(ef)
+                            relaxation = False
+                        else:
+                            if Display: print("untermined x or Auger")
+                            relaxation = False
+                        e_sum += ef
+                if Display:
+                    print("\t Summary of the atomic relaxation")
+                    for i, p in enumerate(particle_vec):
+                        if p[:4] != "Atom":
+                            print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
+    
+                '''
+                ==========================================================
+                III.a SPECTRES D'EMISSION
+                ==========================================================
+                '''
+     
                 for i, p in enumerate(particle_vec):
-                    if p[:4] != "Atom": print(f"\t\t quenched energy of {p} = ", round(e_quenching[i],3), "keV")
+                    if p == "beta":
+                        e_b,p_b = tl.readBetaShape(rad_i,"beta-",level_before_trans)   # read the data of BetaShape
+                        index_beta_energy = tl.sampling(p_b)                           # sampling energy of beta
+                        particle_vec[i] = "electron"
+                        energy_vec[i] = e_b[index_beta_energy]
+        
+                    if p == "beta+":
+                        e_b,p_b = tl.readBetaShape(rad_i,"beta+",level_before_trans)
+                        index_beta_energy = tl.sampling(p_b)
+                        particle_vec[i] = "positron"
+                        energy_vec[i] = e_b[index_beta_energy]
+                        particle_vec.append("gamma")
+                        particle_vec.append("gamma")
+                        energy_vec.append(511)
+                        energy_vec.append(511)
+                energy_vec_initial = energy_vec    
+                if Display:
+                    print("\t Summary of emitted particles")
+                    for i, p in enumerate(particle_vec):
+                        if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
     
-            '''
-            ====================
-            V. LE MESURE TDCR
-            ====================
-            '''
-            if mode2=="sym":
-                p_nosingle = np.exp(-L*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
-                efficiency_S.append(p_single)
-                efficiency_T.append(p_single**3)
-                efficiency_D.append(3*(p_single)**2-2*efficiency_T[-1])
-                if Display: print("\t Summary of TDCR measurement")
-                if Display: print("\t\t Free parameter = ", L, "keV-1")
-                if Display: print("\t\t Efficiency of single events = ", round(efficiency_S[-1],5))
-                if Display: print("\t\t Efficiency of double events = ", round(efficiency_D[-1],5))
-                if Display: print("\t\t Efficiency of triple events = ", round(efficiency_T[-1],5))
-            elif mode2=="asym":
-                pA_nosingle = np.exp(-L[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_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_single = 1-pC_nosingle                                    # probability to have at least 1 electrons in a PMT
+     
+                '''
+                ==========================================================
+                III.b INTERACTION RAYONNEMENT/MATIERE
+                ==========================================================
+                '''
+                for i, p in enumerate(particle_vec):
+                    if p == "electron":
+                        energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+        
+                    if p == "beta+":
+                        energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+        
+                    if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
+                        energy_vec[i] = tl.energie_dep_gamma(energy_vec[i],v=V)          # sampling energy free from photon
+                        particle_vec[i] = "electron"
+                        
+                    if p == "Auger K" or p == "Auger L":
+                        particle_vec[i] = "electron"
+                        energy_vec[i] = tl.energie_dep_beta(energy_vec[i])
+                        
+                if Display:
+                    print("\t Summary of the energy deposited by charged particles")
+                    for i, p  in enumerate(particle_vec):
+                        if p[:4] != "Atom": print(f"\t\t energy of {p} = ", round(energy_vec[i],3), "keV")
                 
-                efficiency_AB.append(pA_single*pB_single)
-                efficiency_BC.append(pB_single*pC_single)
-                efficiency_AC.append(pA_single*pC_single)
-                efficiency_T.append(pA_single*pB_single*pC_single)
-                efficiency_D.append(efficiency_AB[-1]+efficiency_BC[-1]+efficiency_AC[-1]-2*efficiency_T[-1])
-                efficiency_S.append(pA_single+pB_single+pC_single-efficiency_D[-1]-efficiency_T[-1])
-                if Display: print("\t Summary of TDCR measurement")
-                if Display: print("\t\t Free parameter PMT A: ", L[0], "keV-1")
-                if Display: print("\t\t Free parameter PMT B: ", L[1], "keV-1")
-                if Display: print("\t\t Free parameter PMT C: ", L[2], "keV-1")
-                if Display: print("\t\t Efficiency of single events: ", round(efficiency_S[-1],5))
-                if Display: print("\t\t Efficiency of double events: ", round(efficiency_D[-1],5))
-                if Display: print("\t\t Efficiency of triple events: ", round(efficiency_T[-1],5))
+                '''
+                ====================
+                IV. LA SCINTILLATION
+                Calculation of the scintillation quenching with the Birks Model
+                ====================
+                '''
+                # changer l'intégration E_i - E_d à E_i
+                if Display: print("\t Summary of the estimation of quenched energies")
+                e_quenching=[]
+                for i, p in enumerate(particle_vec):
+                    if p == "alpha":
+                        energy_vec[i] = tl.Em_a(energy_vec[i],kB,nE_alpha)
+                        e_quenching.append(energy_vec[i])
+                    elif p == "electron" or p == "positron":
+                        energy_vec[i] = tl.Em_e(energy_vec_initial[i]*1e3,energy_vec[i]*1e3,kB*1e3,nE_electron)*1e-3
+                        e_quenching.append(energy_vec[i])
+                    else:
+                        e_quenching.append(0)
+                if Display: print("\t\t Birks constant = ", kB, ' cm/keV')
+                if Display:
+                    for i, p in enumerate(particle_vec):
+                        if p[:4] != "Atom": print(f"\t\t quenched energy of {p} = ", round(e_quenching[i],3), "keV")
+        
+                '''
+                ====================
+                V. LE MESURE TDCR
+                ====================
+                '''
+                if mode2=="sym":
+                    p_nosingle = np.exp(-L*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
+                    efficiency_S.append(p_single)
+                    efficiency_T.append(p_single**3)
+                    efficiency_D.append(3*(p_single)**2-2*efficiency_T[-1])
+                    if Display: print("\t Summary of TDCR measurement")
+                    if Display: print("\t\t Free parameter = ", L, "keV-1")
+                    if Display: print("\t\t Efficiency of single events = ", round(efficiency_S[-1],5))
+                    if Display: print("\t\t Efficiency of double events = ", round(efficiency_D[-1],5))
+                    if Display: print("\t\t Efficiency of triple events = ", round(efficiency_T[-1],5))
+                elif mode2=="asym":
+                    pA_nosingle = np.exp(-L[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_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_single = 1-pC_nosingle                                    # probability to have at least 1 electrons in a PMT
+                    
+                    efficiency_AB.append(pA_single*pB_single)
+                    efficiency_BC.append(pB_single*pC_single)
+                    efficiency_AC.append(pA_single*pC_single)
+                    efficiency_T.append(pA_single*pB_single*pC_single)
+                    efficiency_D.append(efficiency_AB[-1]+efficiency_BC[-1]+efficiency_AC[-1]-2*efficiency_T[-1])
+                    efficiency_S.append(pA_single+pB_single+pC_single-efficiency_D[-1]-efficiency_T[-1])
+                    if Display: print("\t Summary of TDCR measurement")
+                    if Display: print("\t\t Free parameter PMT A: ", L[0], "keV-1")
+                    if Display: print("\t\t Free parameter PMT B: ", L[1], "keV-1")
+                    if Display: print("\t\t Free parameter PMT C: ", L[2], "keV-1")
+                    if Display: print("\t\t Efficiency of single events: ", round(efficiency_S[-1],5))
+                    if Display: print("\t\t Efficiency of double events: ", round(efficiency_D[-1],5))
+                    if Display: print("\t\t Efficiency of triple events: ", round(efficiency_T[-1],5))
                 
         '''
         ====================
@@ -532,27 +790,12 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             TBCmodel = mean_efficiency_T/mean_efficiency_BC
             TACmodel = mean_efficiency_T/mean_efficiency_AC
             
-            
-        #    x = np.arange(np.mean(efficiency_T),1.001,0.001)
-        #    plt.figure("efficiency distribution")
-        #    plt.clf()
-        #    plt.hist(np.asarray(efficiency_D),bins=x,label="Efficiency of double coincidences")[0]
-        #    plt.hist(np.asarray(efficiency_T),bins=x,label="Efficiency of triple coincidences")[0]
-        #    plt.xlabel("Efficiency", fontsize = 14)
-        #    plt.ylabel(r"Number of counts", fontsize = 14)
-        #    plt.legend(fontsize = 12)
-        #    plt.savefig('Effdistribution.png')
-        
-        #    x = np.arange(np.mean(tdcr),1.001,0.001)
-        #    plt.figure("TDCR distribution")
-        #    plt.clf()
-        #    plt.hist(np.asarray(tdcr),bins=x,label="Calculated TDCR")[0]
-        #    plt.plot(x,st.norm.pdf(x, TDCR_measure, u_TDCR_measure),label="measured TDCR")[0]
-        #    plt.xlabel("Efficiency", fontsize = 14)
-        #    plt.ylabel(r"Number of counts", fontsize = 14)
-        #    plt.legend(fontsize = 12)
-        #    plt.savefig('TDCRdistribution.png')
         
+        '''
+        ======================
+        VI. RETURN THE RESULTS
+        ======================
+        '''
         if mode2=="sym":
             res=(TDCR_calcul-TD)**2
         elif mode2=="asym":
@@ -565,4 +808,25 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                 print("Warning. too low number of MC trials - inaccurate estimation")
                 return mean_efficiency_S, 1, mean_efficiency_D, 1, mean_efficiency_T, 1
             else:
-                return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T
+                return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T
+        if mode =="dis":
+            return efficiency_S, efficiency_D, efficiency_T
+
+
+
+# L = (1, 1, 1)
+# TD = 0.977667386529166
+# TAB = 0.992232838598821
+# TBC = 0.992343419459002
+# TAC = 0.99275350064608
+# Rad="Co-60"
+# pmf_1="1"
+# N = 10
+# kB =1.0e-5
+# V = 10
+# mode = "dis"
+# mode2 = "asym"
+
+
+# S,D,T = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=True, barp=False, uncData=False)
+# # tl.display_distrib(S,D,T)

tdcrpy/TDCR_model_lib.py

@@ -13,6 +13,7 @@ Bureau International des Poids et Mesures
 """
 
 import importlib.resources
+from importlib.resources import files
 import pkg_resources
 import configparser
 import numpy as np
@@ -21,14 +22,16 @@ import time
 import re
 import os
 import scipy.interpolate as  interp
+import matplotlib.pyplot as plt
 
 """
 ======= Import ressource data =======
 """
 
 # import advanced configuration data
+
 config = configparser.ConfigParser()
-with importlib.resources.path('tdcrpy', 'config.toml') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('config.toml')) as data_path:
     file_conf = data_path       
 config.read(file_conf)
 RHO = config["Inputs"].getfloat("density")
@@ -38,22 +41,26 @@ depthSpline = config["Inputs"].getint("depthSpline")
 Einterp = config["Inputs"].getfloat("Einterp")
 
 # import PenNuc data
-with importlib.resources.path('tdcrpy', 'decayData') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('decayData')) as data_path:
+#with importlib.resources.path('tdcrpy', 'decayData') as data_path:
     file_pennuc = data_path / "All-nuclides_PenNuc.zip"
 z_PenNuc = zf.ZipFile(file_pennuc)
 
 # import BetaShape data
-with importlib.resources.path('tdcrpy', 'decayData') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('decayData')) as data_path:
+#with importlib.resources.path('tdcrpy', 'decayData') as data_path:
     file_betashape = data_path / "All-nuclides_BetaShape.zip"
 z_betashape = zf.ZipFile(file_betashape)
 
 # import ENSDF data
-with importlib.resources.path('tdcrpy', 'decayData') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('decayData')) as data_path:
+#with importlib.resources.path('tdcrpy', 'decayData') as data_path:
     file_ensdf = data_path / 'All-nuclides_Ensdf.zip'
 z_ensdf = zf.ZipFile(file_ensdf)
 
 # import photon interaction data (MCNP6 calculation) 
-with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('MCNP-MATRIX')) as data_path:
+#with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
     fp1 = data_path / 'matrice/fichier/matrice_10ml-photon_1_200k.txt'          #gamma-10ml-1-200keV-niveau 0
     fp2 = data_path / 'matrice/fichier/matrice_10ml-photon_200_2000k.txt'       #gamma-10ml-200-2000keV-niveau 1
     fp3 = data_path / 'matrice/fichier/matrice_10ml-photon_2000_10000k.txt'     #gamma-10ml-2000-10000keV-niveau 2
@@ -63,7 +70,8 @@ with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
     fe = data_path / 'matrice/fichier/E_depose.txt'
 
 # import electron interaction data (MCNP6 calculation) 
-with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('MCNP-MATRIX')) as data_path:
+#with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
     fe1 = data_path / 'matrice/fichier/matrice_10ml-beta-_1_200k.txt' # electron-10ml-1-200keV-niveau 0
     fe2 = data_path / 'matrice/fichier/matrice_10ml-beta-_200_2000k.txt' # electron-10ml-200-2000keV-niveau 1
     fe3 = data_path / 'matrice/fichier/matrice_10ml-beta-_2000_10000k.txt' # electron-10ml-2000-10000keV-niveau 2
@@ -72,7 +80,8 @@ with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
     fe = data_path / 'matrice/fichier/E_depose.txt' # electron-10ml-énergie-niveau 'e'   
 
 # import beta spectra calculated for the analytical model (BetaShape + MCNP6 calculation) 
-with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('MCNP-MATRIX')) as data_path:
+#with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
     sH3 = data_path / 'Spectra_for_analytical_model/dep_spectrum_H-3.txt'
     sC14 = data_path / 'Spectra_for_analytical_model/dep_spectrum_C-14.txt'
     sS35 = data_path / 'Spectra_for_analytical_model/dep_spectrum_S-35.txt'
@@ -85,7 +94,8 @@ with importlib.resources.path('tdcrpy', 'MCNP-MATRIX') as data_path:
     sPu241 = data_path / 'Spectra_for_analytical_model/dep_spectrum_Pu-241.txt'
 
 # import stopping power data for electron
-with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('Quenching')) as data_path:
+#with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
     file_TanXia = open(data_path / "TandataUG.txt")
 
 data_TanXia=file_TanXia.read(); file_TanXia.close()
@@ -94,9 +104,10 @@ for i, x in enumerate(data_TanXia):
   if i<len(data_TanXia)-1: data_TanXia_f[i]=float(x)
 
 # import stopping power data for electron for alpha particle (ASTAR data)
-with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('Quenching')) as data_path:
+#with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
     f_alpha = open(data_path / "alpha_toulene.txt")
-
+    
 data_ASTAR = f_alpha.readlines()
 f_alpha.close()
 energy_alph = []
@@ -110,7 +121,8 @@ for i in range(np.size(data_ASTAR)):
 
 # import pre-calculated quenched energy tables
 kB_a = [6e-6, 7e-6, 8e-6, 9e-6, 1e-5, 1.1e-5, 1.2e-5, 1.3e-5, 1.4e-5, 1.5e-5] # cm/MeV
-with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('Quenching')) as data_path:
+#with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
     Ei_alpha_fid = open(data_path / "inputVecteurAlpha.txt")
 Ei_alpha = Ei_alpha_fid.readlines()
 Ei_alpha = Ei_alpha[0].split(" ")
@@ -118,7 +130,8 @@ Ei_alpha = [float(x) for x in Ei_alpha[:-1]]
 
 Em_alpha = []
 for ikB in kB_a:
-    with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
+    with importlib.resources.as_file(files('tdcrpy').joinpath('Quenching')) as data_path:
+    #with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
         tamptxt = "QuenchEnergyAlpha_"+str(ikB)+".txt"
         fid = open(data_path / tamptxt)
     line = fid.readlines()
@@ -127,7 +140,8 @@ for ikB in kB_a:
     Em_alpha.append(line)
 
 kB_e = [0.006, 0.007, 0.008, 0.009, 0.010, 0.011, 0.012, 0.013, 0.014, 0.015] # cm/MeV
-with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
+with importlib.resources.as_file(files('tdcrpy').joinpath('Quenching')) as data_path:
+#with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
     Ei_electron_fid = open(data_path / "inputVecteurElectron.txt")
 Ei_electron = Ei_electron_fid.readlines()
 Ei_electron = Ei_electron[0].split(" ")
@@ -135,7 +149,8 @@ Ei_electron = [float(x) for x in Ei_electron[:-1]]
 
 Em_electron = []
 for ikB in kB_e:
-    with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
+    with importlib.resources.as_file(files('tdcrpy').joinpath('Quenching')) as data_path:
+    #with importlib.resources.path('tdcrpy', 'Quenching') as data_path:
         tamptxt = "QuenchEnergyElectron_"+str(ikB)+".txt"
         fid = open(data_path / tamptxt)
     line = fid.readlines()
@@ -143,6 +158,7 @@ for ikB in kB_e:
     line = [float(x) for x in line[:-1]]
     Em_electron.append(line)
 
+
 """
 ======= Library of functions =======
 """
@@ -239,7 +255,10 @@ def readPenNuc2(rad,z1=z_PenNuc):
         list of energy levels -- indice 13. It contains a sub-list for all possible branches of a given daughter nucleus and a sub-sub list related to possible decay mode of each branch.
     prob_tran_tot : list[list]
         list of sum of transition of each branches -- indice 14. It contains a sub-list for all possible branches of a given daughter nucleus and a sub-sub list related to possible decay mode of each branch.
-
+    half_life : list
+        list of half_life of meta state -- indice 15.
+    uncertainty_tot : list[list]
+        list of uncertainty of probability associated with transitions -- indice 16. It contains a sub-list for all possible branches of a given daughter nucleus and a sub-sub list related to possible decay mode of each branch.
     '''
     doc = rad + ".PenNuc.txt"
     with z1.open(doc) as file_P:
@@ -321,8 +340,10 @@ def readPenNuc2(rad,z1=z_PenNuc):
     desin_type_tot=[];desin_energy_tot=[];desin_prob_tot=[];desin_level_tot=[]
     tran_type_tot=[];tran_energy_tot=[];tran_prob_tot=[];tran_level_end_tot=[]; 
     tran_level_tot=[];level_energy_tot=[]
-    prob_branch_tot=[];prob_tran_tot=[] 
-
+    prob_branch_tot=[];prob_tran_tot=[]
+    uncertainty_tot = []
+    half_life_tot = []
+    
     '''
      =============
      LOOP DAUGHTER 
@@ -357,7 +378,10 @@ def readPenNuc2(rad,z1=z_PenNuc):
         tran_type_daug=[];tran_energy_daug=[];tran_prob_daug=[];tran_level_end_daug=[];
         tran_level_daug=[];level_energy_daug=[]
         prob_branch_daug=[];prob_tran_daug=[]
-
+        uncertainty = []
+        half_life = []
+        
+        
         for i3 in range(len(posi_end_i)-1):
             start_p1 = posi_end_i[i3]
             end_p1 = posi_end_i[i3+1]
@@ -376,7 +400,9 @@ def readPenNuc2(rad,z1=z_PenNuc):
             tran_type_b=[];tran_prob_b=[];tran_energy_b=[]; tran_level_end_b=[];
             tran_level_b=[];level_energy_b=[]
             desin_type_b=[];desin_energy_b=[];desin_prob_b=[];desin_level_b=[];
-             
+            uncertainty_b = []
+            half_life_b = []
+            
             for i4 in decayData[start_p1+1:end_p1]:
                 if start_p1+1 == end_p1:
                     break
@@ -414,10 +440,11 @@ def readPenNuc2(rad,z1=z_PenNuc):
                     if "LED" == i4[0]:
                         tran_level_b.append(int(i4[-1]))
                         level_energy_b.append(float(i4[1]))
+                        half_life_b.append(float(i4[4]))
                     if i4[0] == "GA" or i4[0] == "EK" or i4[0] == "EL" or i4[0] == "EL1" or i4[0] == "EL2" or i4[0] == "EL3" or i4[0] == "EM" or i4[0] == "EN":
-                        #print(i4)
                         tran_type_b.append(i4[0])
                         tran_prob_b.append(float(i4[1]))
+                        uncertainty_b.append(float(i4[2]))
                         tran_energy_b.append(float(i4[3]))
                         tran_level_end_b.append(int(i4[5]))
             if branch:
@@ -428,12 +455,14 @@ def readPenNuc2(rad,z1=z_PenNuc):
              
             if transition:
                 tran_type_daug.append(tran_type_b)
+                uncertainty.append(uncertainty_b)
                 tran_energy_daug.append(tran_energy_b)
                 tran_prob_daug.append(tran_prob_b)
                 tran_level_end_daug.append(tran_level_end_b)
                 tran_level_daug.append(tran_level_b)
                 level_energy_daug.append(level_energy_b)
-
+                half_life.append(half_life_b)
+                
             if len(desin_prob_b)>0:
                 desin_prob_array = np.array(desin_prob_b)
                 prob_branch_i = np.sum(desin_prob_array)
@@ -454,11 +483,13 @@ def readPenNuc2(rad,z1=z_PenNuc):
 
         tran_type_daug.append([])
         tran_prob_daug.append([])
+        uncertainty.append([])
         tran_energy_daug.append([])
         tran_level_end_daug.append([])
         tran_level_daug.append([])
         level_energy_daug.append([])
         prob_tran_daug.append(0)
+        half_life.append([])
 
         desin_type_tot.append(desin_type_daug)
         desin_energy_tot.append(desin_energy_daug)
@@ -473,9 +504,14 @@ def readPenNuc2(rad,z1=z_PenNuc):
         level_energy_tot.append(level_energy_daug)
         prob_branch_tot.append(prob_branch_daug)
         prob_tran_tot.append(prob_tran_daug)
-    out = [daughter,prob_daug,energy_Q,desin_type_tot,desin_energy_tot,desin_prob_tot,desin_level_tot,prob_branch_tot,tran_type_tot,tran_energy_tot,tran_prob_tot,tran_level_tot,tran_level_end_tot,level_energy_tot,prob_tran_tot]
+        half_life_tot.append(half_life)
+        uncertainty_tot.append(uncertainty)
+        
+    out = [daughter,prob_daug,energy_Q,desin_type_tot,desin_energy_tot,desin_prob_tot,desin_level_tot,prob_branch_tot,tran_type_tot,tran_energy_tot,tran_prob_tot,tran_level_tot,tran_level_end_tot,level_energy_tot,prob_tran_tot,half_life_tot,uncertainty_tot]
     return out
 
+
+
 #================================== StoppingPower for alpha particle ===========================================
 
 def stoppingpowerA(e,rho=RHO,energy_alpha=energy_alph,dEdx_alpha=dEdx_alph):
@@ -1611,6 +1647,36 @@ distribution: https://pypi.org/project/TDCRPy \n\
 developement: https://github.com/RomainCoulon/TDCRPy \n\n\
 start calculation..."
  
- # Start Calculation
+    # Start Calculation
     print(header_text)
     print(header_text2)
+
+def display_distrib(S, D, T):
+    n=len(D)
+    x = np.arange(0,1.1,0.01)
+    D=np.asarray(D)
+    T=np.asarray(T)
+    meanD=np.mean(D)
+    meanT=np.mean(T)
+    # tdcr=T/D
+    plt.figure("efficiency distribution")
+    plt.clf()
+    plt.hist(np.asarray(D),bins=x,label="Double coincidences")[0]
+    plt.hist(np.asarray(T),bins=x,label="Triple coincidences")[0]
+    plt.scatter(meanD,n,marker='o',s=200,color='orange',label="mean value for Double coincidences")
+    plt.scatter(meanT,n,marker='o',s=200,color='blue',label="mean value for Triple coincidences")
+    plt.yscale("log")
+    plt.xlabel("Efficiency", fontsize = 14)
+    plt.ylabel(r"Number of counts", fontsize = 14)
+    plt.legend(fontsize = 12)
+    plt.show()
+    # plt.savefig('Effdistribution.png')
+
+    # plt.figure("TDCR distribution")
+    # plt.clf()
+    # plt.hist(np.asarray(tdcr),bins=x,label="calculated TDCR")[0]
+    # # plt.plot(x,st.norm.pdf(x, TDCR_measure, u_TDCR_measure),label="measured TDCR")[0]
+    # plt.xlabel("Efficiency", fontsize = 14)
+    # plt.ylabel(r"Number of counts", fontsize = 14)
+    # plt.legend(fontsize = 12)
+    # # plt.savefig('TDCRdistribution.png')

tdcrpy/config.toml

@@ -25,6 +25,10 @@ Z = 5.2
 # mean mass number of the scintillator (LS cocktail + aqueous solution)
 A = 11.04
 
+## PROPERTIES OF THE COUNTER
+# Coincidence resolving time (ns)
+tau = 50
+
 ## INTERPOLATION TO ESTIMATE THE QUENCHED ENERGY
 # depth (number of indexes on each side of the energy point) on which the spline interpolation is done.
 depthSpline = 5