TDCRPy 1.12.15__py3-none-any.whl → 1.13.0__py3-none-any.whl

{TDCRPy-1.12.15.dist-info → TDCRPy-1.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TDCRPy
-Version: 1.12.15
+Version: 1.13.0
 Summary: TDCR model
 Home-page: https://pypi.org/project/TDCRPy/
 Author: RomainCoulon (Romain Coulon)

{TDCRPy-1.12.15.dist-info → TDCRPy-1.13.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-tdcrpy/TDCRPy.py,sha256=D3NCFJP0n7b7dbg53F-d79p6xMR6_14W52Qd7v6A7uo,65356
+tdcrpy/TDCRPy.py,sha256=i16smPjN2GhbMfhdnTYNXwnyM0rncCszxjK5XCASPh0,69480
 tdcrpy/TDCRPy1.py,sha256=QTBZh5B5JWnGB0BQfD-cFmwA9W080OD4sG-aj50-ejo,38106
-tdcrpy/TDCR_model_lib.py,sha256=M4gFN5QVqEeRp46FrZJpG9ytv99FZl2RTwoU9nc91Go,110702
+tdcrpy/TDCR_model_lib.py,sha256=GLxnYEmB-U-kIsrSwwvawKsltbMyOZESiE_DdRodxjQ,119180
 tdcrpy/TDCRoptimize.py,sha256=c2XIGveeLdVYYek4Rg6dygMvVA2xIrIkMb3L-_jUucM,6496
 tdcrpy/__init__.py,sha256=vQslGLsoZPIceaitnSHOqN6lUdjEyJ3YhfJ6tYdXt-s,127
 tdcrpy/config.toml,sha256=d_olKEgxfobBHkZ2wEj9EgKE7I8Wbpim9ZAsi5ImFxk,1470
@@ -1081,8 +1081,8 @@ tdcrpy/docs/_build/html/source/modules.html,sha256=Jf-qxVBId0UgpwyvYuyjtMNG-ezPO
 tdcrpy/docs/_build/html/source/tdcrpy.html,sha256=-38lHMNFB22p1tWJEeN3yDqfDiCYE304vxDamO1-iRc,3779
 tdcrpy/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tdcrpy/test/test_tdcrpy.py,sha256=JINqSEMFoNpptE4f3h6ZzTYW1rBx90KkaoQzltSg-No,4692
-TDCRPy-1.12.15.dist-info/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
-TDCRPy-1.12.15.dist-info/METADATA,sha256=K6QZZkIGsPacCsrhrwnD6c1--PB5dNgsI-rhS_leirQ,15833
-TDCRPy-1.12.15.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-TDCRPy-1.12.15.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
-TDCRPy-1.12.15.dist-info/RECORD,,
+TDCRPy-1.13.0.dist-info/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
+TDCRPy-1.13.0.dist-info/METADATA,sha256=369qvRM9JVEZlkH7YAB5j-DzZG8rmVnUVBQCp7QfVzY,15832
+TDCRPy-1.13.0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+TDCRPy-1.13.0.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
+TDCRPy-1.13.0.dist-info/RECORD,,

{TDCRPy-1.12.15.dist-info → TDCRPy-1.13.0.dist-info}/WHEEL

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

tdcrpy/TDCRPy.py

@@ -83,7 +83,7 @@ def relaxAtom(daughter_relax,particle_vec,energy_vec,rad,Display=False,uncData=F
                 relaxation = False
     return particle_vec, energy_vec
 
-def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=False, barp=False, Smodel=True, syst = "TDCR", record = False, uncData=False):
+def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=False, barp=False, Smodel=True, syst = "TDCR", record = False, readRecHist = 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. 
@@ -241,7 +241,85 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             return out
         if mode == "eff":
             return out[0], 0, out[1], 0, out[2], 0
+    
+    elif readRecHist:
+        efficiency_A2 = []
+        efficiency_B2 = []
+        efficiency_S = []
+        efficiency_D = []
+        efficiency_D2 = []
+        efficiency_T = []
+        efficiency_AB = []
+        efficiency_BC = []
+        efficiency_AC = []
+        
+        temp_dir = tempfile.gettempdir()
+        recfile3 = os.path.join(temp_dir, "Temp_E2.txt")
+
+        with open(recfile3, "r") as file:
+   
+            decaym = -1
+            e_quenching = []; e_quenching2 = []; evenement=1; t1=0
+            for line in file:
+                if line[0] != "#":
+                    line = line.split(' ')
+                    line = [element for element in line if element != ""]
+                    decay = int(line[2])
+                    
+                    if decay != decaym:
+                        if decay>0:
+                            # print(decay-1,e_quenching,e_quenching2, evenement)
+                            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extDT, measTime)
+                            efficiency_S.append(efficiency0_S)
+                            efficiency_T.append(efficiency0_T)
+                            efficiency_D.append(efficiency0_D)
+                            efficiency_D2.append(efficiency0_D2)
+                            
+                            # print(efficiency0_D, "\n")
+                        
+                        energy = float(line[1])*1e-3
+                        t1 = float(line[4])
+                        decaym = decay
+                        # print(decay, energy, t1, extDT)
+                        e_quenching = []; e_quenching2 = []
+                        evenement=1
+                        e_quenching.append(energy)
+                    else:
+                        energy = float(line[1])*1e-3
+                        t1 = float(line[4])
+                        # print(decay, energy, t1, extDT)
+                        if t1 > tau*1e-9:
+                            evenement = evenement + 1
+                            e_quenching2.append(energy)
+                        else:
+                            e_quenching.append(energy)
+                            
+            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extDT, measTime)
+            efficiency_S.append(efficiency0_S)
+            efficiency_T.append(efficiency0_T)
+            efficiency_D.append(efficiency0_D)
+            efficiency_D2.append(efficiency0_D2)
+                            
+            # print(efficiency_D)
+            outEff = tl.efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_D2, N)
+            return outEff
+                
+
+            # temp1, temp2, temp3, temp4 = tl.read_temp_files()
+            # ee_vec = tl.energyVectors3(temp3)
+            # # to be continued
+    
     else:
