TDCRPy 2.0.2__py3-none-any.whl → 2.0.5__py3-none-any.whl

TDCRPy-2.0.5.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: TDCRPy
+Version: 2.0.5
+Summary: TDCR model
+Home-page: https://pypi.org/project/TDCRPy/
+Author: RomainCoulon (Romain Coulon)
+Author-email: <romain.coulon@bipm.org>
+Project-URL: Documentation, https://github.com/RomainCoulon/TDCRPy/
+Keywords: Python,TDCR,Monte-Carlo,radionuclide,scintillation,counting
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Natural Language :: French
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE.md
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Requires-Dist: setuptools
+Requires-Dist: scipy
+Requires-Dist: configparser
+Requires-Dist: importlib.resources
+Requires-Dist: matplotlib
+
+# TDCRPy
+
+`TDCRPy` is a Python code to calculate detection efficiency of a liquid scintillation counter using 3-photomultiplier tubes.
+The calculation is based on the photo-physical model called of the Triple-to-Double-Coincidence-Ratio method (TDCR) and a Monte-Carlo sampling allowing to adress complexe decay schemes and radionuclide mixtures.
+
+The code is developped and maintained by the BIPM (MIT license).
+
+## Installation
+
+`TDCRPy` requires that the following packages are installed in your `Python` environement.
+
+```shell
+pip install importlib.resources configparser numpy tqdm setuptools scipy
+```
+or in `conda` environement:
+
+```shell
+conda install importlib.resources configparser numpy tqdm setuptools scipy
+```
+
+Then, `TDCRPy` can be installed.
+
+```shell
+pip install TDCRPy
+```
+
+To obtain the last version.
+
+```shell
+pip install TDCRPy --upgrade
+```
+
+The module can be imported in your Python code such as.
+
+```python
+import tdcrpy
+```
+
+## Test
+
+To run the unit tests of the package:
+
+```shell
+python -m unittest tdcrpy.test.test_tdcrpy
+```
+
+or (using the coverage package)
+
+```shell
+coverage run -m unittest tdcrpy.test.test_tdcrpy
+coverage report -m
+```
+
+

{TDCRPy-2.0.2.dist-info → TDCRPy-2.0.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tdcrpy/TDCRPy.py,sha256=Q6ksEJQvjNgbcWPiWFAcT0QDBCN2x5lHs_W4Leh7KO0,61092
+tdcrpy/TDCRPy.py,sha256=WRH8ASoJSEXAl3Vw0t01DZelIJ4Kguu97nEriHuLq-g,64862
 tdcrpy/TDCRPy1.py,sha256=QTBZh5B5JWnGB0BQfD-cFmwA9W080OD4sG-aj50-ejo,38106
 tdcrpy/TDCR_model_lib.py,sha256=gnWWLG96hdT0uFkL0sE4CMuXNcP6DTQ3S3Jq_jwnYMg,125487
 tdcrpy/TDCRoptimize.py,sha256=c2XIGveeLdVYYek4Rg6dygMvVA2xIrIkMb3L-_jUucM,6496
@@ -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-2.0.2.dist-info/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
-TDCRPy-2.0.2.dist-info/METADATA,sha256=FEl2Wv8r3dccx-1t4dCcsKKRtcDwVfxKzLxtlHyR3qM,15831
-TDCRPy-2.0.2.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
-TDCRPy-2.0.2.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
-TDCRPy-2.0.2.dist-info/RECORD,,
+TDCRPy-2.0.5.dist-info/LICENCE.md,sha256=ZTpWyGU3qv_iwEpgvCijoCuCYpOPpyzJCgOk46WpUKU,1066
+TDCRPy-2.0.5.dist-info/METADATA,sha256=mqrbgVTMHYmh9bx5x0SvHIbIQJbnqqAkW73WyWxVFUA,2233
+TDCRPy-2.0.5.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+TDCRPy-2.0.5.dist-info/top_level.txt,sha256=f4vzFFcKSEnonAACs0ZXuRczmroLLqtPTqXFymU_VU0,14
+TDCRPy-2.0.5.dist-info/RECORD,,

{TDCRPy-2.0.2.dist-info → TDCRPy-2.0.5.dist-info}/WHEEL

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

tdcrpy/TDCRPy.py

@@ -1129,10 +1129,107 @@ def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False)
     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
