TDCRPy 2.0.1__tar.gz → 2.0.5__tar.gz

tdcrpy-2.0.5/PKG-INFO

@@ -0,0 +1,1774 @@
+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
+```
+
+
+# Modify the parameters of the model (advanced settings)
+
+
+```python
+#pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+```
+
+## Read the parameters
+
+
+```python
+print("\nparameters in a list: ", td.TDCR_model_lib.readParameters(disp=True))
+```
+
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+    parameters in a list:  (1000, 1000, 0.96, 5.2, 11.04, 5, 100.0, 1.5, 2.0, 0.1, 50, 10, 20, False)
+    
+
+### Change energy binning the quenching function of electrons 
+
+
+```python
+td.TDCR_model_lib.modifynE_electron(100)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifynE_electron(1000)
+```
+
+    New configuration:
+    number of integration bins for electrons = 100
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change energy binning the quenching function of alpha particles
+
+
+```python
+td.TDCR_model_lib.modifynE_alpha(100)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifynE_alpha(1000)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 100
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the density (in g/cm3) of the LS source
+
+
+```python
+td.TDCR_model_lib.modifyDensity(1.02)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyDensity(0.96)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 1.02 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the mean charge number of the LS source
+
+
+```python
+td.TDCR_model_lib.modifyZ(5.7)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyZ(5.2)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.7
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the mean atomic mass number of the LS source
+
+
+```python
+td.TDCR_model_lib.modifyA(12.04)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyA(11.04)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 12.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the depht paramerter of the spline interpolation of the quenching function
+
+
+```python
+td.TDCR_model_lib.modifyDepthSpline(7)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyDepthSpline(5)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 7
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the energy threshold (in keV) above which the interpolation is applied (for alpha particles)
+
+
+```python
+td.TDCR_model_lib.modifyEinterp_a(200)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyEinterp_a(100)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 200.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the energy threshold (in keV) above which the interpolation is applied (for electrons)
+
+
+```python
+td.TDCR_model_lib.modifyEinterp_e(2.0)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyEinterp_e(1.5)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 2.0 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Activate/desactivate the micelles correction
+
+
+```python
+td.TDCR_model_lib.modifyMicCorr(False)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyMicCorr(True)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the diameter of reverse micelles (in nm)
+
+
+```python
+td.TDCR_model_lib.modifyDiam_micelle(4.0)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyDiam_micelle(2.0)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 4.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the acqueous fraction of the LS source
+
+
+```python
+td.TDCR_model_lib.modifyfAq(0.2)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyfAq(0.1)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.2
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the coincidence resolving time of the TDCR counter (in ns)
+
+
+```python
+td.TDCR_model_lib.modifyTau(100)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyTau(50)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 100 ns
+    extended dead time = 10 µs
+    measurement time = 20 min
+    
+
+### Change the extended dead time of the TDCR counter (in µs)¶
+
+
+```python
+td.TDCR_model_lib.modifyDeadTime(100)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyDeadTime(10)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 100 µs
+    measurement time = 20 min
+    
+
+### Change the measurement time (in min)¶
+
+
+```python
+td.TDCR_model_lib.modifyMeasTime(60)
+print("New configuration:")
+td.TDCR_model_lib.readParameters(disp=True)
+# back to the default value
+td.TDCR_model_lib.modifyMeasTime(20)
+```
+
+    New configuration:
+    number of integration bins for electrons = 1000
+    number of integration bins for alpha = 1000
+    density = 0.96 g/cm3
+    Z = 5.2
+    A = 11.04
+    depth of spline interp. = 5
+    energy above which interp. in implemented (for alpha) = 100.0 keV
+    energy above which interp. in implemented (for electron) = 1.5 keV
+    activation of the micelle correction = False
+    diameter of micelle = 2.0 nm
+    acqueous fraction = 0.1
+    coincidence resolving time = 50 ns
+    extended dead time = 10 µs
+    measurement time = 60 min
+    
+
+
+# Efficiency curves using TDCRPy
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import numpy as np
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+```
+
+
+```python
+mode = "eff"                # ask for efficiency calculation
+Rad="Co-60"                 # radionuclides
+pmf_1="1"                   # relatives fractions of the radionulides
+N = 1000                     # number of Monte Carlo trials
+kB =1.0e-5                  # Birks constant in cm keV-1
+V = 10                      # volume of scintillator in mL
+L=np.logspace(-3,2,num=100) # free parameter in keV-1
+
+# Record decay histories in temporary files
+td.TDCRPy.TDCRPy(L[0], Rad, pmf_1, N, kB, V, mode, barp=True, record=True)
+
+effS, u_effS, effD, u_effD, effT, u_effT, effD2, u_effD2 = [], [],[], [],[], [], [], []
+for l in tqdm(L, desc="free parameters ", unit=" iterations"):
+  out = td.TDCRPy.TDCRPy(l, Rad, pmf_1, N, kB, V, mode, readRecHist=True)
+  effS.append(out[2])
+  u_effS.append(out[3])
+  effD.append(out[2])
+  u_effD.append(out[3])
+  effT.append(out[4])
+  u_effT.append(out[5])
+  effD2.append(out[12])
+  u_effD2.append(out[13])
+```
+
+    
+     ______  ______  ______ _______  ________
+    |__  __||  ___ \|  ___||  ___ | |  ____ |
+      | |   | |  | || |    | |  | | | |___| |___     ___
+      | |   | |  | || |    | |__| | |  _____|\  \   |  |
+      | |   | |__| || |____|  __  \ | |       \  \  |  |
+      |_|   |_____/ |_____||_|  \__\|_|        \  \_|  |
+      +++++++++++++++++++++++++++++++++++++++++/      /
+      ________________________________________/      /
+     |______________________________________________/     
+    
+    
+    version 2.0.2
+    BIPM 2023 - license MIT 
+    distribution: https://pypi.org/project/TDCRPy 
+    developement: https://github.com/RomainCoulon/TDCRPy 
+    
+    start calculation...
+    
+
+    Processing: 100%|█████████████████████████████████████████████████████████████| 1000/1000 [00:24<00:00, 40.79 decays/s]
+    free parameters : 100%|█████████████████████████████████████████████████████| 100/100 [00:02<00:00, 35.96 iterations/s]
+    
+
+
+```python
+effS=np.asarray(effS)
+effT=np.asarray(effT)
+effD=np.asarray(effD)
+effD2=np.asarray(effD2)
+u_effS=np.asarray(u_effS)
+u_effT=np.asarray(u_effT)
+u_effD=np.asarray(u_effD)
+u_effD2=np.asarray(u_effD2)
+
+tdcr=effT/effD
+u_tdcr=np.sqrt(u_effD**2*effT**2/effD**4+u_effT**2/effD**2)
+
+plt.figure("efficiency vs free parameter")
+plt.clf()
+plt.errorbar(L,effD,yerr=u_effD,fmt="-k",label="double coincidences")
+plt.errorbar(L,effT,yerr=u_effT,fmt="-r",label="triple coincidences")
+plt.errorbar(L,effD2,yerr=u_effD2,fmt="-g",label="double coincidences (CIEMAT/NIST)")
+plt.xscale('log')
+plt.xlabel(r'$L$ /keV$^{-1}$', fontsize=14)
+plt.ylabel(r'$\epsilon$', fontsize=14)
+plt.legend()
+
+plt.figure("efficiency vs TDCR")
+plt.clf()
+plt.errorbar(tdcr,effD,xerr=u_tdcr,yerr=u_effD,fmt="-k")
+#plt.xscale('log')
+plt.xlabel(r'$R_T/R_D$', fontsize=14)
+plt.ylabel(r'$\epsilon_{D}$', fontsize=14)
+```
+
+
+
+
+    Text(0, 0.5, '$\\epsilon_{D}$')
+
+
+
+
+    
+![png](output_4_1.png)
+    
+
+
+
+    
+![png](output_4_2.png)
+    
+
+
+
+# Read Beta spectrum
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import matplotlib.pyplot as plt
+import numpy as np
+```
+
+
+```python
+radionuclide = "Sr-89"
+mode = "beta-" # 'beta-' or 'beta+'
+level = 'tot' # 0,1,2,3 .... or 'tot'
+```
+
+## Get information about the BetaShape version
+
+
+```python
+print(td.TDCR_model_lib.readBetaShapeInfo(radionuclide,mode,level))
+```
+
+    -Beta Spectrum of the main transition from BetaShape 2.4
+     (05/2024), DDEP 2004 evaluation and Q-value from AME2020-
+    
+
+## Read the energy spectrum tabulated from BetaShape
+
+
+```python
+energy, probability = td.TDCR_model_lib.readBetaShape(radionuclide,mode,level)
+
+plt.figure("Energy spectrum")
+plt.clf()
+plt.plot(energy[:-1], probability)
+plt.xlabel(r'$E$ /keV', fontsize=14)
+plt.ylabel(r'$p(E)$ /(keV$^{-1}$)', fontsize=14)
+```
+
+
+
+
+    Text(0, 0.5, '$p(E)$ /(keV$^{-1}$)')
+
+
+
+
+    
+![png](output_7_1.png)
+    
+
+
+## Read the deposited energy spectrum
+
+This spectrum is built by TDCRPy (function `buildBetaSpectra`) to be used for the analytical TDCR model
+
+
+```python
+energy2, probability2 = td.TDCR_model_lib.readBetaSpectra(radionuclide)
+
+plt.figure("Deposied energy spectrum")
+plt.clf()
+plt.plot(energy[:-1], probability,'-b', label="emitted energy spectrum")
+plt.plot(energy2, probability2,'-r', label="deposited energy spectrum")
+plt.legend(fontsize=14)
+plt.xlabel(r'$E$ /keV', fontsize=14)
+plt.ylabel(r'$p(E)$ /(keV$^{-1}$)', fontsize=14)
+```
+
+
+
+
+    Text(0, 0.5, '$p(E)$ /(keV$^{-1}$)')
+
+
+
+
+    
+![png](output_9_1.png)
+    
+
+
+
+```python
+
+```
+
+
+# Estimation of stopping powers in liquid scintillator
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import matplotlib.pyplot as plt
+import numpy as np
+```
+
+## Stopping power at a given energy
+
+
+```python
+density = 0.96 # in g/cm3
+energy = 100 # keV
+result_alpha = td.TDCR_model_lib.stoppingpowerA(energy,rho=density)
+result_electron = td.TDCR_model_lib.stoppingpower(energy*1e3,rho=density)
+print(f"dE/dx = {result_alpha:.7g} keV/cm for alpha particles" )
+print(f"dE/dx = {result_electron*1e3:.4g} keV/cm for electrons" )
+```
+
+    dE/dx = 1461120 keV/cm for alpha particles
+    dE/dx = 3419 keV/cm for electrons
+    
+
+## Plot stopping power curves
+
+
+```python
+energy_vec = np.logspace(-2,4,1000) # in keV
+w_a, w_e = [], []
+for e in energy_vec:
+        w_a.append(td.TDCR_model_lib.stoppingpowerA(e,rho=density))
+        w_e.append(1e3*td.TDCR_model_lib.stoppingpower(e*1e3,rho=density))
+plt.figure("Stopping power")
+plt.clf()
+plt.plot(energy_vec,w_a,"-k",label="alpha particles")
+plt.plot(energy_vec,w_e,"-r",label="electrons")
+plt.xscale('log')
+plt.xlabel(r'$E$ /keV', fontsize=14)
+plt.ylabel(r'd$E$/d$x$ /(keV/cm)', fontsize=14)
+plt.legend()
+```
+
+
+
+
+    <matplotlib.legend.Legend at 0x25d905a4c90>
+
+
+
+
+    
+![png](output_6_1.png)
+    
+
+
+
+# Simulation of the scintillation quenching
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import matplotlib.pyplot as plt
+import numpy as np
+```
+
+## Calculate the quenched energy from the Birks model
+
+
+```python
+kB = 0.01 # Birks constant in cm/MeV
+ei = 1000  # initial energy in keV
+ed = 1000  # deposited energy in keV
+nE = 10000  # number of points of the energy linear space
+eq_e=td.TDCR_model_lib.E_quench_e(ei*1e3,ed*1e3,kB,nE)*1e-3
+print(f"For electrons       => Initial energy = {ei} keV, deposited energy = {ed} keV, quenched energy = {eq_e:.5g} keV")
+eq_a=td.TDCR_model_lib.E_quench_a(ei,kB*1e-3,nE)
+print(f"For alpha particles => Initial energy = {ei} keV, quenched energy = {eq_a:.5g} keV")
+```
+
+    For electrons       => Initial energy = 1000 keV, deposited energy = 1000 keV, quenched energy = 975.24 keV
+    For alpha particles => Initial energy = 1000 keV, quenched energy = 48.934 keV
+    
+
+## Correction of the micelle effect
+
+The deposited energy ratios were evaluation by GEANT4-DNA [1].
+
+[1] Nedjadi, Y., Laedermann, J.-P., Bochud, F., Bailat, C., 2017. On the reverse micelle effect in liquid scintillation counting. Applied Radiation and Isotopes 125, 94–107. https://doi.org/10.1016/j.apradiso.2017.04.020 
+
+
+```python
+energy_vec = np.logspace(-2,4,100) # in keV
+fAq=0.1
+s05, s1, s2, s3, s4, s5, s6, s7, s8, s10 = [], [], [], [], [], [], [], [], [], []
+for e in energy_vec:
+    s05.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=0.5))
+    s1.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=1.0))
+    s2.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=2.0))
+    s3.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=3.0))
+    s4.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=4.0))
+    s5.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=5.0))
+    s6.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=6.0))
+    s7.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=7.0))
+    s8.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=8.0))
+    s10.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=10.0))
+
+plt.figure("Deposited energy ratio")
+plt.clf()
+plt.plot(energy_vec,s05,label="$\Phi$=0.5 nm")
+plt.plot(energy_vec,s1,label="$\Phi$=1.0 nm")
+plt.plot(energy_vec,s2,label="$\Phi$=2.0 nm")
+plt.plot(energy_vec,s3,label="$\Phi$=3.0 nm")
+plt.plot(energy_vec,s4,label="$\Phi$=4.0 nm")
+plt.plot(energy_vec,s5,label="$\Phi$=5.0 nm")
+plt.plot(energy_vec,s6,label="$\Phi$=6.0 nm")
+plt.plot(energy_vec,s7,label="$\Phi$=7.0 nm")
+plt.plot(energy_vec,s8,label="$\Phi$=8.0 nm")
+plt.plot(energy_vec,s10,label="$\Phi$=10.0 nm")
+plt.xscale('log')
+plt.xlabel(r'$E$ /keV', fontsize=14)
+plt.ylabel(r'$S(E)/E$', fontsize=14)
+plt.legend()
+```
+
+
+
+
+    <matplotlib.legend.Legend at 0x2dab792de10>
+
+
+
+
+    
+![png](output_6_1.png)
+    
+
+
+## Scintillation quenching function from the Birks model (with micelle effect)
+
+
+```python
+energy_vec = np.logspace(-2,4,100) # in keV
+fAq = 0.1 # acqueous fraction
+diam_micelle = 4.0 # diameter of micelles (in nm) 
+
+eq_a, eq_e, eq_e_m = [], [], []
+for e in energy_vec:
+        eq_e.append(td.TDCR_model_lib.E_quench_e(e*1e3,e*1e3,kB,nE)*1e-3)
+        eq_e_m.append(td.TDCR_model_lib.E_quench_e(e*1e3,e*1e3,kB,nE)*1e-3*td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=diam_micelle))
+        eq_a.append(td.TDCR_model_lib.E_quench_a(e,kB*1e-3,nE))
+
+plt.figure("Quenched Energy")
+plt.clf()
+plt.plot(energy_vec,eq_a/energy_vec,"-k",label="alpha particles")
+plt.plot(energy_vec,eq_e/energy_vec,"-r",label="electrons")
+plt.plot(energy_vec,eq_e_m/energy_vec,"--r",label="electrons (micelle effect)")
+plt.xscale('log')
+plt.xlabel(r'$E$ /keV', fontsize=14)
+plt.ylabel(r'$Q_t(E)/E$', fontsize=14)
+plt.legend()
+```
+
+
+
+
+    <matplotlib.legend.Legend at 0x2dab779f910>
+
+
+
+
+    
+![png](output_8_1.png)
+    
+
+
+
+```python
+
+```
+
+
+```python
+# Simulation of the interaction of ionizing particles in the scintillant
+```
+
+
+```python
+#pip install TDCRPy --upgrade
+```
+
+
+```python
+# pip install opencv-python
+```
+
+
+```python
+import tdcrpy as td
+import matplotlib.pyplot as plt
+import numpy as np
+import cv2
+```
+
+## Response for a given initial energy
+
+## Read bivariate distributions
+
+### Electrons from 0 keV to 200 keV
+
+
+```python
+A = td.TDCR_model_lib.Matrice10_e_1
+C = np.flipud(A[0:])
+C = np.clip(C, a_min=7e-6, a_max=1e-1)
+C = np.log(C)
+C = cv2.GaussianBlur(C, (3, 5), 10)
+extent = [A[0,0], A[0,-1], 0, A[0,-1]]
+x = np.arange(0, A[0,-1], A[0,-1]/10)
+y = np.arange(0, A[0,-1], A[0,-1]/10)
+
+plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
+plt.colorbar()
+plt.xticks(x)
+plt.yticks(y)
+plt.xlabel(r"$E_0$ /keV", fontsize=14)
+plt.ylabel(r"$E_1$ /keV", fontsize=14)
+plt.savefig("electrons_0-200.png")
+plt.show()
+```
+
+
+    
+![png](output_7_0.png)
+    
+
+
+### Electrons from 200 keV to 2 MeV
+
+
+```python
+A = td.TDCR_model_lib.Matrice10_e_2
+C = np.flipud(A[0:])
+C = np.clip(C, a_min=1e-5, a_max=1e-0)
+C = np.log(C)
+C = cv2.GaussianBlur(C, (3, 3), 20)
+extent = [A[0,0], A[0,-1], 0, A[0,-1]]
+x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
+y = np.arange(0, A[0,-1], A[0,-1]/10)
+
+plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
+plt.colorbar()
+plt.xticks(x, rotation=20)
+plt.yticks(y)
+plt.xlabel(r"$E_0$ /keV", fontsize=14)
+plt.ylabel(r"$E_1$ /keV", fontsize=14)
+plt.tight_layout()
+plt.savefig("electrons_200-2000.png")
+plt.show()
+```
+
+
+    
+![png](output_9_0.png)
+    
+
+
+### Electrons from 2 MeV to 8 MeV
+
+
+```python
+A = td.TDCR_model_lib.Matrice10_e_3
+C = np.flipud(A[0:])
+C = np.clip(C, a_min=1e-5, a_max=1e-0)
+C = np.log(C)
+C = cv2.GaussianBlur(C, (3, 3), 20)
+extent = [A[0,0], A[0,-1], 0, A[0,-1]]
+x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
+y = np.arange(0, A[0,-1], A[0,-1]/10)
+
+plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
+plt.colorbar()
+plt.xticks(x, rotation=20)
+plt.yticks(y)
+plt.xlabel(r"$E_0$ /keV", fontsize=14)
+plt.ylabel(r"$E_1$ /keV", fontsize=14)
+plt.tight_layout()
+plt.savefig("electrons_2000-10000.png")
+plt.show()
+```
+
+
+    
+![png](output_11_0.png)
+    
+
+
+### Photons from 0 keV to 200 keV
+
+
+```python
+A = td.TDCR_model_lib.Matrice10_p_1
+C = np.flipud(A[0:])
+C = np.clip(C, a_min=1e-7, a_max=1e0)
+C = np.log(C)
+C = cv2.GaussianBlur(C, (3, 3), 20)
+extent = [A[0,0], A[0,-1], 0, A[0,-1]]
+x = np.arange(0, A[0,-1], A[0,-1]/10)
+y = np.arange(0, A[0,-1], A[0,-1]/10)
+
+plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
+plt.colorbar()
+plt.xticks(x)
+plt.yticks(y)
+plt.xlabel(r"$E_0$ /keV", fontsize=14)
+plt.ylabel(r"$E_1$ /keV", fontsize=14)
+plt.savefig("photons_0-200.png")
+plt.show()
+
+x_1 = 1
+
+# Find the column index for the given x_1
+col_idx = np.searchsorted(A[0, :], x_1)
+
+# Extract the corresponding y values from the column
+y_1 = C[:, col_idx]
+x_plot = 0.2*np.arange(0, len(y_1), 1)
+
+print("escape probability = ",np.exp(y_1[-2])/sum(np.exp(y_1)))
+# Plot the extracted values
+plt.plot(x_plot,np.flipud(y_1))
+plt.xlabel(r"$E_1$ /keV", fontsize=14)
+plt.ylabel(r"log($P(E_1|E_0)$)", fontsize=14)
+plt.title(f"Distribution for $x_1 = {x_1}$ keV")
+plt.grid(True)
+plt.xlim([0,x_1*1.5])
+plt.savefig(f"distribution_x_{x_1}.png")
+plt.show()
+```
+
+
+    
+![png](output_13_0.png)
+    
+
+
+    escape probability =  0.5623307322837948
+    
+
+
+    
+![png](output_13_2.png)
+    
+
+
+### Photons from 200 keV to 2 MeV
+
+
+```python
+A = td.TDCR_model_lib.Matrice10_p_2
+C = np.flipud(A[0:])
+C = np.clip(C, a_min=1e-7, a_max=1e0)
+C = np.log(C)
+C = cv2.GaussianBlur(C, (3, 3), 20)
+extent = [A[0,0], A[0,-1], 0, A[0,-1]]
+x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
+y = np.arange(0, A[0,-1], A[0,-1]/10)
+
+plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
+plt.colorbar()
+plt.xticks(x, rotation=20)
+plt.yticks(y)
+plt.xlabel(r"$E_0$ /keV", fontsize=14)
+plt.ylabel(r"$E_1$ /keV", fontsize=14)
+plt.tight_layout()
+plt.savefig("photons_200-2000.png")
+plt.show()
+
+x_1 = 2000
+
+# Find the column index for the given x_1
+col_idx = np.searchsorted(A[0, :], x_1)
+
+# Extract the corresponding y values from the column
+y_1 = np.log(A[:, col_idx])
+x_plot = 2*np.arange(0, len(y_1), 1)
+
+print("escape probability = ",np.exp(y_1[0]))
+# Plot the extracted values
+plt.plot(x_plot,y_1)
+plt.xlabel(r"$E_1$ /keV", fontsize=14)
+plt.ylabel(r"log($P(E_1|E_0)$)", fontsize=14)
+plt.title(f"Distribution for $x_1 = {x_1}$ keV")
+plt.grid(True)
+plt.xlim([0,x_1*1.5])
+plt.savefig(f"distribution_x_{x_1}.png")
+plt.show()
+```
+
+
+    
+![png](output_15_0.png)
+    
+
+
+    escape probability =  1999.9999999999998
+    
+
+    C:\Users\romain.coulon\AppData\Local\Temp\ipykernel_16916\4017156075.py:26: RuntimeWarning: divide by zero encountered in log
+      y_1 = np.log(A[:, col_idx])
+    
+
+
+    
+![png](output_15_3.png)
+    
+
+
+### Photons from 2 MeV to 10 MeV
+
+
+```python
+A = td.TDCR_model_lib.Matrice10_p_3
+C = np.flipud(A[1:])
+C = np.clip(C, a_min=1e-6, a_max=1e-2)
+C = np.log(C)
+C = cv2.GaussianBlur(C, (5, 5), 20)
+extent = [A[0,0], A[0,-1], 0, A[0,-1]]
+x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
+y = np.arange(0, A[0,-1], A[0,-1]/10)
+
+plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
+plt.colorbar()
+plt.xticks(x, rotation=20)
+plt.yticks(y)
+plt.xlabel(r"$E_0$ /keV", fontsize=14)
+plt.ylabel(r"$E_1$ /keV", fontsize=14)
+plt.tight_layout()
+plt.savefig("photons_2000-10000.png")
+plt.show()
+
+x_1 = 5000
+
+# Find the column index for the given x_1
+col_idx = np.searchsorted(A[0, :], x_1)
+
+# Extract the corresponding y values from the column
+y_1 = C[:, col_idx]
+x_plot = 10*np.arange(0, len(y_1), 1)
+
+print("escape probability = ",np.exp(y_1[-1])/sum(np.exp(y_1)))
+# Plot the extracted values
+plt.plot(x_plot,np.flipud(y_1))
+plt.xlabel(r"$E_1$ /keV", fontsize=14)
+plt.ylabel(r"log($P(E_1|E_0)$)", fontsize=14)
+plt.title(f"Distribution for $x_1 = {x_1}$ keV")
+plt.grid(True)
+plt.xlim([0,x_1*1.5])
+plt.savefig(f"distribution_x_{x_1}.png")
+plt.show()
+```
+
+
+    
+![png](output_17_0.png)
+    
+
+
+    escape probability =  0.03360101175407434
+    
+
+
+    
+![png](output_17_2.png)
+    
+
+
+## Sample a deposited energy given an initial energy
+
+
+```python
+ei = 100  # initial energy in keV
+v = 10     # volume of the scintillator in mL
+ed_g=td.TDCR_model_lib.energie_dep_gamma2(ei,v)
+ed_e=td.TDCR_model_lib.energie_dep_beta2(ei,v)
+print(f"The gamma ray of initial energy = {ei} keV, has deposited = {ed_g} keV in the scintillant.")
+print(f"The electron of initial energy = {ei} keV, has deposited = {ed_e} keV in the scintillant.")
+```
+
+    The gamma ray of initial energy = 100 keV, has deposited = 0 keV in the scintillant.
+    The electron of initial energy = 100 keV, has deposited = 100 keV in the scintillant.
+    
+
+## Deposited energy of photons as a function of the sintillant volume
+
+
+```python
+V=np.arange(8,21,0.1)
+N=100000
+E=15    # initial energy in keV
+e_vec, ue_vec = [], []
+for v in V:
+    x=[]
+    for i in range(N):
+        out=td.TDCR_model_lib.energie_dep_gamma2(15,v)
+        x.append(out)
+    e_vec.append(np.mean(x))
+    ue_vec.append(np.std(x)/np.sqrt(N))
+
+```
+
+
+```python
+plt.figure(r"Ed vs volume")
+plt.clf()
+plt.errorbar(V, e_vec, yerr=ue_vec, fmt="-k", label=rf'$E_0$ = {E} keV')
+plt.legend()
+plt.xlabel(r"$V$ /mL", fontsize=14)
+plt.ylabel(r"$\bar{y}$ /(keV)", fontsize=14)
+```
+
+
+
+
+    Text(0, 0.5, '$\\bar{y}$ /(keV)')
+
+
+
+
+    
+![png](output_22_1.png)
+    
+
+
+
+```python
+
+```
+
+
+# Efficiency calculation using the analytical TDCR model
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import numpy as np
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+```
+
+
+```python
+mode = "eff"                # ask for efficiency calculation
+Rad="H-3"                   # radionuclides
+pmf_1="1"                   # relatives fractions of the radionulides
+N = 1000                    # number of Monte Carlo trials (not used)
+kB =1.0e-5                  # Birks constant in cm keV-1
+V = 10                      # volume of scintillator in mL
+L=np.logspace(-3,2,num=100) # free parameter in keV-1
+
+effS, u_effS, effD, u_effD, effT, u_effT = [], [],[], [],[], []
+for l in tqdm(L, desc="free parameters ", unit=" iterations"):
+  out = td.TDCRPy.TDCRPy(l, Rad, pmf_1, N, kB, V, mode, Smodel=False)
+  effS.append(out[2])
+  u_effS.append(out[3])
+  effD.append(out[2])
+  u_effD.append(out[3])
+  effT.append(out[4])
+  u_effT.append(out[5])
+```
+
+    free parameters : 100%|█████████████████████████████████████████████████████| 100/100 [00:15<00:00,  6.50 iterations/s]
+    
+
+
+```python
+effS=np.asarray(effS)
+effT=np.asarray(effT)
+effD=np.asarray(effD)
+u_effS=np.asarray(u_effS)
+u_effT=np.asarray(u_effT)
+u_effD=np.asarray(u_effD)
+
+tdcr=effT/effD
+u_tdcr=np.sqrt(u_effD**2*effT**2/effD**4+u_effT**2/effD**2)
+
+plt.figure("efficiency vs free parameter")
+plt.clf()
+plt.errorbar(L,effD,yerr=u_effD,fmt="-k",label="double coincidences")
+plt.errorbar(L,effT,yerr=u_effT,fmt="-r",label="triple coincidences")
+plt.xscale('log')
+plt.xlabel(r'$L$ /keV$^{-1}$', fontsize=14)
+plt.ylabel(r'$\epsilon$', fontsize=14)
+plt.legend()
+
+plt.figure("efficiency vs TDCR")
+plt.clf()
+plt.errorbar(tdcr,effD,xerr=u_tdcr,yerr=u_effD,fmt="-k")
+#plt.xscale('log')
+plt.xlabel(r'$R_T/R_D$', fontsize=14)
+plt.ylabel(r'$\epsilon_{D}$', fontsize=14)
+```
+
+
+
+
+    Text(0, 0.5, '$\\epsilon_{D}$')
+
+
+
+
+    
+![png](output_4_1.png)
+    
+
+
+
+    
+![png](output_4_2.png)
+    
+
+
+
+# Efficiency with radionuclide mixtures
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import matplotlib.pyplot as plt
+import numpy as np
+from tqdm import tqdm
+```
+
+## Fixed parameters
+
+
+```python
+mode = "eff"                # ask for efficiency calculation
+Rad = "Fe-55, Ni-63"        # list of radionuclides
+pmf_1="1"                   # relatives fractions of the radionulides
+N = 1000                    # number of Monte Carlo trials
+kB =1.0e-5                  # Birks constant in cm keV-1
+V = 10                      # volume of scintillator in mL
+L=1                         # free parameter in keV-1
+```
+
+## Mixture parameters
+
+
+```python
+C = np.arange(0,1,0.05)     # relative fraction of the second nuclide
+```
+
+## Efficiency calculation
+
+
+```python
+effS, ueffS, effD, ueffD, effT, ueffT, effD2, ueffD2 = [], [], [], [], [], [], [], []
+for i in tqdm(C, desc="Processing items"):
+    pmf_1 = f"{1-i}, {i}"
+    result = td.TDCRPy.TDCRPy(L, Rad, pmf_1, N, kB, V, mode)
+    effS.append(result[0]); ueffS.append(result[1])
+    effD.append(result[2]); ueffD.append(result[3])
+    effT.append(result[4]); ueffT.append(result[5])
+    effD2.append(result[12]); ueffD2.append(result[13])
+effD = np.asarray(effD); ueffD = np.asarray(ueffD)
+effD2 = np.asarray(effD2); ueffD2 = np.asarray(ueffD2)
+effT = np.asarray(effT); ueffT = np.asarray(ueffT)
+TDCR = effT/effD
+```
+
+    Processing items: 100%|████████████████████████████████████████████████████████████████| 20/20 [03:52<00:00, 11.63s/it]
+    
+
+## Plot the efficiency curves
+
+
+```python
+plt.figure("Stopping power")
+plt.clf()
+plt.errorbar(C,effD,yerr=2*ueffD,fmt="-k",label=r"$\epsilon_D$")
+plt.errorbar(C,TDCR,yerr=2*ueffD,fmt="-r",label=r"$\epsilon_T/\epsilon_D$")
+plt.errorbar(C,effD2,yerr=2*ueffD2,fmt="-g",label=r"$\epsilon_{D2}$ (CIEMAT/NIST)")
+#plt.xscale('log')
+plt.xlabel(f'relative fraction of {Rad.split(",")[1]}', fontsize=14)
+plt.ylabel(r' ', fontsize=14)
+plt.legend()
+plt.savefig("stopping_power_plot.png")
+```
+
+
+    
+![png](output_10_0.png)
+    
+
+
+
+# Dynamic efficiency estimation
+
+This notebook presents how to link the `TDCRPy` package with the `radioactivedecay` package [1] to simulate dynamic TDCR measurements.
+
+[1] Alex Malins & Thom Lemoine, radioactivedecay: A Python package for radioactive decay calculations. Journal of Open Source Software, 7 (71), 3318 (2022). https://doi.org/10.21105/joss.03318.
+
+
+```python
+# pip install tdcrpy --upgrade
+```
+
+
+```python
+# pip install radioactivedecay
+```
+
+
+```python
+import radioactivedecay as rd
+import tdcrpy as td
+import numpy as np
+import matplotlib.pyplot as plt
+```
+
+## Input parameters
+
+
+```python
+radionuclide = 'Mo-99' # parent nuclide decaying during the measurement
+activity_unit = "Bq"   # unit of the initial activity
+time_unit = "h"        # time unit of the decay process
+A0 = 1                 # initial activity (set to 1 in order to obtain relative activities)
+coolingTime = 30.0     # the cooling time
+
+mode = "eff"
+L = 1                  # free parameter (keV-1)
+kB = 1e-5              # Birks constant cm/keV
+V = 10                 # volume of scintillator (mL)
+N = 1000                # number of simulated decays
+```
+
+## Run radioactivedecay
+
+
+```python
+rad_t0 = rd.Inventory({radionuclide: A0}, activity_unit)
+rad_t1 = rad_t0.decay(coolingTime, time_unit)
+A_t1 = rad_t1.activities(activity_unit)
+As_t1 = sum(A_t1.values())
+print(f"Activity at {coolingTime} {time_unit}") 
+for key, val in A_t1.items(): print(f"\t {key}: {val} {activity_unit}")
+print("Total activity = ", As_t1, activity_unit)
+print(f"Relative activity at {coolingTime} {time_unit}")
+for key, val in A_t1.items(): print(f"\t {key}: {val/As_t1}")
+```
+
+    Activity at 30.0 h
+    	 Mo-99: 0.7295308772422591 Bq
+    	 Ru-99: 0.0 Bq
+    	 Tc-99: 7.44742326547114e-09 Bq
+    	 Tc-99m: 0.6738301487178286 Bq
+    Total activity =  1.4033610334075108 Bq
+    Relative activity at 30.0 h
+    	 Mo-99: 0.5198454708913215
+    	 Ru-99: 0.0
+    	 Tc-99: 5.306847695056773e-09
+    	 Tc-99m: 0.4801545238018309
+    
+
+## Display the decay graph
+
+
+```python
+nuc = rd.Nuclide(radionuclide)
+nuc.plot()
+```
+
+
+
+
+    (<Figure size 450x750 with 1 Axes>, <Axes: >)
+
+
+
+
+    
+![png](output_9_1.png)
+    
+
+
+## Display the decay curve
+
+
+```python
+rad_t0 .plot(coolingTime, time_unit, yunits=activity_unit)
+```
+
+
+
+
+    (<Figure size 640x480 with 1 Axes>,
+     <Axes: xlabel='Time (h)', ylabel='Activity (Bq)'>)
+
+
+
+
+    
+![png](output_11_1.png)
+    
+
+
+## Efficiency calculation as a function of the time
+
+
+```python
+timeVec = np.arange(0,30,2) # time vector
+effS, ueffS, effD, ueffD, effT, ueffT, effD2, ueffD2 = [], [], [], [], [], [], [],[]
+for t in timeVec:
+    rad_t1 = rad_t0.decay(t, time_unit)
+    A_t1 = rad_t1.activities(activity_unit)
+    As_t1 = sum(A_t1.values())
+    
+    rads = ""; pmf1 = ""
+    for key, val in A_t1.items():
+        if key != "Pb-208" and key != "Ru-99":
+            rads += ', '+key
+            pmf1 += ', '+str(val/As_t1)
+    rads = rads[2:]
+    pmf1 = pmf1[2:]
+    
+    out=td.TDCRPy.TDCRPy(L, rads, pmf1, N, kB, V, mode)
+    effD.append(out[2]); ueffD.append(out[3]); effT.append(out[4]); ueffT.append(out[5])
+    effS.append(out[0]); ueffS.append(out[1]); effD2.append(out[12]); ueffD2.append(out[13])
+
+effD = np.asarray(effD); effT = np.asarray(effT); ueffD = np.asarray(ueffD); ueffT = np.asarray(ueffT);
+effD2 = np.asarray(effD2); effS = np.asarray(effS); ueffD2 = np.asarray(ueffD2); ueffS = np.asarray(ueffS);
+tdcr = effT/effD
+```
+
+    warning p not equal to 1
+    warning p not equal to 1
+    warning p not equal to 1
+    warning p not equal to 1
+    
+
+## Plot efficiency curves
+
+
+```python
+# Create the plot
+plt.figure(figsize=(10, 6))
+plt.errorbar(timeVec, effS, yerr=ueffS, fmt='o', capsize=5, label=r'$\epsilon_S$')
+plt.errorbar(timeVec, effD, yerr=ueffD, fmt='o', capsize=5, label=r'$\epsilon_D$')
+plt.errorbar(timeVec, tdcr, yerr=ueffT , fmt='o', capsize=5, label=r'$\epsilon_T/\epsilon_D$')
+plt.errorbar(timeVec, effD2, yerr=ueffD2, fmt='o', capsize=5, label=r'$\epsilon_D$ (CIEMAT/NIST)')
+
+# Adding titles and labels
+#plt.title('Efficiency (effD) as a Function of Time')
+plt.xlabel(f'cooling time /{time_unit}',fontsize=16)
+plt.ylabel(r'$\epsilon_D$ and $\epsilon_T/\epsilon_D$',fontsize=16)
+plt.legend(fontsize=16)
+plt.grid(True)
+
+plt.savefig("plotDecay")
+# Show the plot
+plt.show()
+```
+
+
+    
+![png](output_15_0.png)
+    
+
+
+
+```python
+
+```
+
+
+# Distribution of TDCR measurements
+
+
+```python
+# pip install TDCRPy --upgrade
+```
+
+
+```python
+import tdcrpy as td
+import numpy as np
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+```
+
+## Record the decay histories in temporary files
+
+
+```python
+mode = "eff"                # ask for efficiency calculation
+Rad="Cd-109"                # radionuclides
+pmf_1="1"                   # relatives fractions of the radionulides
+N = 1500                    # number of Monte Carlo trials
+kB =1.0e-5                  # Birks constant in cm keV-1
+V = 10                      # volume of scintillator in mL
+L=1                         # free parameter in keV-1
+
+out = td.TDCRPy.TDCRPy(1, Rad, pmf_1, N, kB, V, mode, record=True, barp=True)
+```
+
+    
+     ______  ______  ______ _______  ________
+    |__  __||  ___ \|  ___||  ___ | |  ____ |
+      | |   | |  | || |    | |  | | | |___| |___     ___
+      | |   | |  | || |    | |__| | |  _____|\  \   |  |
+      | |   | |__| || |____|  __  \ | |       \  \  |  |
+      |_|   |_____/ |_____||_|  \__\|_|        \  \_|  |
+      +++++++++++++++++++++++++++++++++++++++++/      /
+      ________________________________________/      /
+     |______________________________________________/     
+    
+    
+    version 2.0.2
+    BIPM 2023 - license MIT 
+    distribution: https://pypi.org/project/TDCRPy 
+    developement: https://github.com/RomainCoulon/TDCRPy 
+    
+    start calculation...
+    
+
+    Processing: 100%|█████████████████████████████████████████████████████████████| 1500/1500 [00:46<00:00, 32.36 decays/s]
+    
+
+## Read initial energy from the decay process
+
+
+```python
+temp1, temp2, temp3, temp4 = td.TDCR_model_lib.read_temp_files()
+
+ee_vec, eg_vec, ep_vec, ea_vec = td.TDCR_model_lib.energyVectors1(temp1)
+nbins=50
+plt.figure("1")
+plt.hist(eg_vec, bins=nbins, edgecolor='none',density=True,label='photons')
+plt.hist(ee_vec, bins=nbins, edgecolor='none',density=True,label='electrons')
+plt.hist(ep_vec, bins=nbins, edgecolor='none',density=True,label='positrons')
+plt.hist(ea_vec, bins=nbins, edgecolor='none',density=True,label='alphas')
+plt.title('Distribution of Initial Energies')
+plt.xlabel('Energy /keV')
+plt.ylabel('Frequency')
+plt.legend()
+plt.show()
+```
+
+    C:\Users\romain.coulon\AppData\Local\anaconda3\Lib\site-packages\numpy\lib\histograms.py:885: RuntimeWarning: invalid value encountered in divide
+      return n/db/n.sum(), bin_edges
+    
+
+
+    
+![png](output_6_1.png)
+    
+
+
+## Read deposited energy in the scintillator
+
+
+```python
+ee_vec, ep_vec, ea_vec = td.TDCR_model_lib.energyVectors2(temp2)
+nbins=50
+plt.figure("2")
+plt.hist(ee_vec, bins=nbins, edgecolor='none',density=True,label='electrons')
+plt.hist(ep_vec, bins=nbins, edgecolor='none',density=True,label='positrons')
+plt.hist(ea_vec, bins=nbins, edgecolor='none',density=True,label='alphas')
+plt.title('Distribution of Deposited Energies')
+plt.xlabel('Energy /keV')
+plt.ylabel('Frequency')
+plt.legend()
+plt.show()
+```
+
+
+    
+![png](output_8_0.png)
+    
+
+
+## Read quenched deposited energy in the scintillator
+
+
+```python
+ee_vec = td.TDCR_model_lib.energyVectors3(temp3)
+nbins=50
+plt.figure("3")
+plt.hist(ee_vec, bins=nbins, edgecolor='none',density=True,label='electrons')
+plt.title('Distribution of Quenched Deposited Energies')
+plt.xlabel('Energy /keV')
+plt.ylabel('Frequency')
+plt.legend()
+plt.show()
+```
+
+
+    
+![png](output_10_0.png)
+    
+
+
+## Read detection probabilities per decay event
+
+
+```python
+s_vec, d_vec, t_vec = td.TDCR_model_lib.effVector(temp4)
+nbins=50
+plt.figure("4")
+plt.hist(s_vec, bins=nbins, edgecolor='none',density=True,label='single events')
+plt.hist(d_vec, bins=nbins, edgecolor='none',density=True,label='double coincidences')
+plt.hist(t_vec, bins=nbins, edgecolor='none',density=True,label='triple coincidences')
+plt.title('Distribution of detection probabilities per decay event')
+plt.xlabel('Detection probability')
+plt.ylabel('Frequency')
+plt.legend()
+plt.show()
+```
+
+
+    
+![png](output_12_0.png)
+    
+
+
+