radioactivedecay
Release 0.5.1
radioactivedecay est un package Python pour les calculs de désintégration radioactive. Il prend en charge les chaînes de désintégration des radionucléides, des états métastables et des désintégrations de ramification. Par défaut, il utilise les données de désintégration de la publication ICRP 107, qui contient 1252 radionucléides de 97 éléments, et des données de masse atomique du centre de données de masse atomique.
Le code résout les équations différentielles de décroissance radioactive analytiquement à l'aide de routines d'algèbre linéaire Numpy et Scipy. Il existe également un mode de calcul de précision numérique élevé utilisant des routines SYMPY. Cela donne des résultats plus précis pour les chaînes de désintégration contenant des radionucléides avec des ordres de différence de magnitude entre les demi-vies.
Il s'agit d'un logiciel open source gratuit. Il a été créé pour les ingénieurs, les techniciens et les chercheurs qui travaillent avec la radioactivité et pour une utilisation éducative.
radioactivedecay nécessite Python 3.8+. Installez radioactivedecay à partir de l'indice de package Python à l'aide de pip :
$ pip install radioactivedecayou de Conda-Forge:
$ conda install -c conda-forge radioactivedecayL'une ou l'autre commande tentera d'installer les dépendances (Matplotlib, NetworkX, Numpy, Pandas, Scipy, SetUptoLs & Symy) si elles ne sont pas déjà présentes dans l'environnement.
Créez un Inventory de radionucléides et la décomposer comme suit:
>>> 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 a été décomposé pendant 20 heures, produisant la progéniture radioactive TC-99M et TC-99, et le nucléde stable Ru-99.
Nous avons fourni 'h' comme argument à decay() pour spécifier que la période de décroissance avait des unités d'heures. Les unités de temps prises en charge incluent 'μs' , 'ms' , 's' , 'm' , 'h' , 'd' , 'y' etc. Remarque Secondes ( 's' ) est la valeur par défaut si aucune unité n'est fournie à decay() .
Utilisez cumulative_decays() pour calculer le nombre total d'atomes de chaque radionucléide qui se désintégrer sur la période de décroissance:
>>> Mo99_t0.cumulative_decays( 20.0 , ' h ' )
{'Mo-99': 129870.3165339939, 'Tc-99m': 71074.31925850797,
'Tc-99': 0.0002724635511147602} Les radionucléides peuvent être spécifiés de quatre manières équivalentes dans radioactivedecay : trois variations de chaînes de nucléides ou par des ID canoniques. Par exemple, les éléments suivants sont des moyens équivalents de spécifier 222 RN et 192n IR:
'Rn-222' , 'Rn222' , '222Rn' , 862220000 ,'Ir-192n' , 'Ir192n' , '192nIr' , 771920002 . Les stocks peuvent être créés en fournissant une activité ( 'Bq' , 'Ci' , 'dpm' ...), une masse ( 'g' , 'kg' ...), mole ( 'mol' , 'kmol' ...) unités, ou nombres de noyaux ( 'num' ) au constructeur Inventory() . Utilisez les méthodes activities() , masses() , moles() , numbers() , activity_fractions() , mass_fractions() et mole_fractions() pour obtenir le contenu de l'inventaire dans différents formats:
>>> 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} Utilisez la méthode plot() pour graphiquement de la décroissance d'un inventaire dans le temps:
>>> Mo99_t0.plot( 20 , ' d ' , yunits = ' Bq ' )Le graphique montre la désintégration de MO-99 sur 20 jours, conduisant à la gravité de TC-99M et à une trace de TC-99. L'activité de Ru-99 est strictement nulle car c'est le nucléde stable à la fin de la chaîne de désintégration. Les graphiques sont dessinés à l'aide de Matplotlib.
La classe Nuclide peut être utilisée pour récupérer les informations de désintégration pour les radionucléides individuels, par exemple pour 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.01757601699998Il existe des méthodes d'inventaire similaires pour récupérer les données de désintégration:
>>> 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 classe Nuclide comprend une méthode plot() pour dessiner des diagrammes de chaîne de désintégration:
>>> nuc = rd.Nuclide( ' Mo-99 ' )
>>> nuc.plot()Ces diagrammes sont dessinés à l'aide de NetworkX et Matplotlib.
radioactivedecay comprend une classe InventoryHP pour des calculs de précision numérique élevés. Cette classe peut donner des résultats de calcul de désintégration plus fiables pour les chaînes contenant des radionucléides à longue durée de vie:
>>> 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 calcule une solution analytique aux équations différentielles de désintégration radioactive utilisant des opérations d'algèbre linéaire. Il met en œuvre la méthode décrite dans cet article: M Amaku, Pr Pascholati & VR Vanin, Comp. Phys. Comm. 181, 21-23 (2010). Voir la théorie DocPage pour plus de détails.
Il utilise des routines Numpy et Scipy pour les calculs de désintégration standard (opérations à virgule flottante à double précision) et Sympy pour les calculs de précision numérique arbitraire.
Par défaut, radioactivedecay utilise les données de désintégration de la publication ICRP 107 (2008) et des données de masse atomiques du centre de données de masse atomique (AMDC - AME2020 et Nubase2020).
Le dépôt de jeux de données contient des cahiers Jupyter pour la création de ensembles de données de désintégration qui peuvent être utilisés par radioactivedecay , par exemple ICRP 107.
Le dépôt de comparaisons contient quelques vérifications de radioactivedecay contre Pyne et la boîte à outils radiologique.
Du répertoire de base Run:
$ python -m unittest discover radioactivedecay est un logiciel open source publié sous la licence MIT. Voir le fichier de licence pour plus de détails.
Les données de désintégration par défaut utilisées par radioactivedecay (ICRP-107) sont Copyright 2008 A. Endo et KF Eckerman et distribuées sous une licence distincte. Les données de masse atomique par défaut proviennent d'AMDC (licence).
Si vous trouvez ce package utile pour vos recherches, veuillez envisager de citer l'article sur radioactivedecay publié dans le Journal of Open Source: un logiciel:
Alex Malins et Thom Lemoine, RadioactiveCaideCay: un package Python pour les calculs de désintégration radioactive . Journal of Open Source Software, 7 (71), 3318 (2022). Doi: 10.21105 / joss.03318.
Les contributeurs sont les bienvenus pour corriger les bogues, ajouter de nouvelles fonctionnalités ou faire des demandes de fonctionnalités. Veuillez ouvrir un problème, une demande d'extraction ou un nouveau fil de discussion au référentiel GitHub.
Veuillez lire les directives de contribution.
