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

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

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

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

@@ -1,8 +1,8 @@
-tdcrpy/TDCRPy.py,sha256=i16smPjN2GhbMfhdnTYNXwnyM0rncCszxjK5XCASPh0,69480
+tdcrpy/TDCRPy.py,sha256=MBIIarFldIoz1BOyWlB_5rKA_5NMed2QQfM-2xqJnUg,61031
 tdcrpy/TDCRPy1.py,sha256=QTBZh5B5JWnGB0BQfD-cFmwA9W080OD4sG-aj50-ejo,38106
-tdcrpy/TDCR_model_lib.py,sha256=GLxnYEmB-U-kIsrSwwvawKsltbMyOZESiE_DdRodxjQ,119180
+tdcrpy/TDCR_model_lib.py,sha256=I8AOboq9sgCnkMpu871RTABgxvUg-OwBNzL20EARJpo,124068
 tdcrpy/TDCRoptimize.py,sha256=c2XIGveeLdVYYek4Rg6dygMvVA2xIrIkMb3L-_jUucM,6496
-tdcrpy/__init__.py,sha256=vQslGLsoZPIceaitnSHOqN6lUdjEyJ3YhfJ6tYdXt-s,127
+tdcrpy/__init__.py,sha256=9Djir8dPNchcJVQvhl-oRHEOsoDkiZlkOhWT-eHR7wQ,95
 tdcrpy/config.toml,sha256=d_olKEgxfobBHkZ2wEj9EgKE7I8Wbpim9ZAsi5ImFxk,1470
 tdcrpy/test2.py,sha256=poLLXJyIaCeqh1VSkwgbi-udvY7lQjxz_YStKjJXGhU,501
 tdcrpy/EfficiencyCurves/Ag-108/EffD_Ag-108_[1]_1e-05.txt,sha256=OUoMuqPTw3fXLu5qaHUFN2iW0dPJ9cRyh99a6mUcEus,43
@@ -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.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-2.0.0.dist-info/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
+TDCRPy-2.0.0.dist-info/METADATA,sha256=VHpxRhIMAyLRXOcwjFkhQ-E0bVBk5yIQ_YsevRQorcY,15831
+TDCRPy-2.0.0.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
+TDCRPy-2.0.0.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
+TDCRPy-2.0.0.dist-info/RECORD,,

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

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

tdcrpy/TDCRPy.py

@@ -17,6 +17,7 @@ import numpy as np
 from tqdm import tqdm
 import tempfile
 import os
+import scipy.optimize as opt
 
 def relaxAtom(daughter_relax,particle_vec,energy_vec,rad,Display=False,uncData=False):
          
