radioactivedecay
Release 0.5.1
radioactivedecay é um pacote Python para cálculos de decaimento radioativo. Ele suporta cadeias de decaimento de radionuclídeos, estados metaestáveis e decaimentos ramificados. Por padrão, ele usa os dados de decaimento da publicação do ICRP 107, que contém 1252 radionuclídeos de 97 elementos, e dados de massa atômica do data center atômico de massa.
O código resolve as equações diferenciais de decaimento radioativo analiticamente usando as rotinas de álgebra linear Numpy e Scipy. Há também um alto modo de cálculo de precisão numérica que emprega rotinas de simpia. Isso fornece resultados mais precisos para cadeias de decaimento contendo radionuclídeos com ordens de diferenças de magnitude entre as meias-vidas.
Este é um software de código aberto gratuito. Foi criado para engenheiros, técnicos e pesquisadores que trabalham com radioatividade e para uso educacional.
radioactivedecay requer Python 3.8+. Instale radioactivedecay no índice de pacote Python usando pip :
$ pip install radioactivedecayou de conda-forge:
$ conda install -c conda-forge radioactivedecayQualquer um comando tentará instalar as dependências (Matplotlib, Networkx, Numpy, Pandas, Scipy, SetupTools & Sympy) se ainda não estiverem presentes no ambiente.
Crie um Inventory de radionuclídeos e decague -o da seguinte maneira:
>>> 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} Um Inventory de 2,0 bq de MO-99 foi deteriorado por 20 horas, produzindo a progênie radioativa TC-99M e o TC-99 e o nuclídeo estável Ru-99.
Fornecemos 'h' como um argumento para decay() para especificar o período de decaimento teve unidades de horas. As unidades de tempo suportadas incluem 'μs' , 'ms' , 's' , 'm' , 'h' , 'd' , 'y' etc. Nota segundos ( 's' ) é o padrão se nenhuma unidade for fornecida para decay() .
Use cumulative_decays() para calcular o número total de átomos de cada radionuclídeo que decaem durante o período de decaimento:
>>> Mo99_t0.cumulative_decays( 20.0 , ' h ' )
{'Mo-99': 129870.3165339939, 'Tc-99m': 71074.31925850797,
'Tc-99': 0.0002724635511147602} Os radionuclídeos podem ser especificados de quatro maneiras equivalentes no radioactivedecay : três variações de cordas nuclídeos ou por IDs canônicos. Por exemplo, a seguir são maneiras equivalentes de especificar 222 RN e 192N IR:
'Rn-222' , 'Rn222' , '222Rn' , 862220000 ,'Ir-192n' , 'Ir192n' , '192nIr' , 771920002 . Os inventários podem ser criados fornecendo atividades ( 'Bq' , 'Ci' , 'dpm' ...), Mass ( 'g' , 'kg' ...), Mole ( 'mol' , 'kmol' ...) unidades, ou números de núcleos ( 'num' ) para o construtor Inventory() . Use os métodos activities() , masses() , moles() , numbers() , activity_fractions() , mass_fractions() e mole_fractions() para obter o conteúdo do inventário em 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 o método plot() para gráfico da deterioração de um inventário ao longo do tempo:
>>> Mo99_t0.plot( 20 , ' d ' , yunits = ' Bq ' )O gráfico mostra a decaimento do MO-99 ao longo de 20 dias, levando ao crescimento do TC-99M e a uma quantidade de traço de TC-99. A atividade do RU-99 é estritamente zero, pois é o nuclídeo estável no final da cadeia de decaimento. Os gráficos são desenhados usando o matplotlib.
A classe Nuclide pode ser usada para buscar informações de decaimento para radionuclídeos individuais, por exemplo, 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.01757601699998Existem métodos de inventário semelhantes para buscar dados de decaimento:
>>> 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', 'β-']} A classe Nuclide inclui um método plot() para desenhar diagramas de cadeia de decaimento:
>>> nuc = rd.Nuclide( ' Mo-99 ' )
>>> nuc.plot()Esses diagramas são desenhados usando Networkx e Matplotlib.
radioactivedecay inclui uma classe InventoryHP para cálculos de alta precisão numérica. Esta classe pode fornecer resultados de cálculo de decaimento mais confiáveis para cadeias contendo radionuclídeos de longa e curta duração:
>>> 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 uma solução analítica para as equações diferenciais de decaimento radioativo usando operações de álgebra linear. Ele implementa o método descrito neste artigo: M Amaku, Pr Pascholati e VR Vanin, Comp. Phys. Comm. 181, 21-23 (2010). Veja a teoria Docpage para obter mais detalhes.
Ele usa rotinas Numpy e Scipy para cálculos de decaimento padrão (operações de ponto flutuante de precisão dupla) e simpy para cálculos de precisão numérica arbitrária.
Por padrão, radioactivedecay usa dados de decaimento da publicação do ICRP 107 (2008) e dados de massa atômica do atômico de data center (AMDC - Avaliações AME2020 e NUBASE2020).
O Repo DataSets contém notebooks Jupyter para criar conjuntos de dados de decaimento que podem ser usados pelo radioactivedecay , por exemplo, ICRP 107.
O repositório de comparações contém algumas verificações do radioactivedecay contra Pyne e Caixa de Ferramentas Radiológicas.
Da execução do diretório base:
$ python -m unittest discover radioactivedecay é o software de código aberto lançado sob a licença do MIT. Consulte o arquivo de licença para obter detalhes.
Os dados de decaimento padrão usados pelo radioactivedecay (ICRP-107) são Copyright 2008 A. Endo e KF Eckerman e distribuídos sob uma licença separada. Os dados de massa atômica padrão são do AMDC (licença).
Se você achar este pacote útil para sua pesquisa, considere citar o artigo no radioactivedecay publicado no Journal of Open Source Software:
Alex Malins e Thom Lemoine, RadioActivedEcay: um pacote Python para cálculos de decaimento radioativo . Journal of Open Source Software, 7 (71), 3318 (2022). Doi: 10.21105/joss.03318.
Os colaboradores são bem -vindos para corrigir bugs, adicionar novos recursos ou fazer solicitações de recursos. Por favor, abra uma questão, solicitação de puxar ou novos threads de discussões no repositório do GitHub.
Leia as diretrizes de contribuição.
