radioactivedecay
Release 0.5.1
radioactivedecay es un paquete de Python para cálculos de desintegración radiactiva. Apoya las cadenas de desintegración de radionucleidos, estados metaestables y desintegraciones de ramificación. Por defecto, utiliza los datos de desintegración de la publicación 107 de ICRP, que contiene 1252 radionucleidos de 97 elementos y datos de masa atómica del centro de datos de masa atómica.
El código resuelve las ecuaciones diferenciales de desintegración radiactiva analíticamente utilizando rutinas de álgebra lineal Numpy y Scipy. También hay un modo de cálculo de precisión numérico alto que emplea rutinas Sympy. Esto proporciona resultados más precisos para las cadenas de descomposición que contienen radionucleidos con órdenes de diferencias de magnitud entre las vidas medias.
Este es un software de código abierto gratuito. Fue creado para ingenieros, técnicos e investigadores que trabajan con radioactividad y para uso educativo.
radioactivedecay requiere Python 3.8+. Instale radioactivedecay desde el índice de paquetes de Python usando pip :
$ pip install radioactivedecayo de Conda-Forge:
$ conda install -c conda-forge radioactivedecayCualquiera de los comando intentará instalar las dependencias (matplotlib, networkx, numpy, pandas, scipy, setuppools y sympy) si aún no están presentes en el entorno.
Cree un Inventory de radionuclidos y lo descomponga de la siguiente manera:
>>> import radioactivedecay as rd
>>> Mo99_t0 = rd.Inventory({ ' Mo-99 ' : 2.0 }, ' Bq ' )
>>> Mo99_t1 = Mo99_t0.decay( 20.0 , ' h ' )
>>> Mo99_t1.activities( ' Bq ' )
{'Mo-99': 1.6207863893776937, 'Ru-99': 0.0,
'Tc-99': 9.05304236308454e-09, 'Tc-99m': 1.3719829376710406} Un Inventory de 2.0 BQ de MO-99 se detuvo durante 20 horas, produciendo la progenie radiactiva TC-99M y TC-99, y el nucleido estable RU-99.
Suministramos 'h' como argumento para decay() para especificar que el período de tiempo de descomposición tenía unidades de horas. Las unidades de tiempo compatibles incluyen 'μs' , 'ms' , 's' , 'm' , 'h' , 'd' , 'y' etc. notas segundos ( 's' ) es el valor predeterminado si no se suministra ninguna unidad a decay() .
Use cumulative_decays() para calcular el número total de átomos de cada radionúclido que se descompone durante el período de tiempo de descomposición:
>>> Mo99_t0.cumulative_decays( 20.0 , ' h ' )
{'Mo-99': 129870.3165339939, 'Tc-99m': 71074.31925850797,
'Tc-99': 0.0002724635511147602} Los radionucleidos se pueden especificar de cuatro maneras equivalentes en radioactivedecay : tres variaciones de las cadenas de nucleidos o por IDS canónicos. Por ejemplo, las siguientes son formas equivalentes de especificar 222 RN y 192N IR:
'Rn-222' , 'Rn222' , '222Rn' , 862220000 ,'Ir-192n' , 'Ir192n' , '192nIr' , 771920002 . Se pueden crear inventarios suministrando actividad ( 'Bq' , 'Ci' , 'dpm' ...), masa ( 'g' , 'kg' ...), mole ( 'mol' , 'kmol' ...) unidades o números de nucleos ( 'num' ) al constructor Inventory() . Use las activities() , masses() , moles() , numbers() , activity_fractions() , mass_fractions() y mole_fractions() para obtener el contenido del inventario en diferentes formatos:
>>> H3_t0 = rd.Inventory({ ' H-3 ' : 3.0 }, ' g ' )
>>> H3_t1 = H3_t0.decay( 12.32 , ' y ' )
>>> H3_t1.masses( ' g ' )
{'H-3': 1.5, 'He-3': 1.4999900734297729}
>>> H3_t1.mass_fractions()
{'H-3': 0.5000016544338455, 'He-3': 0.4999983455661545}
>>> C14_t0 = rd.Inventory({ ' C-14 ' : 3.2E24 }, ' num ' )
>>> C14_t1 = C14_t0.decay( 3000 , ' y ' )
>>> C14_t1.moles( ' mol ' )
{'C-14': 3.6894551567795797, 'N-14': 1.6242698581767292}
>>> C14_t1.mole_fractions()
{'C-14': 0.6943255713073281, 'N-14': 0.3056744286926719} Use el método plot() para gráficos de la descomposición de un inventario con el tiempo:
>>> Mo99_t0.plot( 20 , ' d ' , yunits = ' Bq ' )El gráfico muestra la descomposición de MO-99 durante 20 días, lo que lleva al crecimiento de TC-99M y una cantidad traza de TC-99. La actividad de Ru-99 es estrictamente cero, ya que es el nucleido estable al final de la cadena de descomposición. Los gráficos se dibujan usando matplotlib.
La clase Nuclide se puede usar para obtener información de descomposición para radionucleidos individuales, por ejemplo, para RN-222:
>>> nuc = rd.Nuclide( ' Rn-222 ' )
>>> nuc.half_life( ' s ' )
330350.4
>>> nuc.half_life( ' readable ' )
'3.8235 d'
>>> nuc.progeny()
['Po-218']
>>> nuc.branching_fractions()
[1.0]
>>> nuc.decay_modes()
['α']
>>> nuc.Z # proton number
86
>>> nuc.A # nucleon number
222
>>> nuc.atomic_mass # atomic mass in g/mol
222.01757601699998Existen métodos de inventario similares para obtener datos de descomposición:
>>> Mo99_t1.half_lives( ' readable ' )
{'Mo-99': '65.94 h', 'Ru-99': 'stable', 'Tc-99': '0.2111 My', 'Tc-99m': '6.015 h'}
>>> Mo99_t1.progeny()
{'Mo-99': ['Tc-99m', 'Tc-99'], 'Ru-99': [], 'Tc-99': ['Ru-99'], 'Tc-99m': ['Tc-99', 'Ru-99']}
>>> Mo99_t1.branching_fractions()
{'Mo-99': [0.8773, 0.1227], 'Ru-99': [], 'Tc-99': [1.0], 'Tc-99m': [0.99996, 3.7e-05]}
>>> Mo99_t1.decay_modes()
{'Mo-99': ['β-', 'β-'], 'Ru-99': [], 'Tc-99': ['β-'], 'Tc-99m': ['IT', 'β-']} La clase Nuclide incluye un método plot() para dibujar diagramas de cadena de descomposición:
>>> nuc = rd.Nuclide( ' Mo-99 ' )
>>> nuc.plot()Estos diagramas se dibujan utilizando NetworkX y Matplotlib.
radioactivedecay incluye una clase InventoryHP para cálculos de precisión numérica de alta. Esta clase puede dar resultados de cálculo de descomposición más confiables para cadenas que contienen radionucleidos de vida larga y corta:
>>> U238_t0 = rd.InventoryHP({ ' U-238 ' : 1.0 })
>>> U238_t1 = U238_t0.decay( 10.0 , ' d ' )
>>> U238_t1.activities()
{'At-218': 1.4511675857141352e-25,
'Bi-210': 1.8093327888942224e-26,
'Bi-214': 7.09819414496093e-22,
'Hg-206': 1.9873081129046843e-33,
'Pa-234': 0.00038581180879502017,
'Pa-234m': 0.24992285949158477,
'Pb-206': 0.0,
'Pb-210': 1.0508864357335218e-25,
'Pb-214': 7.163682655782086e-22,
'Po-210': 1.171277829871092e-28,
'Po-214': 7.096704966148592e-22,
'Po-218': 7.255923469955255e-22,
'Ra-226': 2.6127168262000313e-21,
'Rn-218': 1.4511671865210924e-28,
'Rn-222': 7.266530698712501e-22,
'Th-230': 8.690585458641225e-16,
'Th-234': 0.2499481473619856,
'Tl-206': 2.579902288672889e-32,
'Tl-210': 1.4897029111914831e-25,
'U-234': 1.0119788393651999e-08,
'U-238': 0.9999999999957525} radioactivedecay calcula una solución analítica a las ecuaciones diferenciales de desintegración radiactiva utilizando operaciones de álgebra lineal. Implementa el método descrito en este documento: M Amaku, PR Pascholati y VR Vanin, Comp. Phys. Comunicación 181, 21-23 (2010). Vea la teoría DocPage para obtener más detalles.
Utiliza rutinas Numpy y Scipy para los cálculos de desintegración estándar (operaciones de punto flotante de doble precisión) y Sympy para cálculos arbitrarios de precisión numérica.
De manera predeterminada, radioactivedecay utiliza datos de desintegración de la publicación de ICRP 107 (2008) y datos de masa atómica del Centro de datos de masa atómica (Evaluaciones AMDC - AME2020 y Nubase2020).
El repositorio de los conjuntos de datos contiene cuadernos Jupyter para crear conjuntos de datos de descomposición que radioactivedecay , por ejemplo, ICRP 107.
El repositorio de comparaciones contiene algunas comprobaciones de radioactivedecay contra Pyne y Radiological Toolbox.
Desde la ejecución del directorio base:
$ python -m unittest discover radioactivedecay es un software de código abierto lanzado bajo la licencia MIT. Consulte el archivo de licencia para obtener más detalles.
Los datos de desintegración predeterminados utilizados por radioactivedecay (ICRP-107) son los derechos de autor 2008 A. Endo y KF Eckerman y se distribuyen bajo una licencia separada. Los datos de masa atómica predeterminados son de AMDC (licencia).
Si encuentra este paquete útil para su investigación, considere citar el documento sobre radioactivedecay publicado en la revista de software de código abierto:
Alex Malins y Thom Lemoine, Radioactivedecay: un paquete de Python para cálculos de desintegración radiactiva . Journal of Open Source Software, 7 (71), 3318 (2022). Doi: 10.21105/joss.03318.
Los contribuyentes son bienvenidos a solucionar errores, agregar nuevas funciones o hacer solicitudes de funciones. Abra un problema, retire la solicitud o el nuevo hilo de discusiones en el repositorio de GitHub.
Lea las pautas de contribución.