@@ -83,61 +84,32 @@ 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, readRecHist = False, uncData=False):
+def TDCRPy(L, Rad, pmf_1, N, kB, V, mode="eff", Display=False, barp=False, Smodel=True, 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.
+    This is the main function of the TDCRPy package.
     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. 
-    
-    It can operates in two modes:
-       
-       --> 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.
-    
-    also, two configuration can be set:
        
-        --> mode2="sym", where symmetry is considered between the 3 photomultiplier tubes - here L is a scalar and only the global TDCR value TD is used as measurement data.
-        
-        --> mode2="asym", where an asymmetry between the 3 photomultiplier tubes is possible - here L is a triplet and only the specific TDCR values TAB, TBC, TAC are used as measurement data.
-    
     The parmeter N sets the number of Monte-Carlo trails used for the estimation. Each MC trial corresponds to a simulated radiactive decay.
     TDCRPY() used a set of fonctions from the tdcrpy.TDCR_model_lib module.
     
     Advanced settings can be configured in the config.toml file.
     
-       --> By default Y = True so that the analytical model is applied for solution containing only pure beta emitting radionuclides. If you would like to apply the MC calculation also for these nuclides, set Y = False.
-       
-       --> If you would like to change the number of bins nE to discretize the linear energy space for quenching calculation, you can change nE_electron and nE_alpha parameters for respectively electrons and alpha particles.
-       
-       --> By default the calculation is set for Ultima-Gold cocktail mixed with a small amount of aqueous solution. You can adapt for a specific scintillator by changing the density, the mean charge number Z and the mean mass number A of the scintillator.
-       
-    
     Parameters
     ----------
-    L : Float (if mode2="sym") or a tuple (if mode2="asym")
-        Free parameter in keV-1.
-    TD : float
-        triple-to-double coincidence ratio. Not consider if mode2="asym". Not consider if mode2="asym".
-    TAB : float
-        triple-to-double coincidence ratio (coincidences between channel A and B). Not consider if mode2="sym".
-    TBC : float
-        triple-to-double coincidence ratio (coincidences between channel B and C). Not consider if mode2="sym".
-    TAC : float
-        triple-to-double coincidence ratio (coincidences between channel A and C). Not consider if mode2="sym".
+    L : Float or tuple
+        If L is float, then L is the global free parameter. If L is tuple, then L is a triplet of free parameters. unit keV-1
     Rad : string
         List of radionuclides (eg. "H-3, Co-60").
     pmf_1 : string
         list of probability of each radionuclide (eg. "0.8, 0.2").
     N : integer
-        Number of Monte-Carlo trials. recommanded N>10000 (see JCGM 101). Not applied in the case of pure beta emitting radionuclides.
+        Number of Monte-Carlo trials. recommanded N>10000 (see JCGM 101). Not applied in the case of the analytical model.
     kB : float
         Birks constant in cm/keV.
     V : float
         volume of the scintillator in ml.
     mode : string
-        "res" to return the residual, "eff" to return efficiencies.
-    mode2 : string
-        "sym" for symetrical model, "asym" for symetrical model.
+        "eff" to return efficiencies, "dis" to return list of decay events.
     Display : Boolean, optional
         "True" to display details on the decay sampling. The default is False.
     barp : Boolean, optional
@@ -149,25 +121,42 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
     
     Returns
     -------
-    res : float
-        Residuals of the model compared the measurement data for (a) given free parmeters L. (only in mode="res")
     mean_efficiency_S : float
-        Estimation of the efficiency of single counting events. (only in mode="eff")
+        Estimation of the efficiency of single counting events.
     std_efficiency_S : float
-        Standard uncertainty from calculation associated with the estimation of the efficiency of single counting events. (only in mode="eff")
+        Standard uncertainty from calculation associated with the estimation of the efficiency of single counting events.
     mean_efficiency_D : float
-        Estimation of the efficiency of logic sum of double coincidences. (only in mode="eff")
+        Estimation of the efficiency of logic sum of double coincidences.
     std_efficiency_D : float
-        Standard uncertainty from calculation associated with the estimation of the efficiency of logic sum of double coincidences. (only in mode="eff")
+        Standard uncertainty from calculation associated with the estimation of the efficiency of logic sum of double coincidences.
     mean_efficiency_T : float
-        Estimation of the efficiency of triple coincidences. (only in mode="eff")
+        Estimation of the efficiency of triple coincidences.
     std_efficiency_T : float
-        Standard uncertainty from calculation associated with the estimation of the efficiency of triple coincidences. (only in mode="eff")    
+        Standard uncertainty from calculation associated with the estimation of the efficiency of triple coincidences.
+    mean_efficiency_AB : float
+        detection efficiency of coincidences between channels A and B.
+    std_efficiency_AB : float
+        standard uncertainty of detection efficiency of coincidences between channels A and B.
+    mean_efficiency_BC : float
+        detection efficiency of coincidences between channels B and C.
+    std_efficiency_BC : float
+        standard uncertainty of Ddetection efficiency of coincidences between channels B and C.
+    mean_efficiency_AC : float
+        detection efficiency of coincidences between channels A and C.
+    std_efficiency_AC : float
+        standard uncertainty of detection efficiency of coincidences between channels A and C.
     mean_efficiency_D2 : float
-        Estimation of the efficiency of double coincidences for C/N systems. (only in mode="eff")
+        detection efficiency of coincidences in a C/N system.
     std_efficiency_D2 : float
-        Standard uncertainty from calculation associated with the estimation of the efficiency of double coincidences for C/N systems. (only in mode="eff")
+        standard uncertainty of detection efficiency of coincidences in a C/N system.
     """
+    
+    if isinstance(L, (tuple, list)):
+        symm = False
+    else:
+        symm = True
+    
+    
     if record:
         temp_dir = tempfile.gettempdir()
         recfile1 = os.path.join(temp_dir, "Temp_E0.txt")
@@ -228,17 +217,13 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
         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
+        out=tl.modelAnalytical(L,1,1,1,1,Rad,kB,V,mode,symm,nE)
         if mode == "eff":
             return out[0], 0, out[1], 0, out[2], 0
     elif (not Smodel) and (not Rad in radListPureBeta):
         # print("cannot be processed by the analytical model.")
         # print(f"Analytical model used for {Rad}")
-        out=tl.modelAnalytical(L,TD,TAB,TBC,TAC,Rad,kB,V,mode,mode2,1000)
-        if mode == "res":
-            return out
+        out=tl.modelAnalytical(L,1,1,1,1,Rad,kB,V,mode,symm,1000)
         if mode == "eff":
             return out[0], 0, out[1], 0, out[2], 0
     
@@ -269,10 +254,13 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                     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)
+                            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
                             efficiency_S.append(efficiency0_S)
                             efficiency_T.append(efficiency0_T)
                             efficiency_D.append(efficiency0_D)
+                            efficiency_AB.append(efficiency0_AB)
+                            efficiency_BC.append(efficiency0_BC)
+                            efficiency_AC.append(efficiency0_AC)
                             efficiency_D2.append(efficiency0_D2)
                             
                             # print(efficiency0_D, "\n")
@@ -294,15 +282,19 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
                         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)
+            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
             efficiency_S.append(efficiency0_S)
             efficiency_T.append(efficiency0_T)
             efficiency_D.append(efficiency0_D)
+            efficiency_AB.append(efficiency0_AB)
+            efficiency_BC.append(efficiency0_BC)
+            efficiency_AC.append(efficiency0_AC)
             efficiency_D2.append(efficiency0_D2)
                             
             # print(efficiency_D)
-            outEff = tl.efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_D2, N)
-            return outEff
+            outEff = tl.efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_AB, efficiency_BC, efficiency_AC, efficiency_D2, N)
+            if mode == "eff": return outEff
+            if mode == "dis": return efficiency_S, efficiency_D, efficiency_T, efficiency_D2
                 
 
             # temp1, temp2, temp3, temp4 = tl.read_temp_files()
@@ -957,111 +949,15 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             ====================
             '''
             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)
+            efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, efficiency0_D2 = tl.detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime)
             efficiency_S.append(efficiency0_S)
             efficiency_T.append(efficiency0_T)
             efficiency_D.append(efficiency0_D)
+            efficiency_AB.append(efficiency0_AB)
+            efficiency_BC.append(efficiency0_BC)
+            efficiency_AC.append(efficiency0_AC)            
             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
-                    
-            #         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)
-                   
-                    
-                    
-            #         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))                    
+         
 
             """
             ==========================================================
@@ -1070,9 +966,9 @@ def TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=Fals
             """
             if record:
                 with open(recfile4, "a") as file:
-                    if mode2=="sym":
+                    if symm:
                         file.write(f"{idec} {efficiency_S[-1]} {efficiency_D[-1]} {efficiency_T[-1]}\n")
-                    elif mode2=="asym":
+                    else:
                         file.write(f"{idec} {efficiency_S[-1]} {efficiency_D[-1]} {efficiency_T[-1]} {efficiency_AB[-1]} {efficiency_BC[-1]} {efficiency_AC[-1]}\n")
             
         '''
@@ -1080,92 +976,174 @@ 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_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
-        elif mode2=="asym":
-            mean_efficiency_AB = np.mean(efficiency_AB)
-            std_efficiency_AB = np.std(efficiency_AB)/np.sqrt(N)
-            mean_efficiency_BC = np.mean(efficiency_BC)
-            std_efficiency_BC = np.std(efficiency_BC)/np.sqrt(N)
-            mean_efficiency_AC = np.mean(efficiency_AC)
-            std_efficiency_AC = np.std(efficiency_AC)/np.sqrt(N)
-            TDCR_calcul = mean_efficiency_T/mean_efficiency_D
-            TABmodel = mean_efficiency_T/mean_efficiency_AB
-            TBCmodel = mean_efficiency_T/mean_efficiency_BC
-            TACmodel = mean_efficiency_T/mean_efficiency_AC
-        
-        if mode2=="sym":
-            res=(TDCR_calcul-TD)**2
-        elif mode2=="asym":
-            res=(TAB-TABmodel)**2+(TBC-TBCmodel)**2+(TAC-TACmodel)**2
-        
-        if mode == "res":
-            return res
+        mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_AB, std_efficiency_AB, mean_efficiency_BC, std_efficiency_BC, mean_efficiency_AC, std_efficiency_AC, mean_efficiency_D2, std_efficiency_D2 = tl.efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_AB, efficiency_BC, efficiency_AC, efficiency_D2, N)
+                        
         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:
-            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
+            return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_AB, std_efficiency_AB, mean_efficiency_BC, std_efficiency_BC, mean_efficiency_AC, std_efficiency_AC, mean_efficiency_D2, std_efficiency_D2
         if mode =="dis":
             return efficiency_S, efficiency_D, efficiency_T, efficiency_D2
 
-# L = 1
-# TD = 0.977667386529166
-# TAB = 0.992232838598821
-# TBC = 0.992343419459002
-# TAC = 0.99275350064608
-# Rad="H-3"
-# pmf_1="1"
-# N = 100
-# kB =1.0e-5
-# V = 10
-# mode = "eff"
-# mode2 = "sym"
+def objectFct(L, TD, Rad, pmf_1, N, kB, V):
+    """
+    Objective function to minimize in order the estimate the detection efficiencies based on the measurements.
 
-# out = TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2, Display=False, barp=False, Smodel=False, uncData=False)
+    Parameters
+    ----------
+    L : float or tuple
+        If L is float, then L is the global free parameter. If L is tuple, then L is a triplet of free parameters. unit keV-1
+    TD : float or tuple
+        measurements. If TD is float, then TD is the measured TDCR parameter. If TD is tuple, then TD must contain the global TDCR parameter followed by specific ones (T/B, T/AB, T/BC, T/AC)
+    Rad : string
+        List of radionuclides (eg. "H-3, Co-60").
+    pmf_1 : string
+        list of probability of each radionuclide (eg. "0.8, 0.2").
+    N : integer
+        Number of Monte-Carlo trials. recommanded N>10000 (see JCGM 101). Not applied in the case of the analytical model.
+    kB : float
+        Birks constant in cm/keV.
+    V : float
+        volume of the scintillator in ml.
+
+    Returns
+    -------
+    res : float
+        The residual value.
+
+    """
+    
+    if isinstance(TD, (tuple, list)):
+        symm = False
+    else:
+        symm = True
+        
+    if symm:
+        eff_model = TDCRPy(L, Rad, pmf_1, N, kB, V, readRecHist = True)
+        TDCR_calcul = eff_model[4]/eff_model[2]
+        res=(TDCR_calcul-TD)**2
+    else:
+        eff_model = TDCRPy(L, Rad, pmf_1, N, kB, V, readRecHist = True)
+        TAB_calcul = eff_model[4]/eff_model[6]
+        TBC_calcul = eff_model[4]/eff_model[8]
+        TAC_calcul = eff_model[4]/eff_model[10]
+        res=(TD[1]-TAB_calcul)**2+(TD[2]-TBC_calcul)**2+(TD[3]-TAC_calcul)**2        
+    
+    return res
+
+def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False):
+    """
+    Caclulation of the efficiency of a TDCR system based on the model TDCRPy.
+    This function includes optimization procedures from scipy.
+
+    Parameters
+    ----------
+    TD : float or tuple
+        measurements. If TD is float, then TD is the measured TDCR parameter. If TD is tuple, then TD must contain the global TDCR parameter followed by specific ones (T/B, T/AB, T/BC, T/AC)
+    Rad : string
+        List of radionuclides (eg. "H-3, Co-60").
+    pmf_1 : string
+        list of probability of each radionuclide (eg. "0.8, 0.2").
+    kB : float
+        Birks constant in cm/keV.
+    V : float
+        volume of the scintillator in ml.
+    N : interger, optional
+        number of Monte-Carlo trials. The default is 10000.
+    maxiter : interger, optional
+        maximum number of iterations of the optimization procedures
+    xatol : float
+        convergence parameter of the Nelder Mead optimisation
+    disp : Boolean
+        to display detailed results of the procedure. Default is False.
+
+    Returns
+    -------
+    L0 : float
+        global free parameter.
+    L : tuple
+        free parameters (relevant for the asymetric model).
+    eff_S : float
+        counting efficiency of single events.
+    u_eff_S : float
+        standard uncertainty of eff_S.
+    eff_D : float
+        counting efficiency of double coincidences.
+    u_eff_D : float
+        standard uncertainty of eff_D.
+    eff_T : float
+        counting efficiency of triple coincidences.
+    u_eff_T : float
+        standard uncertainty of eff_T.
+    eff_AB : float
+        counting efficiency of coincidences AB.
+    u_eff_AB : float
+        standard uncertainty of eff_AB.
+    eff_BC : float
+        counting efficiency of coincidences BC.
+    u_eff_BC : float
+        standard uncertainty of eff_BC.
+    eff_AC : float
+        counting efficiency of coincidences AC.
+    u_eff_AC : float
+        standard uncertainty of eff_AC.    
+    eff_D : float
+        counting efficiency of double coincidences in C/N configuation (not relevant).
+    u_eff_D : float
+        standard uncertainty of eff_D in C/N configuation (not relevant).
+
+    """
+    if isinstance(TD, (tuple, list)):
+        symm = False
+    else:
+        symm = True
+    
+    if symm: r=opt.minimize_scalar(objectFct, args=(TD, Rad, pmf_1, N, kB, V), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
+    else: r=opt.minimize_scalar(objectFct, args=(TD[0], Rad, pmf_1, N, kB, V), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
+    L0=r.x
+    L=(L0, L0, L0)
+    print(f"global free parameter = {L0} keV-1")
+    
+    if not symm:
+        r=opt.minimize(objectFct, L, args=(TD, Rad, pmf_1, N, kB, V), method='nelder-mead',options={'xatol': xatol, 'disp': disp, 'maxiter':maxiter})
+        L=r.x
+        print(f"free parameters = {L} keV-1")   
 
-# print(out)
+    if symm: out=TDCRPy(L0, Rad, pmf_1, N, kB, V, readRecHist = True)
+    else: out=TDCRPy(L, Rad, pmf_1, N, kB, V, readRecHist = True)
+    eff_S = out[0]
+    u_eff_S = out[1]
+    eff_D = out[2]
+    u_eff_D = out[3]
+    eff_T = out[4]
+    u_eff_T = out[5]
+    eff_AB = out[6]
+    u_eff_AB = out[7]
+    eff_BC = out[8]
+    u_eff_BC = out[9]
+    eff_AC = out[10]
+    u_eff_AC = out[11]
+    eff_D2 = out[12]
+    u_eff_D2 = out[13]
+    
+    return L0, L, eff_S, u_eff_S, eff_D, u_eff_D, eff_T, u_eff_T, eff_AB, u_eff_AB, eff_BC, u_eff_BC, eff_AC, u_eff_AC, eff_D2, u_eff_D2
 
-# L = 1
-# TD = 0.977667386529166
-# TAB = 0.992232838598821
-# TBC = 0.992343419459002
-# TAC = 0.99275350064608
+
+# # L = 1
+# # L = (1.1, 1.05, 1.15)
+# # TD = 0.977667386529166
+# TD = (0.977667386529166, 0.992232838598821, 0.992343419459002, 0.99275350064608)
+# # TD = (0.977667386529166, 0.995232838598821, 0.990343419459002, 0.99275350064608)
 # Rad="Co-60"
 # pmf_1="1"
-# N = 5
+# N = 1000
 # 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, 20, kB, V, mode, mode2, Display=True, barp=False, Smodel=True, syst = "TDCR", record = "phf1", uncData=False)
+# # out = TDCRPy(L, Rad, pmf_1, N, kB, V, Display = False, record = True, readRecHist = False)
+# # print("result", out)
+# # out = TDCRPy(L, Rad, pmf_1, N, kB, V, Display = False, record = False, readRecHist = True)
+# # print("result", out)
 
-# 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)
+# out = eff(TD, Rad, pmf_1, kB, V, N=1000, L=1, maxiter=20, xatol=1e-7)
+# print(out)

tdcrpy/TDCR_model_lib.py

@@ -2624,7 +2624,7 @@ def relaxation_atom_ph(lacune,element,v):
 
 
 
-def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,mode2,ne):
+def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,symm,ne):
     """
     TDCR analytical model that is used for pure beta emitting radionuclides
     
@@ -2648,8 +2648,8 @@ def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,mode2,ne):
         volume of the scintillator in ml. run only for 10 ml
     mode : string
         "res" to return the residual, "eff" to return efficiencies.