+        efficiency_A2 = []
+        efficiency_B2 = []
+        efficiency_S = []
+        efficiency_D = []
+        efficiency_D2 = []
+        efficiency_T = []
+        efficiency_AB = []
+        efficiency_BC = []
+        efficiency_AC = []
+        
         nE_electron = config["Inputs"].getint("nE_electron")
         nE_alpha = config["Inputs"].getint("nE_alpha")
         Rad=Rad.replace(" ","")
@@ -295,18 +373,7 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             u_prob_trans.append(out_PenNuc[16])
             trans_halfLife.append(out_PenNuc[15])
         # print("\n",trans_halfLife)
-        
-        efficiency_A2 = []
-        efficiency_B2 = []
-        efficiency_S = []
-        efficiency_D = []
-        efficiency_D2 = []
-        efficiency_T = []
-        efficiency_AB = []
-        efficiency_BC = []
-        efficiency_AC = []
-
-        
+                
         if barp and not Display: NN = tqdm(range(N), desc="Processing", unit=" decays")
         else: NN = range(N)
         for idec in NN: # Main Loop - Monte Carlo trials
@@ -888,104 +955,113 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             ====================
             V. LE MESURE TDCR
             ====================
-            '''            
-            if mode2=="sym":
-                if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
-                    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
-                    p_nosingle2 = np.exp(-L*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
-                    p_single2 = 1-p_nosingle2
-                    efficiency_S.append(1-p_nosingle**3+1-p_nosingle2**3)
-                    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))
-                    efficiency_D2.append(p_single**2+p_single2**2)
-                    if Display: print(f"\n\t COUNTING--Sym \n\t\t Free parameter = {L} keV-1 \n\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(1-p_nosingle**3,5))
-                    if Display: print("\t\t Efficiency of double events = ", round(3*(p_single)**2-2*p_single**3,5))
-                    if Display: print("\t\t Efficiency of triple events = ", round(p_single**3,5))
-                    if Display: print("\t Summary of TDCR measurement (delayed)")
-                    if Display: print("\t\t Efficiency of single events = ", round(1-p_nosingle2**3,5))
-                    if Display: print("\t\t Efficiency of double events = ", round(3*(p_single2)**2-2*p_single2**3,5))
-                    if Display: print("\t\t Efficiency of triple events = ", round(p_single2**3,5))
-                    if Display: print("\t Summary of TDCR measurement (prompt + delayed)")
-                    if Display: print("\t\t Efficiency of single events = ", round(1-p_nosingle**3+1-p_nosingle2**3,5))
-                    if Display: print("\t\t Efficiency of double events = ", round(3*(p_single)**2-2*p_single**3+(3*(p_single2)**2-2*p_single2**3),5))
-                    if Display: print("\t\t Efficiency of triple events = ", round(p_single**3+p_single2**3,5))
-                else:
-                    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(1-p_nosingle**3)
-                    efficiency_T.append(p_single**3)
-                    efficiency_D.append(3*(p_single)**2-2*efficiency_T[-1])
-                    efficiency_D2.append(p_single**2)
-                    if Display: print(f"\n\t COUNTING--Sym \n\t\t Free parameter = {L} keV-1 \n\t Summary of TDCR measurement (prompt)")
-                    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: e_quenching2 = 0; t1=0
+            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extDT, measTime)
+            efficiency_S.append(efficiency0_S)
+            efficiency_T.append(efficiency0_T)
+            efficiency_D.append(efficiency0_D)
+            efficiency_D2.append(efficiency0_D2)
+            # print(e_quenching,efficiency0_D)
+            
+            
+            # if mode2=="sym":
+            #     if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+            #         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
+            #         p_nosingle2 = np.exp(-L*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            #         p_single2 = 1-p_nosingle2
+            #         efficiency_S.append(1-p_nosingle**3+1-p_nosingle2**3)
+            #         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))
+            #         efficiency_D2.append(p_single**2+p_single2**2)
+            #         if Display: print(f"\n\t COUNTING--Sym \n\t\t Free parameter = {L} keV-1 \n\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(1-p_nosingle**3,5))
+            #         if Display: print("\t\t Efficiency of double events = ", round(3*(p_single)**2-2*p_single**3,5))
+            #         if Display: print("\t\t Efficiency of triple events = ", round(p_single**3,5))
+            #         if Display: print("\t Summary of TDCR measurement (delayed)")
+            #         if Display: print("\t\t Efficiency of single events = ", round(1-p_nosingle2**3,5))
+            #         if Display: print("\t\t Efficiency of double events = ", round(3*(p_single2)**2-2*p_single2**3,5))
+            #         if Display: print("\t\t Efficiency of triple events = ", round(p_single2**3,5))
+            #         if Display: print("\t Summary of TDCR measurement (prompt + delayed)")
+            #         if Display: print("\t\t Efficiency of single events = ", round(1-p_nosingle**3+1-p_nosingle2**3,5))
+            #         if Display: print("\t\t Efficiency of double events = ", round(3*(p_single)**2-2*p_single**3+(3*(p_single2)**2-2*p_single2**3),5))
+            #         if Display: print("\t\t Efficiency of triple events = ", round(p_single**3+p_single2**3,5))
+            #     else:
+            #         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(1-p_nosingle**3)
+            #         efficiency_T.append(p_single**3)
+            #         efficiency_D.append(3*(p_single)**2-2*efficiency_T[-1])
+            #         efficiency_D2.append(p_single**2)
+            #         if Display: print(f"\n\t COUNTING--Sym \n\t\t Free parameter = {L} keV-1 \n\t Summary of TDCR measurement (prompt)")
+            #         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":
-                if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
-                    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
+            # elif mode2=="asym":
+            #     if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+            #         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
                     
-                    pA_nosingle2 = np.exp(-L[0]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
-                    pA_single2 = 1-pA_nosingle2                                    # probability to have at least 1 electrons in a PMT
-                    pB_nosingle2 = np.exp(-L[1]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
-                    pB_single2 = 1-pB_nosingle2                                    # probability to have at least 1 electrons in a PMT
-                    pC_nosingle2 = np.exp(-L[2]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
-                    pC_single2 = 1-pC_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            #         pA_nosingle2 = np.exp(-L[0]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            #         pA_single2 = 1-pA_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            #         pB_nosingle2 = np.exp(-L[1]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            #         pB_single2 = 1-pB_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            #         pC_nosingle2 = np.exp(-L[2]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            #         pC_single2 = 1-pC_nosingle2                                    # probability to have at least 1 electrons in a PMT
                     
-                    efficiency_A2.append(pA_single+pA_single2)
-                    efficiency_B2.append(pB_single+pB_single2)
-                    efficiency_AB.append(pA_single*pB_single+pA_single2*pB_single2)
-                    efficiency_BC.append(pB_single*pC_single+pB_single2*pC_single2)
-                    efficiency_AC.append(pA_single*pC_single+pA_single2*pC_single2)
-                    efficiency_T.append(pA_single*pB_single*pC_single+pA_single2*pB_single2*pC_single2)
-                    efficiency_D.append(pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single+(pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2))
-                    #efficiency_S.append(pA_single+pB_single+pC_single-pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single-pA_single*pB_single*pC_single+(pA_single2+pB_single2+pC_single2-pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2-pA_single2*pB_single2*pC_single2))
-                    efficiency_S.append(1-pA_nosingle*pB_nosingle*pC_nosingle+1-pA_nosingle2*pB_nosingle2*pC_nosingle2)
-                    efficiency_D2.append(pA_single*pB_single+pA_single2*pB_single2)
+            #         efficiency_A2.append(pA_single+pA_single2)
+            #         efficiency_B2.append(pB_single+pB_single2)
+            #         efficiency_AB.append(pA_single*pB_single+pA_single2*pB_single2)
+            #         efficiency_BC.append(pB_single*pC_single+pB_single2*pC_single2)
+            #         efficiency_AC.append(pA_single*pC_single+pA_single2*pC_single2)
+            #         efficiency_T.append(pA_single*pB_single*pC_single+pA_single2*pB_single2*pC_single2)
+            #         efficiency_D.append(pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single+(pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2))
+            #         #efficiency_S.append(pA_single+pB_single+pC_single-pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single-pA_single*pB_single*pC_single+(pA_single2+pB_single2+pC_single2-pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2-pA_single2*pB_single2*pC_single2))
+            #         efficiency_S.append(1-pA_nosingle*pB_nosingle*pC_nosingle+1-pA_nosingle2*pB_nosingle2*pC_nosingle2)
+            #         efficiency_D2.append(pA_single*pB_single+pA_single2*pB_single2)
                    
                     
                     
-                    if Display: print(f"\n\t COUNTING--Asym \n\t\t Free parameters (A,B,C) = {L[0]},{L[1]},{L[2]} keV-1 \n\t Summary of TDCR measurement (prompt)")
-                    #if Display: print("\t Summary of TDCR measurement (prompt)")
-                    if Display: print("\t\t Efficiency of single events: ", round(pA_single+pB_single+pC_single-pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single-pA_single*pB_single*pC_single,5))
-                    if Display: print("\t\t Efficiency of double events: ", round(pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single,5))
-                    if Display: print("\t\t Efficiency of triple events: ", round(pA_single*pB_single*pC_single,5))
-                    if Display: print("\t Summary of TDCR measurement (delayed)")
-                    if Display: print("\t\t Efficiency of single events: ", round(pA_single2+pB_single2+pC_single2-pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2-pA_single2*pB_single2*pC_single2,5))
-                    if Display: print("\t\t Efficiency of double events: ", round(pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2,5))
-                    if Display: print("\t\t Efficiency of triple events: ", round(efficiency_S[-1],5))
-                else:
-                    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(f"\n\t COUNTING--Asym \n\t\t Free parameters (A,B,C) = {L[0]},{L[1]},{L[2]} keV-1 \n\t Summary of TDCR measurement (prompt)")
+            #         #if Display: print("\t Summary of TDCR measurement (prompt)")
+            #         if Display: print("\t\t Efficiency of single events: ", round(pA_single+pB_single+pC_single-pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single-pA_single*pB_single*pC_single,5))
+            #         if Display: print("\t\t Efficiency of double events: ", round(pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single,5))
+            #         if Display: print("\t\t Efficiency of triple events: ", round(pA_single*pB_single*pC_single,5))
+            #         if Display: print("\t Summary of TDCR measurement (delayed)")
+            #         if Display: print("\t\t Efficiency of single events: ", round(pA_single2+pB_single2+pC_single2-pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2-pA_single2*pB_single2*pC_single2,5))
+            #         if Display: print("\t\t Efficiency of double events: ", round(pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2,5))
+            #         if Display: print("\t\t Efficiency of triple events: ", round(efficiency_S[-1],5))
+            #     else:
+            #         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_A2.append(pA_single)
-                    efficiency_B2.append(pB_single)
-                    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(1-pA_nosingle*pB_nosingle*pC_nosingle)
-                    efficiency_D2.append(pA_single*pB_single)
-                    if Display: print(f"\n\t COUNTING--Asym \n\t\t Free parameters (A,B,C) = {L[0]},{L[1]},{L[2]} keV-1 \n\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))                    
+            #         efficiency_A2.append(pA_single)
+            #         efficiency_B2.append(pB_single)
+            #         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(1-pA_nosingle*pB_nosingle*pC_nosingle)
+            #         efficiency_D2.append(pA_single*pB_single)
+            #         if Display: print(f"\n\t COUNTING--Asym \n\t\t Free parameters (A,B,C) = {L[0]},{L[1]},{L[2]} keV-1 \n\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))                    
 
             """
             ==========================================================
@@ -1004,18 +1080,20 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
         VI. CALCULATION OF THE FINAL ESTIMATORS
         ====================
         '''
