TDCRPy 1.5.3__tar.gz → 1.5.5__tar.gz

{TDCRPy-1.5.3/TDCRPy.egg-info → TDCRPy-1.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TDCRPy
-Version: 1.5.3
+Version: 1.5.5
 Summary: TDCR model
 Home-page: https://github.com/RomainCoulon/TDCRPy
 Author: RomainCoulon (Romain Coulon)

{TDCRPy-1.5.3 → TDCRPy-1.5.5/TDCRPy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TDCRPy
-Version: 1.5.3
+Version: 1.5.5
 Summary: TDCR model
 Home-page: https://github.com/RomainCoulon/TDCRPy
 Author: RomainCoulon (Romain Coulon)

{TDCRPy-1.5.3 → TDCRPy-1.5.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import codecs
 import os
 
-VERSION = "1.5.3"
+VERSION = "1.5.5"
 DESCRIPTION = "TDCR model"
 
 with open("README.md", "r") as f:

{TDCRPy-1.5.3 → TDCRPy-1.5.5}/tdcrpy/TDCRPy.py

@@ -9,6 +9,8 @@ Bureau International des Poids et Mesures
 """
 
 ## IMPORT PYTHON MODULES
+#import tdcrpy.TDCR_model_lib as tl
+# import TDCR_model_lib as tl
 import tdcrpy.TDCR_model_lib as tl
 import importlib.resources
 from importlib.resources import files
@@ -111,6 +113,7 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
     if X and Y:
         inE = radListPureBeta.index(Rad)
         nE = nElist[inE]
+        print(f"Analytical model used for {Rad}")
         out=tl.modelAnalytical(L,TD,TAB,TBC,TAC,Rad,kB,V,mode,mode2,nE)
         if mode == "res":
             return out
@@ -418,58 +421,174 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             ==========================
             '''
             ## evenement retarde
-            if evenement != 1:
-                
-                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]:
+            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],uncData=uncData)
+                    if tf == "XKA":
+                        particle_vec[i_part] = "Atom_L"
+                        particle_vec.append(tf)
+                        energy_vec.append(ef)
                         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
+                    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("\n\t ATOMIC RECOMBINATION\n\t Summary of the atomic relaxation (promt)")
+                for i, p in enumerate(particle_vec):
+                    if p[:4] != "Atom":
+                        if p=="beta" or p=="beta+":
+                            print(f'\t\t {p} transition of energy = {energy_vec[i]}, keV')
                         else:
-                            if Display: print("\t\t x ray or Auger electron from X shell")
-                            relaxation = False
-                        e_sum += ef
-                if Display:
-                    print("\n\t ATOMIC RECOMBINATION\n\t Summary of the prompt atomic relaxation")
-                    for i, p in enumerate(particle_vec):
-                        if p[:4] != "Atom":
                             print(f"\t\t emitted {p} of energy = {round(energy_vec[i],3)} keV")
-                        else:
-                            print(f'\t\t an electron left the {p[5:]} shell')
-                            
+                    else:
+                        print(f'\t\t an electron left the {p[5:]} shell')
+    
+                '''
+                ==========================================================
+                III.a SPECTRES D'EMISSION
+                ==========================================================
+                '''
+            if ("beta" in particle_vec) or ("beta+" in particle_vec):
+                if Display: print("\n\t EMISSION OF BETA PARTICLES")   
+            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 Display: print(f"\t\t emitted {p} of energy = {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)
+                    if Display: print(f"\t\t emitted {p} of energy = {round(energy_vec[i],3)} keV")
+            energy_vec_initial = energy_vec    
+     
+            '''
+            ==========================================================
+                III.b INTERACTION RAYONNEMENT/MATIERE
+            ==========================================================
+            '''
+
+            for i, p in enumerate(particle_vec):
+                if p == "electron":
+                    energy_vec[i] = tl.energie_dep_beta2(energy_vec[i],v=V)
+        
+                if p == "beta+":
+                    energy_vec[i] = tl.energie_dep_beta2(energy_vec[i],v=V)
+        
+                if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
+                    energy_vec[i] = tl.energie_dep_gamma2(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_beta2(energy_vec[i],v=V)
+                
+            if Display:
+                print("\n\t INTERACTION \n\t Summary of the energy deposited by charged particles (promt)")
+                for i, p  in enumerate(particle_vec):
+                    if p[:4] != "Atom" and energy_vec[i]!=0: print(f"\t\t {p} of energy = {round(energy_vec[i],3)} keV")
+                        
+                '''
+                ====================
+                IV. LA SCINTILLATION
+                Calculation of the scintillation quenching with the Birks Model
+                ====================
+                '''
+            if Display: print(f"\n\t SCINTILLATION \n\t\t Birks constant = {kB} cm/keV\n\t Summary of the estimation of quenched energies (promt)")
+            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(f"\n\t COUNTING \n\t\t Free parameter = {L} keV-1 \n\t Summary of TDCR measurement (promt)")
+                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))
+                    
+                             
+            if evenement != 1:
+                print("\n\t Summary of the delayed emission")            
                 for i_part in range(len(particle_vec2)):
                     relaxation = False
                     if "Atom_K" in particle_vec2[i_part] or "Atom_L" in particle_vec2[i_part] or "Atom_M" in particle_vec2[i_part]:
                         relaxation = True
                     while relaxation:
-                        tf,ef = tl.relaxation_atom(daughter_relax,Rad[index_rad],particle_vec2[i_part])
+                        tf,ef = tl.relaxation_atom(daughter_relax,Rad[index_rad],particle_vec2[i_part],uncData=uncData)
                         if tf == "XKA":
                             particle_vec2[i_part] = "Atom_L"
                             particle_vec2.append(tf)
@@ -501,12 +620,15 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                         e_sum2 += ef
                 
                 if Display:
-                    print("\t Summary of the delayed atomic relaxation")
-                    for i, p in enumerate(particle_vec2):
-                        if p[:4] != "Atom":
-                            print(f"\t\t emitted {p} of energy = {round(energy_vec2[i],3)} keV")
+                    print("\n\t ATOMIC RECOMBINATION\n\t Summary of the atomic relaxation (promt)")
+                for i, p in enumerate(particle_vec):
+                    if p[:4] != "Atom":
+                        if p=="beta" or p=="beta+":
+                            print(f'\t\t {p} transition of energy = {energy_vec[i]}, keV')
                         else:
-                            print(f'\t\t an electron left the {p[5:]} shell')
+                            print(f"\t\t emitted {p} of energy = {round(energy_vec[i],3)} keV")
+                    else:
+                        print(f'\t\t an electron left the {p[5:]} shell')
                 
                 '''
                 ==========================================================
@@ -537,54 +659,12 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                 energy_vec_initial2 = energy_vec2    
 
                 
-                if ("beta" in particle_vec) or ("beta+" in particle_vec):
-                    if Display: print("\t Summary of sampling of beta particles")     
-                    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 Display: print(f"\t\t emitted {p} of energy = {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)
-                            if Display: print(f"\t\t emitted {p} of energy = {round(energy_vec[i],3)} keV")
-                energy_vec_initial = energy_vec    
-                
                 '''
                 ==========================================================
                 III.b INTERACTION RAYONNEMENT/MATIERE
                 ==========================================================
                 '''
                 
-                for i, p in enumerate(particle_vec):
-                    if p == "electron":
-                        energy_vec[i] = tl.energie_dep_beta2(energy_vec[i],v=V)
-        
-                    if p == "beta+":
-                        energy_vec[i] = tl.energie_dep_beta2(energy_vec[i],v=V)
-        
-                    if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
-                        energy_vec[i] = tl.energie_dep_gamma2(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_beta2(energy_vec[i],v=V)
-                        
-                if Display:
-                    print("\n\t INTERACTION \n\t Summary of the energy deposited by charged particles from the prompt transitions")
-                    for i, p  in enumerate(particle_vec):
-                        if p[:4] != "Atom" and energy_vec[i]!=0: print(f"\t\t {p} of energy = {round(energy_vec[i],3)} keV")
-                
                 for i, p in enumerate(particle_vec2):
                     if p == "electron":
                         energy_vec2[i] = tl.energie_dep_beta2(energy_vec2[i],v=V)
@@ -601,7 +681,7 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                         energy_vec2[i] = tl.energie_dep_beta2(energy_vec2[i],v=V)
                         
                 if Display:
-                    print("\t Summary of the energy deposited by charged particles from the delayed transitions")
+                    print("\n\t INTERACTION \n\t Summary of the energy deposited by charged particles (delay)")
                     for i, p  in enumerate(particle_vec2):
                         if p[:4] != "Atom" and energy_vec2[i]!=0: print(f"\t\t {p} of energy = {round(energy_vec2[i],3)} keV")
                 
@@ -616,22 +696,8 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                 '''
                 
                 # changer l'intégration E_i - E_d à E_i
-                if Display: print(f"\n\t SCINTILLATION \n\t\t Birks constant = {kB} cm/keV\n\t Summary of the estimation of quenched energies from the prompt transitions")
-                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:
-                    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 Display: print("\t Summary of the estimation of quenched energies by the delayed atomic relaxation")
+                if Display: print(f"\n\t SCINTILLATION \n\t\t Birks constant = {kB} cm/keV\n\t Summary of the estimation of quenched energies (delay)")
                 e_quenching2=[]
                 for i, p in enumerate(particle_vec2):
                     if p == "alpha":
@@ -661,7 +727,7 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                     efficiency_S.append(p_single+p_single2)
                     efficiency_T.append(p_single**3+p_single2**3)
                     efficiency_D.append(3*(p_single)**2-2*p_single**3+(3*(p_single2)**2-2*p_single2**3))
-                    if Display: print(f"\n\t COUNTING \n\t\t Free parameter = {L} keV-1 \n\t Summary of TDCR measurement (prompt)")
+                    if Display: print(f"\n\t COUNTING \n\t\t Free parameter = {L} keV-1 \n\t Summary of TDCR measurement (promt)")
                     if Display: print("\t\t Free parameter = ", L, "keV-1")
                     if Display: print("\t\t Efficiency of single events = ", round(p_single,5))
                     if Display: print("\t\t Efficiency of double events = ", round(p_single**3,5))
@@ -704,166 +770,7 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                     if Display: print("\t\t Efficiency of triple events: ", round(pA_single2*pB_single2*pC_single2,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("\n\t ATOMIC RECOMBINATION\n\t Summary of the atomic relaxation")
-                    for i, p in enumerate(particle_vec):
-                        if p[:4] != "Atom":
-                            if p=="beta" or p=="beta+":
-                                print(f'\t\t {p} transition of energy = {energy_vec[i]}, keV')
-                            else:
-                                print(f"\t\t emitted {p} of energy = {round(energy_vec[i],3)} keV")
-                        else:
-                            print(f'\t\t an electron left the {p[5:]} shell')
-    
-                '''
-                ==========================================================
-                III.a SPECTRES D'EMISSION
-                ==========================================================
-                '''
-                if ("beta" in particle_vec) or ("beta+" in particle_vec):
-                    if Display: print("\n\t EMISSION OF BETA PARTICLES")   
-                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 Display: print(f"\t\t emitted {p} of energy = {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)
-                        if Display: print(f"\t\t emitted {p} of energy = {round(energy_vec[i],3)} keV")
-                energy_vec_initial = energy_vec    
-     
-                '''
-                ==========================================================
-                III.b INTERACTION RAYONNEMENT/MATIERE
-                ==========================================================
-                '''
 
-                for i, p in enumerate(particle_vec):
-                    if p == "electron":
-                        energy_vec[i] = tl.energie_dep_beta2(energy_vec[i],v=V)
-        
-                    if p == "beta+":
-                        energy_vec[i] = tl.energie_dep_beta2(energy_vec[i],v=V)
-        
-                    if p == "gamma" or p == "XKA" or p == "XKB" or p == "XL":
-                        energy_vec[i] = tl.energie_dep_gamma2(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_beta2(energy_vec[i],v=V)
-                
-                if Display:
-                    print("\n\t INTERACTION \n\t Summary of the energy deposited by charged particles")
-                    for i, p  in enumerate(particle_vec):
-                        if p[:4] != "Atom" and energy_vec[i]!=0: print(f"\t\t {p} of energy = {round(energy_vec[i],3)} keV")
-                        
-                '''
-                ====================
-                IV. LA SCINTILLATION
-                Calculation of the scintillation quenching with the Birks Model
-                ====================
-                '''
-                if Display: print(f"\n\t SCINTILLATION \n\t\t Birks constant = {kB} cm/keV\n\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(f"\n\t COUNTING \n\t\t Free parameter = {L} keV-1 \n\t Summary of TDCR measurement")
-                    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))
                 
         '''
         ====================
@@ -931,12 +838,13 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
         if mode =="dis":
             return efficiency_S, efficiency_D, efficiency_T    
 
-# L = 1.0
+
+# L = 0.8
 # TD = 0.977667386529166
 # TAB = 0.992232838598821
 # TBC = 0.992343419459002
 # TAC = 0.99275350064608
-# Rad="Cd-109"
+# Rad="Sr-89"
 # pmf_1="1"
 # N = 10000
 # kB =1.0e-5
@@ -946,5 +854,4 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
 
 
 # out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=False, barp=True, uncData=False)
-# # tl.display_distrib(out)
-# print(out)
+# tl.display_distrib(out)

{TDCRPy-1.5.3 → TDCRPy-1.5.5}/tdcrpy/TDCR_model_lib.py

@@ -1310,6 +1310,8 @@ def transf_name(rad):
     RAD = name_lis[2]+name_lis[1]
     return RAD
 
+
+
 def readEShape(rad, *, z=z_ensdf):
     """ This function reads the ENSDF zip files and format the data to be processed by TDCRPy. 
 
@@ -1400,6 +1402,7 @@ def readEShape(rad, *, z=z_ensdf):
                     e.append(p1[2])
                     type_b.append(p1[-2])
                     incertitude_b.append(int(p1[-3]))
+                    #incertitude_b.append(p1[-3])
                     prob_str_b.append(p1[3])
                 continue 
             elif '|]' in p1:                # traiter un bloc qui comprend |]
@@ -1407,6 +1410,7 @@ def readEShape(rad, *, z=z_ensdf):
                     prob_str_b.append(p1[4])
                     prob_b.append(float(p1[4]))
                     incertitude_b.append(int(p1[5]))
+                    #incertitude_b.append(p1[5])
                 e.append(float(p1[2]))      # enregistrer les valeurs d'énergie
                 if 'AUGER' in p1:           # traiter le cas d'auger et |] 
                     if 'K' in p1[-2]:       # Auger K
@@ -1425,6 +1429,7 @@ def readEShape(rad, *, z=z_ensdf):
                     prob_b.append(float(p1[3]))    # enregistrer proba
                     prob_str_b.append(p1[3])
                     incertitude_b.append(int(p1[4]))
+                    #incertitude_b.append(p1[4])
                     if 'L' in p1:
                         type_b.append('Auger L')   # enregistrer type Auger L
                     else:
@@ -1458,31 +1463,52 @@ def readEShape(rad, *, z=z_ensdf):
 
 
 def incer(prob,incer):
-    if type(incer) == float or type(incer) == int:
-        incer_str = str(incer)    
-    len_prob = len(prob)
-    len_incer = len(incer_str)
+    '''
+
+    Parameters
+    ----------
+    prob : list of str
+        probability (str) of rayon X and Auger electron.
+    incer : list of int
+        uncertainty of the probability.
+
+    Returns
+    -------
+    incertitude : list of float
+        DESCRIPTION.
+
+    '''
+    incertitude = []
     
-    if '.' in prob:
-        index_pt = prob.index('.')
-        len_rest = len_prob - index_pt - 1
-        #print(len_rest,incer_str)
-        if len_rest >= len_incer:
-            #print('1')
-            incertitude = round(incer*(10**-len_rest),len_rest)
-        else:
-            incertitude = round(incer*(10**(len_rest-len_incer)),len_rest)
-    else:
-        incertitude = incer
+    for i in range(len(incer)):
+        incertitude_b = []
+        #if type(p) == float or type(p) == int:
+        for n in range(len(incer[i])):
+            p = prob[i][n]
+            u = incer[i][n]
+            incer_str = str(u)    
+            len_prob = len(p)
+            len_incer = len(incer_str)
+        
+            if '.' in p:
+                index_pt = p.index('.')
+                len_rest = len_prob - index_pt - 1
+            #print(len_rest,incer_str)
+                if len_rest >= len_incer:
+                #print('1')
+                    incertitude_b.append(round(u*(10**-len_rest),len_rest))
+                else:
+                    incertitude_b.append(round(u*(10**(len_rest-len_incer)),len_rest))
+            else:
+                incertitude_b.append(float(u))
+        incertitude.append(incertitude_b)
         
     return incertitude    
 
 
 
-
-
 #============  traiter la relaxation ===============
-def relaxation_atom(daugther,rad,lacune='defaut'):
+def relaxation_atom(daugther,rad,lacune='defaut',uncData=False):
     """ This function simulates the atomic rearangement following a missing electron an inner shell of the daughter atom.
     
     Parameters
@@ -1493,7 +1519,9 @@ def relaxation_atom(daugther,rad,lacune='defaut'):
         The mother nucleus (for exemple Am-241, C-11 etc.) 
     lacune  : string
         The shell where the electron is missing (for example 'Atom_K','Atom_L' etc.)
-
+    uncData : True/False
+        
+            
     Returns 
     -------
     Type : type of transition Auger L or K, or X Ray.
@@ -1501,6 +1529,7 @@ def relaxation_atom(daugther,rad,lacune='defaut'):
 
     """
     daug_name,Energy,Prob,Type,Incertitude,f = readEShape(rad)  # tirer les vecteurs de rad d'Ensdf 
+    incertitude = incer(f,Incertitude)
 
     index_daug = daug_name.index(daugther)        # repérer l'indice de fille correspondante
     
@@ -1508,26 +1537,19 @@ def relaxation_atom(daugther,rad,lacune='defaut'):
     probability = np.array(Prob[index_daug])                # tirer le vecteur de proba
     type_transi = Type[index_daug]                # tirer le vecteur de type
 
-
+    u_probability = np.array(incertitude[index_daug])
+    
     if len(probability) > 0:                      # le cas où le vecteur de proba/energie/type n'est pas vide
-        '''
-        posi_L = []
-        posi_K = []
-        
-        for i, p in enumerate(type_transi):       # repérer les indices de transition L ou K
-            if 'L' in p:
-                posi_L.append(i)                  # enregistrer la posotion de transition L
-
-            elif 'K' in p:
-                posi_K.append(i)                  # enregistrer la posotion de transition L
-        '''
         if 'L' in lacune:                         # traiter le transition de couche L
             prob_2 = []
             energy_2 = []
             type_2 = []
             for il, pl in enumerate(type_transi):
                 if 'L' in pl:
-                    prob_2.append(probability[il])    # enregistrer les proba de transition L
+                    if uncData:
+                        prob_2.append(np.random.normal(probability[il],u_probability[il],1)[0])    # enregistrer les proba de transition L
+                    else:
+                        prob_2.append(probability[il])    # enregistrer les proba de transition L
                     energy_2.append(Energie[il])      # enregistrer les energies de transition L
                     type_2.append(type_transi[il])    # enregistrer les types de transition L
 
@@ -1537,7 +1559,10 @@ def relaxation_atom(daugther,rad,lacune='defaut'):
             type_2 = []
             for ik, pk in enumerate(type_transi):     
                 if 'K' in pk:
-                    prob_2.append(probability[ik])    # enregistrer les proba de transition K
+                    if uncData:
+                        prob_2.append(np.random.normal(probability[ik],u_probability[ik],1)[0])
+                    else:
+                        prob_2.append(probability[ik])    # enregistrer les proba de transition K
                     energy_2.append(Energie[ik])      # enregistrer les energie de transition K
                     type_2.append(type_transi[ik])    # enregistrer les type de transition K
 

{TDCRPy-1.5.3 → TDCRPy-1.5.5}/tdcrpy/TDCRoptimize.py

@@ -84,4 +84,14 @@ def eff(TD, TAB, TBC, TAC, Rad, pmf_1, kB, V, mode2, N=10000, L=1):
     u_eff_T = out[5]
     
     return L0, L, eff_S, u_eff_S, eff_D, u_eff_D, eff_T, u_eff_T
-    
+    
+def effCurves(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V):
+    effD = []; ueffD = []; tdcr = []; uTdcr = []
+    for l in L:
+        out=td.TDCRPy(l, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, "eff", "sym", Display=False, barp=True, uncData=False)  
+        effD.append(out[2])
+        ueffD.append(out[3])
+        tdcr.append(out[4]/out[2])
+        uTdcr.append(1/out[2]*np.sqrt(out[5]**2+out[4]**2*out[3]**2/out[2]**2))
+    return effD, ueffD, tdcr, uTdcr
+

{TDCRPy-1.5.3 → TDCRPy-1.5.5}/tdcrpy/config.toml

@@ -8,7 +8,7 @@ Y = True
 radListPureBeta = H-3, C-14, S-35, Ca-45, Ni-63, Sr-89, Sr-90, Tc-99, Pm-147, Pu-241
 # Number of bins to discretize the linear energy space for quenching calculation
 # and achieve a relative standard uncertainty below 1e-4.
-nE = 7000, 1000, 1000, 500, 2000, 50, 200, 500, 1000, 7000
+nE = 7000, 1000, 1000, 500, 2000, 500, 200, 500, 1000, 7000
 
 ## OTHER CASES
 # Number of bins to discretize the linear energy space for quenching calculation

{TDCRPy-1.5.3 → TDCRPy-1.5.5}/tdcrpy/test2.py

@@ -8,15 +8,18 @@ Created on Fri Oct  6 14:49:40 2023
 import TDCR_model_lib as tl
 #import numpy as np
 
-a,b,c,d,e,f =  tl.readEShape('Fe-59')
-print(c,e)
-#'''
+a,b,c,d,e,f =  tl.readEShape('Mn-52m')
+#print(f,e)
+
+#print(tl.incer(f,e))
+
+'''
 if len(f[0]) == len(f[0]):
     for i in range(len(f[0])):
         print(tl.incer(f[0][i],e[0][i]))
 else:
     print('len pas bon')    
-#'''
+
 
 if len(f) == 2:
     print('### 2 fil')
@@ -26,3 +29,4 @@ if len(f) == 2:
     else:
         print('len pas bon')  
 
+'''