-    mode2 : string
-        "sym" for symetrical model, "asym" for symetrical model.
+    symm : boolean
+        "True" for symetrical model, "False" for symetrical model.
     nE : integer
          Number of bins for the quenching function.
     
@@ -2675,14 +2675,13 @@ def modelAnalytical(L,TD,TAB,TBC,TAC,rad,kB,V,mode,mode2,ne):
         em[i] = Em_e(ei*1e3,ei*1e3,kB*1e3,ne)*1e-3
         
         
-    if mode2=="sym":
+    if symm:
         eff_S = sum(p*(1-np.exp(-L*em/3)))
         eff_T = sum(p*(1-np.exp(-L*em/3))**3)
         eff_D = sum(p*(3*(1-np.exp(-L*em/3))**2-2*(1-np.exp(-L*em/3))**3))
         TDCR_calcul=eff_T/eff_D
         res=(TDCR_calcul-TD)**2
-
-    if mode2=="asym":
+    else:
         # eff_A = sum(p*(1-np.exp(-L[0]*em/3)))
         # eff_B = sum(p*(1-np.exp(-L[1]*em/3)))
         # eff_C = sum(p*(1-np.exp(-L[2]*em/3)))
@@ -2830,8 +2829,51 @@ 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":
+def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, extDT, measTime):
+    """
+    Calculate detection probabilities for LS counting systems - see Broda, R., Cassette, P., Kossert, K., 2007. Radionuclide metrology using liquid scintillation counting. Metrologia 44. https://doi.org/10.1088/0026-1394/44/4/S06 
+
+    Parameters
+    ----------
+    L : float or tuple
+        If L is float, then L is the global free parameter. If L is tuple, then L is a triplet of free parameters. unit keV-1
+    e_quenching : list
+        List of quenched deposited energies from prompt particles in keV.
+    e_quenching2 : list
+        List of quenched deposited energies from delayed particles in keV.
+    t1 : float
+        decay time of the delayed transitions in s.
+    evenement : interger
+        number of pulses per decay (prompt (1), prompt + delayed (2)).
+    extDT : float
+        extended dead time of the system in ns.
+    measTime : float
+        measurement time in minutes.
+
+    Returns
+    -------
+    efficiency0_S : float
+        detection probability of single event.
+    efficiency0_D : float
+        detection probability of double coincidences.
+    efficiency0_T : float
+        detection probability of triple coincidences.
+    efficiency0_AB : float
+        detection probability of coincidences between channels A and B.
+    efficiency0_BC : float
+        detection probability of coincidences between channels B and C.
+    efficiency0_AC : float
+        detection probability of coincidences between channels A and C.
+    efficiency0_D2 : float
+        detection probability of coincidences in a C/N system.
+
+    """
+    if isinstance(L, (tuple, list)):
+        symm = False
+    else:
+        symm = True
+        
+    if symm:
         # print(evenement !=1, t1 > extDT*1e-6, t1 < measTime*60)
         if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
             # TDCR