-        mean_efficiency_T = np.mean(efficiency_T) # average
-        std_efficiency_T = np.std(efficiency_T)/np.sqrt(N)   # standard deviation
-        std_efficiency_T = np.sqrt(std_efficiency_T**2+1e-8) # combined with uncertainty due to quenching calculation
-        mean_efficiency_D = np.mean(efficiency_D)
-        std_efficiency_D = np.std(efficiency_D)/np.sqrt(N)
-        std_efficiency_D = np.sqrt(std_efficiency_D**2+1e-8)
-        mean_efficiency_D2 = np.mean(efficiency_D2)
-        std_efficiency_D2 = np.std(efficiency_D2)/np.sqrt(N)
-        std_efficiency_D2 = np.sqrt(std_efficiency_D2**2+1e-8)
-        mean_efficiency_S = np.mean(efficiency_S)
-        std_efficiency_S = np.std(efficiency_S)/np.sqrt(N)
-        std_efficiency_S = np.sqrt(std_efficiency_S**2+1e-8)
+        mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_D2, std_efficiency_D2 = tl.efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_D2,N)
+
+        # mean_efficiency_T = np.mean(efficiency_T) # average
+        # std_efficiency_T = np.std(efficiency_T)/np.sqrt(N)   # standard deviation
+        # std_efficiency_T = np.sqrt(std_efficiency_T**2+1e-8) # combined with uncertainty due to quenching calculation
+        # mean_efficiency_D = np.mean(efficiency_D)
+        # std_efficiency_D = np.std(efficiency_D)/np.sqrt(N)
+        # std_efficiency_D = np.sqrt(std_efficiency_D**2+1e-8)
+        # mean_efficiency_D2 = np.mean(efficiency_D2)
+        # std_efficiency_D2 = np.std(efficiency_D2)/np.sqrt(N)
+        # std_efficiency_D2 = np.sqrt(std_efficiency_D2**2+1e-8)
+        # mean_efficiency_S = np.mean(efficiency_S)
+        # std_efficiency_S = np.std(efficiency_S)/np.sqrt(N)
+        # std_efficiency_S = np.sqrt(std_efficiency_S**2+1e-8)
         
         if mode2=="sym":
             TDCR_calcul = mean_efficiency_T/mean_efficiency_D