-# L = (1.1, 1.05, 1.15)
-# # # TD = 0.977667386529166
-# TD = (0.977667386529166, 0.992232838598821, 0.992343419459002, 0.99275350064608)
+# def effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7, disp=False):
+#     """
+#     Caclulation of the efficiency of a TDCR system based on the model TDCRPy (analytical model).
+#     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.
+#     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(tl.modelAnalytical, args=(TD, TD, TD, TD, Rad, kB, V, "res", True, 1e3), method='bounded', bounds = (0.1, 5), options={'disp': disp, 'maxiter':maxiter})
+#     else: r=opt.minimize_scalar(tl.modelAnalytical, args=(TD[0], TD[1], TD[2], TD[3], Rad, kB, V, "res", True, 1e3), 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(tl.modelAnalytical, L, args=(TD[0], TD[1], TD[2], TD[3], Rad, kB, V, "res", True, 1e3), method='nelder-mead',options={'xatol': xatol, 'disp': disp, 'maxiter':maxiter})
+#         L=r.x
+#         print(f"free parameters = {L} keV-1")   
+
+#     if symm: out=tl.modelAnalytical(L, TD, TD, TD, TD, Rad, kB, V, "eff", True, 1e3)
+#     else: out=tl.modelAnalytical(L, TD[0], TD[1], TD[2], TD[3], Rad, kB, V, "eff", True, 1e3)
+#     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]
+    
+#     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
+
+
+
+
+
+# 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"
@@ -1142,10 +1239,11 @@ def eff(TD, Rad, pmf_1, kB, V, N=10000, L=1, maxiter=20, xatol=1e-7, disp=False)
 # mode = "eff"
 
 
-# # 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, 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 = eff(TD, Rad, pmf_1, kB, V, N=1000, L=1, maxiter=20, xatol=1e-7)
+# # out = eff(TD, Rad, pmf_1, kB, V, N=1000, L=1, maxiter=20, xatol=1e-7)
+# out = effA(TD, Rad, pmf_1, kB, V, L=1, maxiter=20, xatol=1e-7)
 # print(out)

TDCRPy-2.0.2.dist-info/METADATA