@@ -2842,12 +2884,17 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extD
             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)
+            efficiency0_AB = (efficiency0_D+2*efficiency0_T)/3
+            efficiency0_BC = efficiency0_AB
+            efficiency0_AC = efficiency0_AB
             
             # CN
             p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
             p_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_A2 = p_single+p_single2
+            efficiency0_B2 = efficiency0_A2
             efficiency0_D2 = p_single**2+p_single2**2
         else:
             # TDCR
@@ -2856,14 +2903,19 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extD
             efficiency0_S = 1-p_nosingle**3
             efficiency0_T = p_single**3
             efficiency0_D = 3*(p_single)**2-2*efficiency0_T
+            efficiency0_AB = (efficiency0_D+2*efficiency0_T)/3
+            efficiency0_BC = efficiency0_AB
+            efficiency0_AC = efficiency0_AB
             
             # CN
             p_nosingle = np.exp(-L*np.sum(np.asarray(e_quenching))/2) # probability to have 0 electrons in a PMT
             p_single = 1-p_nosingle                                    # probability to have at least 1 electrons in a PMT            
+            efficiency0_A2 = p_single
+            efficiency0_B2 = efficiency0_A2
             efficiency0_D2 = p_single**2
         
                             
-    elif mode2=="asym":
+    else:
         if evenement !=1 and t1 > extDT*1e-6 and t1 < measTime*60:
             # TDCR            
             pA_nosingle = np.exp(-L[0]*np.sum(np.asarray(e_quenching))/3) # probability to have 0 electrons in a PMT