@@ -1039,17 +1117,14 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
         if mode == "res":
             return res
         if mode == "eff":
-            if N<200:
-                print("Warning. too low number of MC trials - inaccurate estimation")
-                if syst == "TDCR":
-                    return mean_efficiency_S, 1, mean_efficiency_D, 1, mean_efficiency_T, 1
-                elif syst =="CN":
-                    return mean_efficiency_D2, 1
-            else:
-                if syst == "TDCR":
-                    return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T
-                elif syst =="CN":
-                    return mean_efficiency_D2, std_efficiency_D2
+            # if N<200:
+            #     print("Warning. too low number of MC trials - inaccurate estimation")
+            #     if syst == "TDCR":
+            #         return mean_efficiency_S, 1, mean_efficiency_D, 1, mean_efficiency_T, 1
+            #     elif syst =="CN":
+            #         return mean_efficiency_D2, 1
+            # else:
+            return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_D2, std_efficiency_D2
         if mode =="dis":
             return efficiency_S, efficiency_D, efficiency_T, efficiency_D2
 
@@ -1075,17 +1150,22 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
 # TAB = 0.992232838598821
 # TBC = 0.992343419459002
 # TAC = 0.99275350064608
-# Rad="Lu-177"
+# Rad="Co-60"
 # pmf_1="1"