@@ -1,334 +0,0 @@
-Metadata-Version: 2.1
-Name: TDCRPy
-Version: 2.0.2
-Summary: TDCR model
-Home-page: https://pypi.org/project/TDCRPy/
-Author: RomainCoulon (Romain Coulon)
-Author-email: <romain.coulon@bipm.org>
-Project-URL: Documentation, https://github.com/RomainCoulon/TDCRPy/
-Keywords: Python,TDCR,Monte-Carlo,radionuclide,scintillation,counting
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Natural Language :: French
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: Unix
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENCE.md
-Requires-Dist: numpy
-Requires-Dist: tqdm
-Requires-Dist: setuptools
-Requires-Dist: scipy
-Requires-Dist: configparser
-Requires-Dist: importlib.resources
-Requires-Dist: matplotlib
-
-# TDCRPy
-
-`TDCRPy` is a Python code to calculate detection efficiency of a liquid scintillation counter using 3-photomultiplier tubes.
-The calculation is based on the photo-physical model called of the Triple-to-Double-Coincidence-Ratio method (TDCR) and a Monte-Carlo sampling allowing to adress complexe decay schemes and radionuclide mixtures.
-
-The code is developped and maintained by the BIPM (MIT license).
-
-## Installation
-
-`TDCRPy` requires that the following packages are installed in your `Python` environement.
-
-```shell
-pip install importlib.resources configparser numpy tqdm setuptools scipy
-```
-or in `conda` environement:
-
-```shell
-conda install importlib.resources configparser numpy tqdm setuptools scipy
-```
-
-Then, `TDCRPy` can be installed.
-
-```shell
-pip install TDCRPy
-```
-
-To obtain the last version.
-
-```shell
-pip install TDCRPy --upgrade
-```
-
-The module can be imported in your Python code such as.
-
-```python
-import tdcrpy
-```
-
-## Test
-
-To run the unit tests of the package:
-
-```shell
-python -m unittest tdcrpy.test.test_tdcrpy
-```
-
-or (using the coverage package)
-
-```shell
-coverage run -m unittest tdcrpy.test.test_tdcrpy
-coverage report -m
-```
-
-## User guide
-
-At first, the TDCRPy module must be imported.
-
-```python
-import tdcrpy
-```
-### TDCRPy()
-
-The main function of the TDCRPy module is `TDCRPy()` in which the Monte-Carlo Triple-to-Double Coincidence Ratio model is implemented. The computation is made for a given solution containing a radionuclide (or a mixture of radionuclides) `rad`, 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 (or a triplet) of the free parameter(s) `L`. The measurement data is not used is this mode.
-*  In `mode="res"`, it calculates the residual of the TDCR model parametrized by a value (or triplet) of the free parameter(s) `L` and the measurement data `TD`, `TAB`, `TBC`, `TAC`. This residual is used in the optimisation procedure `tdcrpy.TDCRoptimize.eff()` that aims to estimate the dection efficiency of the TDCR system (see above).
-
-Also, two configurations can be set:
-
-* In `mode2="sym"`, the symmetry is considered between the 3 photomultiplier tubes (PMTs). Here, the free parameter `L` is a scalar and only the global TDCR value `TD` is used as measurement data.
-* In `mode2="asym"`, a possible asymmetry between the 3 photomultiplier tubes is considered in the model. Here, the free parameter `L` is a triplet corresponding to each PMTs and only the specific TDCR values `TAB`, `TBC` and `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() is parametrised by the following parameters:
-*  `L` is the free parameter(s) in keV^-1^. It represents the number of photoelectrons produced by the PMTs per unit of ionisation energy released in the scintillator during a decay without considering the scintillation quenching. It is of type `float` when `mode2="sym"` and of type `tuple` or `list` when `mode2="asym"`.
-*  `TD` (type `float`) is the quotient of the triple coincidence count rate divided by the logic sum of the double coincidence count rate.
-*  `TAB` (type `float`) is the quotient of the triple coincidence count rate divided by the double coincidence count rate between the channel A and B.
-*  `TBC` (type `float`) is the quotient of the triple coincidence count rate divided by the double coincidence count rate between the channel B and C.
-*  `TAC` (type `float`) is the quotient of the triple coincidence count rate divided by the double coincidence count rate between the channel A and C.
-*  `rad` (type `string`) is the list of radionuclides contained in the solution, e.g. `"H-3"`, `"H-3, Co-60"`.
-*  `pmf_1` (type `string`) is the probability of each radionuclide contained in `rad`. If `rad = "H-3, Co-60"` and `pmf_1="0.8, 0.2"`, the solution contains 80 % of tritium and 20 % of cobalt 60.
-*  `N` (type `integer`) is the number of Monte-Carlo trials corresponding each to a simulated nuclear decay in the scintillator. Monte-Carlo calculation is not used in the case of pure beta emitting radionuclides where the analytical model is implemented.
-*  `kB` (type `float`) is the Birks constant caracterizing the scintillator. It is espressed in cm/keV.
-*  `V` (type `float`) is the volume in ml of the scintillator.
-*  `mode` sets the type of output: `mode="res"` to return the residual, `mode="eff"` to return efficiencies.
-*  `mode2` sets whether the TDCR system has to be considered as symetrical by the model `mode2="sym"` or not symetrical `mode2="asym"`.
-*  `Display` (type `boolean`) is an optional parameter set by default, `Display=False`. If `Display=True`, detailed on the simulated decays are displayed.
-*  `barp` (type `boolean`) is an optional parameter set by default, `barp=False`. If `barp=True`, the progression bar of the calculation is displayed.
-*  `Smodel` (type `boolean`) is an optional parameter set by default, `Smodel=True`. If `barp=True`, the stochastic model is applied otherwise the analytical model is applied (suitable for pure beta emitters).
-*  `uncData` (type `boolean`) is an optional parameter set by default, `uncData=False`. If `uncData=True`, the unceratainty on transition probabilities are propagated by MC sampling (still under study).
-
-
-In  `mode="eff"`, `TDCRPy()` returns a `tuple` composed of:
-*  the estimation of the counting efficiency of single events *S*,
-*  the standard uncertainty of the estimation of *S*,
-*  the estimation of the counting efficiency of double coincidences *D*,
-*  the standard uncertainty of the estimation of *D*,
-*  the estimation of the counting efficiency of triple coincidences *T*,
-*  the standard uncertainty of the estimation of *T*,
-
-Example: 
-
-```python
-import tdcrpy
-
-L = 1.5
-TD = 0.977667386529166
-TAB = 0.992232838598821
-TBC = 0.992343419459002
-TAC = 0.99275350064608
-Rad="Co-60"
-pmf_1="1"
-N = 100
-kB =1.0e-5
-V = 10
-mode = "eff"
-mode2 = "sym"
-
-result = tdcrpy.TDCRPy.TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2)
-
-print("efficiency S = ", round(result[0],4), "+/-", round(result[1],4))
-print("efficiency D = ", round(result[2],4), "+/-", round(result[3],4))
-print("efficiency T = ", round(result[4],4), "+/-", round(result[5],4))
-```
-
-```Console
-efficiency S =  0.9875 +/- 0.007
-efficiency D =  0.9903 +/- 0.0072
-efficiency T =  0.9749 +/- 0.0121
-```
-
-In  `mode="res"`, TDCRPy() returns the residuals *R* (type `float`) of the TDCR model for the given value of the free parameter `L`.
-
-Example: 
-
-```python
-import tdcrpy
-
-L = 1.5
-TD = 0.977667386529166
-TAB = 0.992232838598821
-TBC = 0.992343419459002
-TAC = 0.99275350064608
-Rad="Co-60"
-pmf_1="1"
-N = 100
-kB =1.0e-5
-V = 10
-mode = "res"
-mode2 = "sym"
-
-result = tdcrpy.TDCRPy.TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2)
-
-print("R = ",result)
-```
-
-```Console
-R =  9.72238771394384e-06
-```
-
-When a triplet of free parameters is considered, `L` is of type `tuple` and `mode2 = "asym"`. It must be noted that the calculation time is three times higher than in the symetrical model. 
-
-Example: 
-
-```python
-import tdcrpy
-
-L = (1.5, 1.2, 1.4)
-TD = 0.977667386529166
-TAB = 0.992232838598821
-TBC = 0.992343419459002
-TAC = 0.99275350064608
-Rad="Co-60"
-pmf_1="1"
-N = 100
-kB =1.0e-5
-V = 10
-mode = "res"
-mode2 = "asym"
-
-result = tdcrpy.TDCRPy.TDCRPy(L, TD, TAB, TBC, TAC, Rad, pmf_1, N, kB, V, mode, mode2)
-
-print("R = ",result)
-```
-
-```Console
-R =  1.4353680366705997e-05
-```
-
-By default, the Monte-Carlo model is not applied for the following list radionuclides when used solely (not in a mixture): ^3^H, ^14^C, ^35^S, ^45^Ca, ^63^Ni, ^89^Sr, ^90^Sr, ^99^Tc, ^147^Pm, ^241^Pu. In the latter cases, the analytical model is applied and the calculation time does not dependent to the parameter `N`.
-
-### Advance settings
-
-An advanced setting can be configured in the `config.toml` file for functions `TDCRPy.TDCRPy()` and `TDCRoptimize.eff()`. In this file:
-*  The number of bins to discretize the linear energy space for quenching calculation can be adjusted. `nE_electron` and `nE_alpha` parameters for respectively electrons and alpha particles are respectiveley set by default such as `nE_electron = 1000` and `nE_alpha = 1000`.
-* 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` (default `density=0.96`), the mean charge number `Z` (default `Z=5.2`) and the mean mass number `A` (default `A=11.04`) of the scintillator.
-* To process photoelectric interactions, the atomic concentration of the scintillator is spectified. By default `pH = 0.578772`, `pC = 0.338741`, `pN = 0.000302`, `pO = 0.082022`, `pP = 0.000092`, `pCl = 0.000071`
-* A correction due reverse micelles in the scintillator is implemented. It is by default activated `micCorr = True`. The diameter of the micelles and the fraction of aqueous solution is specified. By defaut `diam_micelle = 2`, `fAq = 0.1`
-* The coincidence resolving time of the LS counter is specified (in ns). By default `tau = 50`.
-* To optimize the speed of the Monte-Carlo calculation, a spline interpolation on precalculated quenched energy is applied. The parameter `depthSpline` (default `depthSpline = 5`) sets the number of bins on each side of the energy point on which the interpolation is applied. The parameter `Einterp_a` for alpha particles and `Einterp_e` for electrons (default `Einterp_a = 100` keV, `Einterp_e = 1.5` keV) set the energy (in keV) above which the interpolation is applied.
-
-### TDCRoptimize.eff()
-
-An optimization procedure `TDCRoptimize.eff()` is proposed to estimate the counting efficiency of a TDCR system. It approximates the free parameter(s) `L` in order to minimize the residual estimated by `TDCRPy()` for a given set of measurement data. In `mode2 = "sym"`, the *golden section search technique* is applied with a maximum number of iterations of 20. In `mode2 = "asym"`, the *Nelder-Mead technique* is applied with a maximum number of iterations of 20.
-
-`TDCRoptimize.eff()` is parametrised by the following parameters:
-*  `TD` (type `float`) is the quotient of the triple coincidence count rate divided by the logic sum of the double coincidence count rate.
-*  `TAB` (type `float`) is the quotient of the triple coincidence count rate divided by the double coincidence count rate between the channel A and B.
-*  `TBC` (type `float`) is the quotient of the triple coincidence count rate divided by the double coincidence count rate between the channel B and C.
-*  `TAC` (type `float`) is the quotient of the triple coincidence count rate divided by the double coincidence count rate between the channel A and C.
-*  `rad` (type `string`) is the list of radionuclides contained in the solution, e.g. `"H-3"`, `"H-3, Co-60"`.
-*  `pmf_1` (type `string`) is the probability of each radionuclide contained in `rad`. If `rad = "H-3, Co-60"` and `pmf_1="0.8, 0.2"`, the solution contains 80 % of tritium and 20 % of cobalt 60.
-*  `kB` (type `float`) is the Birks constant caracterizing the scintillator. It is espressed in cm/keV.
-*  `V` (type `float`) is the volume in ml of the scintillator.
-*  `mode2` sets whether the TDCR system has to be considered symetrical `mode2="sym"` or not symetrical `mode2="asym"`.
-*  `N` (type `integer`) is the number of Monte-Carlo trials corresponding each, to a simulated nuclear decay in the scintillator. Monte-Carlo calculation is not used in the case of pure beta emitting radionuclides where the analytical model is implemented. It is an optional parameter set by default at `N = 10000`.
-*  `L` (type `float`) initial guess of the free parameter(s) in keV^-1^. It represents the number of photoelectrons produced by the PMTs per unit of ionisation energy released in the scintillator during a decay and in the abscence of scintillation quenching. It is set by default at `L = 1`.
-
-`TDCRoptimize.eff()` returns:
-*  the global free parameter *L*,
-*  the free parameters related to each channel (*L<sub>A</sub>*, *L<sub>B</sub>*, *L<sub>C</sub>*),
-*  the estimation of the counting efficiency of single events *S*,
-*  the standard uncertainty of the estimation of *S*,
-*  the estimation of the counting efficiency of double coincidences *D*,
-*  the standard uncertainty of the estimation of *D*,
-*  the estimation of the counting efficiency of triple coincidences *T*,
-*  the standard uncertainty of the estimation of *T*.
-
-Example with `mode2 = "sym"`: 
-
-```python
-import tdcrpy
-
-TD = 0.977667386529166
-TAB = 0.992232838598821
-TBC = 0.992343419459002
-TAC = 0.99275350064608
-Rad="Co-60"
-pmf_1="1"
-N = 250
-kB =1.0e-5
-V = 10
-mode2 = "sym"
-
-result = tdcrpy.TDCRoptimize.eff(TD, TAB, TBC, TAC, Rad, pmf_1, kB, V, mode2, N=N)
-
-print("Global free parameter = \t", round(result[0],4), " keV-1")
-print("Free parameter (PMT A) = \t", round(result[1][0],4) , " keV-1")
-print("Free parameter (PMT B) = \t", round(result[1][1],4) , " keV-1")
-print("Free parameter (PMT C) = \t", round(result[1][2],4) , " keV-1")
-print("efficiency S = \t", round(result[2],4), "+/-", round(result[3],4))
-print("efficiency D = \t", round(result[4],4), "+/-", round(result[5],4))
-print("efficiency T = \t", round(result[6],4), "+/-", round(result[7],4))
-```
-
-```Console
-Global free parameter = 	 1.3061  keV-1
-Free parameter (PMT A) = 	 1.3061  keV-1
-Free parameter (PMT B) = 	 1.3061  keV-1
-Free parameter (PMT C) = 	 1.3061  keV-1
-efficiency S = 	 0.979 +/- 0.0067
-efficiency D = 	 0.9833 +/- 0.0064
-efficiency T = 	 0.963 +/- 0.0096
-```
-
-Example with `mode2 = "asym"`: 
-
-```python
-import tdcrpy
-
-TD = 0.977667386529166
-TAB = 0.992232838598821
-TBC = 0.992343419459002
-TAC = 0.99275350064608
-Rad="Co-60"
-pmf_1="1"
-N = 250
-kB =1.0e-5
-V = 10
-mode2 = "asym"
-
-result = tdcrpy.TDCRoptimize.eff(TD, TAB, TBC, TAC, Rad, pmf_1, kB, V, mode2, N=N)
-
-print("Global free parameter = \t", round(result[0],4), " keV-1")
-print("Free parameter (PMT A) = \t", round(result[1][0],4) , " keV-1")
-print("Free parameter (PMT B) = \t", round(result[1][1],4) , " keV-1")
-print("Free parameter (PMT C) = \t", round(result[1][2],4) , " keV-1")
-print("efficiency S = \t", round(result[2],4), "+/-", round(result[3],4))
-print("efficiency D = \t", round(result[4],4), "+/-", round(result[5],4))
-print("efficiency T = \t", round(result[6],4), "+/-", round(result[7],4))
-```
-
-```Console
-Global free parameter = 	 1.3061  keV-1
-Free parameter (PMT A) = 	 1.3061  keV-1
-Free parameter (PMT B) = 	 1.3061  keV-1
-Free parameter (PMT C) = 	 1.3061  keV-1
-efficiency S = 	 0.979 +/- 0.0067
-efficiency D = 	 0.9833 +/- 0.0064
-efficiency T = 	 0.963 +/- 0.0096
-```
-