@@ -2928,19 +2980,81 @@ def detectProbabilities(L, e_quenching, e_quenching2, t1, evenement, mode2, extD
             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        
+    return efficiency0_S, efficiency0_D, efficiency0_T, efficiency0_AB, efficiency0_BC, efficiency0_AC, 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
+def efficienciesEstimates(efficiency_S, efficiency_D, efficiency_T, efficiency_AB, efficiency_BC, efficiency_AC, efficiency_D2, N):
+    """
+    Calculate detection efficiencies from list of detection probabilities per decays.
+
+    Parameters
+    ----------
+    efficiency0_S : float
+        detection probability of single event.
+    efficiency0_D : float
+        detection probability of double coincidences.
+    efficiency0_T : float
+        detection probability of triple coincidences.
+    efficiency0_AB : float
+        detection probability of coincidences between channels A and B.
+    efficiency0_BC : float
+        detection probability of coincidences between channels B and C.
+    efficiency0_AC : float
+        detection probability of coincidences between channels A and C.
+    efficiency0_D2 : float
+        detection probability of coincidences in a C/N system.
+    N : interger
+        number of simulated decays.
+
+    Returns
+    -------
+    mean_efficiency_S : float
+        detection efficiency of single event.
+    std_efficiency_S : float
+        standard uncertainty of detection efficiency of single event.
+    mean_efficiency_D : float
+        detection efficiency of double coincidences.
+    std_efficiency_D : float
+        standard uncertainty of detection efficiency of double coincidences.
+    mean_efficiency_T : float
+        detection efficiency of triple coincidences.
+    std_efficiency_T : float
+        standard uncertainty of detection efficiency of triple coincidences.
+    mean_efficiency_AB : float
+        detection efficiency of coincidences between channels A and B.
+    std_efficiency_AB : float
+        standard uncertainty of detection efficiency of coincidences between channels A and B.
+    mean_efficiency_BC : float
+        detection efficiency of coincidences between channels B and C.
+    std_efficiency_BC : float
+        standard uncertainty of Ddetection efficiency of coincidences between channels B and C.
+    mean_efficiency_AC : float
+        detection efficiency of coincidences between channels A and C.
+    std_efficiency_AC : float
+        standard uncertainty of detection efficiency of coincidences between channels A and C.
+    mean_efficiency_D2 : float
+        detection efficiency of coincidences in a C/N system.
+    std_efficiency_D2 : float
+        standard uncertainty of detection efficiency of coincidences in a C/N system.
+
+    """
+    mean_efficiency_S = np.mean(efficiency_S)
+    std_efficiency_S = np.std(efficiency_S)/np.sqrt(N)
     mean_efficiency_D = np.mean(efficiency_D)
     std_efficiency_D = np.std(efficiency_D)/np.sqrt(N)
+    mean_efficiency_T = np.mean(efficiency_T) # average
+    std_efficiency_T = np.std(efficiency_T)/np.sqrt(N)   # standard deviation
+    mean_efficiency_AB = np.mean(efficiency_AB)
+    std_efficiency_AB = np.std(efficiency_AB)/np.sqrt(N)
+    mean_efficiency_BC = np.mean(efficiency_BC)
+    std_efficiency_BC = np.std(efficiency_BC)/np.sqrt(N)
+    mean_efficiency_AC = np.mean(efficiency_AC)
+    std_efficiency_AC = np.std(efficiency_AC)/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
+
+    return mean_efficiency_S, std_efficiency_S, mean_efficiency_D, std_efficiency_D, mean_efficiency_T, std_efficiency_T, mean_efficiency_AB, std_efficiency_AB, mean_efficiency_BC, std_efficiency_BC, mean_efficiency_AC, std_efficiency_AC, mean_efficiency_D2, std_efficiency_D2
     
 
 

tdcrpy/__init__.py

@@ -1,4 +1,3 @@
 from tdcrpy import TDCRPy
 from tdcrpy import TDCR_model_lib
-from tdcrpy import TDCRoptimize
 from tdcrpy.test import test_tdcrpy