-# N = 1000
+# N = 5
 # kB =1.0e-5
 # V = 10
 # mode = "eff"
 # mode2 = "sym"
 
-# # out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=True, barp=False,uncData=False)
-# # print("TDCR", out[4]/out[2])
-# # print("Eff D", out[2])
+# # # out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=True, barp=False,uncData=False)
+# # # print("TDCR", out[4]/out[2])
+# # # print("Eff D", out[2])
+
 
+# # out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, 20, kB, V, mode, mode2, Display=True, barp=False, Smodel=True, syst = "TDCR", record = "phf1", uncData=False)
 
-# out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, 20, kB, V, mode, mode2, Display=True, barp=False, Smodel=True, syst = "TDCR", record = "phf1", uncData=False)
+# out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display = False, record = True, readRecHist = False)
+# print("result", out)
+# out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display = False, record = False, readRecHist = True)
+# print("result", out)

tdcrpy/TDCR_model_lib.py

@@ -2830,7 +2830,122 @@ def buildBetaSpectra(rad, V, N, prt=False):
                 else: file.write(f"{b}\t{p2[i]}\n")
         print("file written in local")        
                 
+def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extDT, measTime):
+    if mode2=="sym":
+        # print(evenement !=1, t1 > extDT*1e-6, t1 < measTime*60)
+        if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+            # TDCR
+            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+            p_nosingle2 = np.exp(-L*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            p_single2 = 1-p_nosingle2
+            efficiency0_S = 1-p_nosingle**3+1-p_nosingle2**3
+            efficiency0_T = p_single**3+p_single2**3
+            efficiency0_D = 3*(p_single)**2-2*p_single**3+(3*(p_single2)**2-2*p_single2**3)
+            
+            # CN
+            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+            p_nosingle2 = np.exp(-L*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 electrons in a PMT
+            p_single2 = 1-p_nosingle2            
+            efficiency0_D2 = p_single**2+p_single2**2
+        else:
+            # TDCR
+            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT
+            efficiency0_S = 1-p_nosingle**3
+            efficiency0_T = p_single**3
+            efficiency0_D = 3*(p_single)**2-2*efficiency0_T
+            
+            # CN
+            p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT            
+            efficiency0_D2 = p_single**2
+        
+                            
+    elif mode2=="asym":
+        if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
+            # TDCR            
+            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pA_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
+            
+            pA_nosingle2 = np.exp(-L[0]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            pA_single2 = 1-pA_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle2 = np.exp(-L[1]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            pB_single2 = 1-pB_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            pC_nosingle2 = np.exp(-L[2]*np.sum(np.asarray(e_quenching2))/3) # probability to have 0 electrons in a PMT
+            pC_single2 = 1-pC_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            
+            efficiency0_A2 = pA_single+pA_single2
+            efficiency0_B2 = pB_single+pB_single2
+            efficiency0_AB = pA_single*pB_single+pA_single2*pB_single2
+            efficiency0_BC = pB_single*pC_single+pB_single2*pC_single2
+            efficiency0_AC = pA_single*pC_single+pA_single2*pC_single2
+            efficiency0_T = pA_single*pB_single*pC_single+pA_single2*pB_single2*pC_single2
+            efficiency0_D = pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single+(pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2)
+            #efficiency_S = pA_single+pB_single+pC_single-pA_single*pB_single+pB_single*pC_single+pA_single*pC_single-2*pA_single*pB_single*pC_single-pA_single*pB_single*pC_single+(pA_single2+pB_single2+pC_single2-pA_single2*pB_single2+pB_single2*pC_single2+pA_single2*pC_single2-2*pA_single2*pB_single2*pC_single2-pA_single2*pB_single2*pC_single2)
+            efficiency0_S = 1-pA_nosingle*pB_nosingle*pC_nosingle+1-pA_nosingle2*pB_nosingle2*pC_nosingle2
+            
+            
+            # CN
+            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pA_single = 1-pA_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle = np.exp(-L[1]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pB_single = 1-pB_nosingle                                    # probability to have at least 1 electrons in a PMT
+            
+            pA_nosingle2 = np.exp(-L[0]*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 electrons in a PMT
+            pA_single2 = 1-pA_nosingle2                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle2 = np.exp(-L[1]*np.sum(np.asarray(e_quenching2))/2) # probability to have 0 electrons in a PMT
+            pB_single2 = 1-pB_nosingle2                                    # probability to have at least 1 electrons in a PMT
+
+            efficiency0_D2 = pA_single*pB_single+pA_single2*pB_single2
+        else:
+            # TDCR
+            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
+            pA_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
                 
+            efficiency0_A2 = pA_single
+            efficiency0_B2 = pB_single
+            efficiency0_AB = pA_single*pB_single
+            efficiency0_BC = pB_single*pC_single
+            efficiency0_AC = pA_single*pC_single
+            efficiency0_T = pA_single*pB_single*pC_single
+            efficiency0_D = efficiency0_AB+efficiency0_BC+efficiency0_AC-2*efficiency0_T
+            efficiency0_S = 1-pA_nosingle*pB_nosingle*pC_nosingle
+            
+            # CN
+            pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pA_single = 1-pA_nosingle                                    # probability to have at least 1 electrons in a PMT
+            pB_nosingle = np.exp(-L[1]*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
+            pB_single = 1-pB_nosingle                                    # probability to have at least 1 electrons in a PMT            
+            efficiency0_D2 = pA_single*pB_single
+            
+    return efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_D2        
+
+
+def efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_D2,N):
+    mean_efficiency_T = np.mean(efficiency_T) # average
+    std_efficiency_T = np.std(efficiency_T)/np.sqrt(N)   # standard deviation
+    mean_efficiency_D = np.mean(efficiency_D)
+    std_efficiency_D = np.std(efficiency_D)/np.sqrt(N)
+    mean_efficiency_D2 = np.mean(efficiency_D2)
+    std_efficiency_D2 = np.std(efficiency_D2)/np.sqrt(N)
+    mean_efficiency_S = np.mean(efficiency_S)
+    std_efficiency_S = np.std(efficiency_S)/np.sqrt(N)
+    return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_D2, std_efficiency_D2
+    
+
+
+
+
 # N = 1e7
 # buildBetaSpectra('H-3', 16, N, prt=True); print('H-3 - done')
 # buildBetaSpectra('C-14', 16, N, prt=True); print('C-14 - done')