An alternative algorithm for the linearization process of transmutation and decay networks

Accepted Manuscript An alternative algorithm for the linearization process of transmutation and decay networks Carlos-Antonio Cruz-López, Juan-Luis François

PII: DOI: Reference:

S0010-4655(18)30140-1 https://doi.org/10.1016/j.cpc.2018.04.024 COMPHY 6498

To appear in:

Computer Physics Communications

Received date : 26 November 2017 Revised date : 10 March 2018 Accepted date : 23 April 2018 Please cite this article as: C.-A. Cruz-López, J.-L. François, An alternative algorithm for the linearization process of transmutation and decay networks, Computer Physics Communications (2018), https://doi.org/10.1016/j.cpc.2018.04.024 This is a PDF file of an unedited manuscript that has been accepted for publication. As a service to our customers we are providing this early version of the manuscript. The manuscript will undergo copyediting, typesetting, and review of the resulting proof before it is published in its final form. Please note that during the production process errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain.

*Manuscript

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

An alternative algorithm for the linearization process of transmutation and decay networks Carlos-Antonio Cruz-López, Juan-Luis François Universidad Nacional Autónoma de México, Facultad de Ingeniería, Departamento de Sistemas Energéticos Paseo Cuauhnáhuac 8532, Col. Progreso, 62550 Jiutepec, Morelos, México [email protected], [email protected] Abstract To modelling the changes occurring in the nuclear reactor’s fuel composition, it is necessary to solve a coupled system of first order differential equations, known as the Bateman equations. Nowadays, there are two main methods to accomplish this task: the linear chain method and the matrix exponential method. The general procedure for the linear chain method consists in breaking a transmutation network into independent depletion chains (also known as “linear chains”) and then solving each one analytically. The common way to build these linear chains is using a Depth-First-Search (DFS) algorithm, which consists in finding every possible path in a network, tracking the decay and transmutation reactions for a set of isotopes until one stable appears or there is no more information to continue. At this point, the algorithm moves backwards searching a branch or an untraveled path, and then the procedure is repeated. In the present work, an alternative new algorithm for building linear chains is developed, which uses a special notation and reduces the problem of finding paths to the problem of ordering a sequence of characters. Unlike the DFS, the algorithm developed has not a backward routine, but it has a “fill” procedure instead. The last property decreases the computation time spent in build linear chains and is useful with cyclic chains. We carry out a comparative analysis including computational schemes based on the running time of the algorithms, versus the length of the linear chains built. We considered two kinds of networks: 1) where the initial element is a heavy isotope that undergoes fission reaction and 2) where the first element is a fission product. In all the practical scenarios the proposed algorithm is faster than the DFS’s, nevertheless when the values of the chain’s length are large enough, the running times converge, being necessary to use a more complex and advanced sorting method. 1. Introduction Changes occurring in the fuel isotopic composition during nuclear reactors operation modify the fuel neutronic properties. As a result, there is an effect in the reactivity and safety parameters of the reactor core, and therefore it is necessary a detailed knowledge of the depletion and distribution of the fuel. These changes are due to three main reactions and transformations in the isotopes: 1) radioactive decay, 2) capture, and 3) fission process. The simulation of them in a nuclear reactor is known as burnup calculation. The change of the isotope concentration over time can be described by the following differential equation (Isotalo,2013):

1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Where

is the atom density of isotope ,

is an effective branch ratio, that represents the

fraction of transformations or decays of an isotope , that produces the isotope ; and the effective decay constant of the isotope , defined as:

is

With as the standard decay constant, as the microscopic cross section for the energy group , and as the group flux. Bateman (1910) proposed a solution to a particular case1 of the equation (1), where there is a special relation between the isotopes: except the first and the last element, everyone else has only one ancestor and one successor, i.e.:

This structure is known as a linear chain. Bateman’s solution was very simple, but unfortunately there are very few cases in burnup problems where the transmutation and decay schemes are linear. In addition to this, Bateman suppose that the coefficients appearing in the differential equations were constant. In the case of equation (1) this condition is not satisfied, even more, the terms

and

depend on the flux and the microscopic cross sections, which in turn are determined using the atomic densities . In other words, this is a nonlinear problem. It is possible to overcome both difficulties. The last one is solved assuming linearity over a time interval or “step”, in which the terms are assumed to be constant (Stammler and Abbate, 1983). To deal with the first difficulty it is necessary to break the network in linear chains, then solve each one with the Bateman’s solution or some of its variations, and finally apply a superposition process to take account of all valid contributions. In the future, we will refer this process as “linearization”. Then, we have two main steps in this procedure: 1) the generation of linear chains, and 2) the solution of the Bateman equation of each of them, using a correct superposition process. Nevertheless, in practice it is not possible to solve each linear chain, because the run time is directly dependent on the number of them, as well as on their average length (Chaitanya et al., 2017). At the time when Bateman published his solution, the process of fission or capture had not been discovered, also the branching ratio had not been yet studied. 1

2

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Figure 1. Diagram of the different steps that integrate the linear chain method, according to the methodology described in the present work. Therefore, it is necessary to introduce an analysis about which linear chains will be considered, and a cutoff technique in order to reduce their length. This analysis is carry out between the two steps that were mentioned before. In Figure 1 these steps are depicted. The method described above is called the “linear chain method”, and it is currently used in several burnup codes and algorithms: TTA (Cetnar, 2006), PENBURN, (Manalo, 2008), STEP1.0 (Wang et al 2013), ORIGEN (Herman and Westfall, 1998), HELIOS (Studsvik, 2008). Furthermore, there are other ways to solve the equation (1), such as the exponential matrix method, the Runge-Kutta solution of the Gauss Type, and Taylor expansions among others. Particularly, the Chebyshev Rational Approximation Method (CRAM) (Pusa, 2013), belonging to the first kind, has become the most powerful and popular tool in burnup calculations, and it has been proven (Isotalo, 2013) that CRAM is faster than the Trajectory Transmutation Analysis method, the main linear chain method used nowadays. Nevertheless, in recent analysis (Huang, et. at, 2015) it has been considered that while CRAM could “elegantly” solve burnup problems, the linear chain methods can be viewed as a complement for it. The general procedure of the linear chain method consists in breaking a transmutation network into independent depletion chains (also known as “linear chains”) and then solving each one analytically. The common way to build these linear chains is using a Depth-FirstSearch (DFS) algorithm, which consists in finding every possible path in a network, tracking the decay and transmutation reactions for a set of isotopes until one stable appears, or there is no more information to continue. At this point, the algorithm moves backwards searching a branch or an untraveled path, and then the procedure is repeated. In its standard form, the DFS’s algorithm has only one search criterion and one search restriction. This criterion is related to the stability of the isotopes. If the isotope is stable, then the DFS’s algorithm has reached an end of a linear chain, and therefore it moves backward. On the other hand, the restriction is associated with the chain’s length, and therefore with the search depth. Nevertheless, the DFS’s algorithm can use more specific criteria and restrictions. Particularly, it is possible to include criteria about the actual contribution of the chain to the final concentration of a given isotope. If the algorithm asses that the contribution is negligible from one isotope forward, then it has reached an end of a linear chain, in the same way as it has found a stable isotope. In other words, the DFS’s algorithm can include the step 1 and the intermediate step of Fig. 1, and therefore this algorithm is a key aspect of the linear chain method. 3

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

In the present work, an alternative algorithm for the linearization process is developed. This algorithm uses a special notation based on characters separated by dashes symbols. The elements in a transmutation and a decay network are represented according to their interrelationships or kindred, and the dash symbol allows to identify the generation or depth. Later, when we use an ordering procedure on the characters or strings, the resulting elements are segments of linear chains. Therefore, the procedure of searching descendants is reduced to the process of sorting characters. The proposed algorithm was compared with a standard DFS, using as a unique criterion: the stability of the isotopes, and the chains length as the only restriction. In this first study, such comparison was carried out at the algorithmic level, in which the main properties of the algorithm's notation are shown, Particularly, for all the practical cases, the proposed algorithm is faster than the DFS. The structure of this paper is as follows: In Section 2 the linearization process is explained. Section 3 discusses the importance and relevance of the linearization process. In Section 4 the proposed algorithm is developed. In Section 5 a computational comparison between the proposed algorithm and the DFS is developed. Finally, conclusions are in Section 6. 2. The process of linearization. Let us consider the transmutation and decay network illustrated in Fig. 2. The elements , with , represent the isotopes, and the factors are the branching ratios previously mentioned, where the superscript “eff” has been omitted. Let us consider the case of finding trajectories using as unique criteria the stability of the isotopes. For this network, the standard linearization process begins with the element , then, since it has two branches, it is necessary to choose one, and “put on hold” the other. Suppose we choose , even when this selection is arbitrary, it is always a common practice to consider the “first” element. From this point, there are not branches in the following isotopes. Indeed, we have a “segment” or a linear chain with the elements and . There are three cases for a final element: 1) it has not progenies, 2) there is not available information about it, 3) we have defined it as the final element. The last case is useful when we have decided to “truncate” or “cut off” a chain. Once a final element is reached, the set of isotopes traversing becomes a linear chain. In our example (Figure 2):

After this, it is necessary to travel the linear chain obtained in the opposite direction, until we find the first branch with an element “put on hold”, in this case: . The branching element (who originates ) is taken as a reference point, and it is searched in the last immediate linear chain, i.e. in (3).

4

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Figure 2. Scheme of a transmutation and decay network Once we have located it, it is necessary to take all the previous elements in that linear chain, in our case only . These elements will form the “base” or the “stem” of the following linear chain. This process is repeated until there are not elements “put on hold”. Figure 3 shows the linearization of the network of Figure 2. If we call the isotopes “nodes”, and the paths between elements are considered as “edges”, it is possible to see the network as a “tree”. In data structure’s theory, there are two main algorithms used to traversing trees: the “Depth-First Search” and the “Breadth-First Search” (BFS) (Thulasiraman et. al, 2016). The linearization method above discussed is a standard “Depth-First Search” algorithm. As its name suggests, this algorithm first finds the last element (the deepest) in a “steam” or “path”, and then search in the unexplored nodes. In the burnup problems, we do not have the network “a priori”. Instead, it is built through the information from nuclear data libraries as ENDF or JEFF, and its structure is determined by the special treatment of the code, as well by the restriction and search criteria. There is a class of networks whose structure contains a repeated pattern that under a linearization process leads to an infinite number of linear chains. For example, let us considerer the following transmutation scheme: (4) In (4), the first element reappears at the final part; therefore, the pattern is repeated from this point. This case can happen with several heavy elements as and . If this were a linear chain, its length would be infinite, and the problem would be solved by restricting the length of the depth of search. Unfortunately, there may be branches and then the problem becomes complex. This type of networks is called “cyclic chains” and have an impact in the Bateman’s equation, since its analytic solution presents problems if there are two elements with the same effective decay constant (that is the case if there are two repeated elements in a network’s pathway). 5

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Figure 3. Linearization of the network depicted in Figure 2. There are several methods to overcome the problems related to the analytical solution. For example, Cetnar (2006) and Dreher (2013), separately and independently, have developed general analytical solutions that allow identical effective decay constants. Also, there are methods that introduce small modifications to avoid problematic cancellations. As previously mentioned, if we try to apply the linearization process in a cyclic chain, the result will be an infinite number of linear chains. Nevertheless, if we restrict the number of generations (i.e. the search depth), we can correctly address the problem and the number of linear chains can be finite, even if this number is large. The error due to this approach is acceptable. This procedure is used in the ALARA (Wilson 1999) activation code, and an earlier reference to it is in DCHAIN2 (Tasaka, 1980). Depending on the considered length, the number of linear chains can grow significantly. Particularly, this growth can be characterized as exponential for the case of cyclic chains, as it will be shown in Section 5.1. In the next section we will discuss about how DFS is used in burnup codes, and we will justify the importance of improving this linearization process. 3. The relevance of linearization. 3.1 The linearization process and the flexibility. One of the early references to the linearization process is the England’s work about the “fission cross sections” (England, 1962a). In the Part I of his report, England shows how to break a section of the transmutation and decay network related to Xe-134. Later, in the appendices A and B of the same report, England explains how the independent linear chains can be solved using an analytical solution. Nevertheless, England’s explanation is merely intuitive and does not offer an explicit methodology for the linearization.

6

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Later, the burnup code CINDER (England, 1962b) implemented England’s procedure, and it is, probably, the first code using the linearization process. A formal mathematical proof about linearization was offered by Raykin and Shlyakhter (1989). In their work, it is strictly proved that any transmutation network can be broken into independent depletion chains, if the burnup equations are linear in concentrations. After CINDER was developed, other codes followed such as ORIGEN (Bell, 1973), WIMS (Leszczynski et al. 2007), DCHAIN (Tasaka, 1976), HELIOS (Studsvik, 2008) , BISON-C (Cetnar, 2000), PENBURN (Manalo, 2008), among others. Unfortunately, in their documentation there is not a detailed treatment about the linear chains building, and even with some exceptions, the DFS algorithm is not mentioned. As exception to the rule, we have the activation code ALARA (Wilson, 1999), the burnup code PENBURN (Manalo, 2008), and the Captain Harr’s master thesis (Harr, 2007). Each one of these references addresses the linearization process, mentioning DFS to some extent. The first one analyzes how to deal with cyclic chains (a topic that will be mentioned later in the present work), the second one proposes an algorithm to enumerate linear chains (using a special notation) and the last reference describes a verification process for the DFS routine, considering nine test cases in its Appendix B. Nevertheless, in most of the literature, this subject is treated in a superficially way, or in the worst case is totally ignored. This can be explained if we consider the computation limitations, and the conservative focus that some codes had. Since that, the number of linear chains solved impacts considerably in the software’s executive time, it is very probable that the linearization process was carried out only once, using a probed scheme that were developed heuristically. In other words, the codes always work with the same set of linear chains that produce correct results. As an example, in the code MCNP (Pelowitz, 2008) there are three different decay and transmutation schemes, defined as TIER 1, TIER 2 and TIER 3. In these schemes the fission products are fixed, and therefore the linear chains associated with them. Since the yield assignation is totally dependent of the linear chains used, due to isobaric chains, it is possible that the results for the concentration of some isotopes do not necessarily match with the output of other burnup codes. Particularly, the authors of the present work have found discrepancies between the output of MCNP and SERPENT (Leppänen, 2009) for some isotopes as Ge-076. Then, if we want to compare these concentrations in a fair way, it will be necessary to provide flexibility in the linearization process, and in some scenarios generate the linear chains in each step, in order to follow correctly the evolution of the isotopes concentration. Unfortunately, until now, the dominant paradigm in core analysis codes is to use a fixed linear chains scheme. Nevertheless, a new paradigm has emerged recently regarding the development of core analysis codes and neutronic methodologies, which consists in carry out several computations “on the fly” during the global core simulation (Ivanov, 2008, Zhang, 2008), such as the related to cross sections. Unlike the common and traditional approach where, for example, pregenerated cross sections tables for homogenized nodes are calculated, this new paradigm involves a greater use of computational resources to achieve best estimate results. These new procedures are known as “Next Generation Methods” (NGM). 7

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Even when this new approach does not consider the linearization process in burnup calculations, it suggests using more detailed computations and more complex analysis. Therefore, it is possible to extend this paradigm to the transmutation and decay networks’ study, to include a great number of isotopes, and to track all the possible reactions with fewer approximations. In this way, it will be possible to gain flexibility regarding the number of linear chains included, as well as their length. 3.2 The execution time and the termination criterion. In Section 2 we described an intermediate step (Fig. 1), whose main objective is to reduce the number of linear chains. As it was mentioned before, the execution time is totally dependent of this number, and if we reduce it, the execution time will decrease. On the other hand, the number of linear chains usually depends on the chain’s length. This is clear, because the length, in turn, is related to the “depth” reached by the DFS algorithm when the chains were generated. Then, the deeper the algorithm searches, the more “branches” it finds, and therefore more “linear chains” are generated. This is true especially for cyclic chains, where the number of linear chains grow exponentially when the depth increases. In Section 5.1 we carry out this analysis for the U-235’s case. Accordingly, it is necessary to introduce a “chain termination technique” (also named “cut off criterion”), that truncates the chain’s length, keeping the accuracy in an acceptable level. Essentially, these techniques consist in defining a “passage” function, which serves to quantify the total production of all isotopes in a subtree due to the nth isotope in the chain. One of the earliest references to these techniques can be found in Cetnar’s work about the development of the Transmutation Trajectory Analysis method (TTA). Such method owes its name to this type of techniques, which it uses to generate linear chains. More recently, Kai Huang et. al (2015) and Chaitanya’s et.al (2017) have made significative contributions to this topic. In Huang’s work an alternative approach to the “passage” function is presented, which is determined from a time-average isotope number density. On the other hand, in Chaitanya’s work a recurrence relation is developed that defines the “passage” function of an isotope in the “nth” position, in terms of the “passage” function of the previous one. These termination techniques can be applied in a set of linear chains that have already been generated. In other words, it is possible to apply them to a set of fixed linear chains, and through these techniques reduce their number. Nevertheless, the termination techniques can also be used as a search criterion to create new linear chains in the linearization process, using a DFS algorithm. In other words, we can generate the more appropriate linear chains from the beginning and considering the best scheme according to a given scenario. Even when the present work is mainly oriented to core burnup analysis codes, it is important to mention that this methodology is used in another branch of nuclear engineering, namely: “nuclear activation calculations”. For example, in the recently developed ACTYS activation code (Chaitanya et al., 2017), linear chains (also called “pathways”) are automatically generated at each time step, adapting its procedure to several cases, and avoiding excessive time consumption. 8

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

From the above discussion, it is clear the need to improve the speed of the DFS algorithm, which allows us to include this type of criteria that will improve the speed of the linear chain method. Nevertheless, it is necessary to clarify that in the present stage of the investigation, we are implementing an alternative algorithm using as a unique criterion the stability of the isotopes, and the chain's length as the only restriction. Our main objective in the present work is to show the characteristics of such algorithm, which has the novelty to transform the problem of finding trajectories to the problem of sorting strings elements. Then, we designed a simple comparison scheme that allow us to compare in a first stage our algorithm with the DFS. Clearly, the next research’s stage will include, as an additional search criterion, some termination technique. Nevertheless, as it will be shown in Section 4, further investigations should be conducted to determine what methodology is more appropriate to the proposed algorithm. 3.3 Linearization process and multi point calculation. In our brief discussion in Section 1 we established the equations (1) and (2), where the possibility of multi-groups energy calculations was included, but not the possibility of multi point calculations. Since the flux is not constant thought out the reactor, it is usually necessary to divide the reactor in different regions or meshes. We can observe that the coefficients appearing in equations (1) and (2) depend on the flux, and therefore for each mesh we will have a different set of coefficients. Therefore, linear chain methods usually solve Bateman equations for each mesh with a particular set of coefficients, and later on a superposition process is carried out. Nevertheless, there is another methodology recently reported by Kanth et al. (2017), called multipoint calculation, where the entire system is considered as one single system, and calculations are optimized using a common coefficient matrix. The last matrix can be used to solve Bateman equations for all the meshes that have the same composition or material, independently of their position in the system. This is a very large matrix whose size can be reduced through the creation of a superlist and by removing sparsity. One of the fundamental steps in the creation of a coefficient matrix is related to the linearization process since equations (1) and (2) are built according to the relationships between isotopes. Therefore, the coefficient matrix building process will depend on a DFS’s algorithm. Even when Kanth’s work is mainly oriented to activation codes, it is possible to extend its application to burnup codes, because the mathematical and physical models are the same. From the above discussion, it is clear the importance to improve the speed of the DFS algorithm for multipoint calculations. Despite that the present stage of our research do not consider the possibility to adapt the proposed algorithm to multipoint calculations, undoubtedly this task will be part for the next research’s stage.

9

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

4. The algorithm based on sorting strings elements. One of the key points about the proposed algorithm is related to the “a priori” information of the isotopes and their reactions that come from nuclear data libraries, such as ENDF or JEFF. Through these libraries it is possible to know if an isotope is stable and who are their descendants or “daughters”. This information can be managed in data structures like lists or dictionaries, and the DFS’s queries are reduced to know if the isotope decays/transmutes and, if the answer is true, what are the products of these transformations. As we will discuss in the next section, both queries can be summarized in a single consult about who are the descendants, using two vectors and a special notation. Later, the whole structure of a transmutation and decay network can be condensed in one vector, and from it the linearization process is straightforward. Particularly, the procedure to build linear chains is equivalent to order a characters sequence, also called “string” in computer science. 4.1 Information’s condensation and indices generation. Let us consider the transmutation and decay network depicted in Figure 2, and the empty vectors or lists and . Then, the first element in the network is added to and a string “P0” is stored in : (5) In the Appendix we will define two iterative functions: “Add-indexes” and “Add-elements”. The first one builds the necessary notation to the process of linearization, and the second one stores this information in a special structure. After the first iteration of the “Add-elements” function, the structures of following:

and

are the (6)

Note that both vectors must have the same number of elements, and that there is a one-to-one correspondence (a bijective function) between them. Therefore, the information in the position in belongs to the -element in . The dash character (“-“) in the items in allows us to identify the relationship between the elements in . For example, for we have the notation “ , which means that this element is the “second daughter” or the “second descendent” of “ . In our case, “ ” correspond to . Then, for the second iteration of the “Add-elements” function, structure:

and

have the following (7)

10

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Again, it is possible to track a pathway or a linear chain in using the dash character. We just need to follow the ordering sequence of the strings. From (7) we can extract the following pathways: (8)

In Section 4.2 we will discuss this procedure in detail. Through the correspondence with

, from (8) we can build the following two linear chains: (9)

If we compare (9) with Figure 3, it is possible to realize that our algorithm traverses the network one generation at a time. In other words, we first find the descendants for one element and store them, and then this procedure is repeated for the following elements in the same generation. Therefore, our algorithm is not a DFS’s type, because it does not search first in depth, instead it searches first in breadth. In computer sciences, this methodology is known as Breadth-First-Search (BFS) algorithm. As mentioned earlier, the DFS method carries out two queries: 1) if the isotope decays/transmutes and 2) what are the products of these transformations. Nevertheless, if the information about the isotopes is treated before the queries, it is possible to reduce these consultations to only one. Therefore, if we have a “data-base” with the descendants of the isotopes, it is only necessary to consult if the isotope decays/transmutes, and then to select one of the descendants and “put on hold” the rest. The proposed algorithm makes the same consultation, but it does not “put on hold” elements, instead it builds the notation previously mentioned. For the 10th iteration we have: (10)

4.2 Sorting based on the dash character Let us consider an arbitrary item in

, that has the following element in (11)

In order to search the immediate ancestor and successor elements of find in the next items:

, it is just necessary to (12)

11

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Note, that the dash character and the notation structure provide us with a useful symbolic identifier. Starting from (11), for the ancestor element it is necessary to “back up” one dash character, omitting the element. For the successor, we go forward one “dash” character and search the “1” element that corresponds to the first successor. Once these items have been found in , we can find the corresponding elements in their positions, from the correspondence relationship between and .

through

Nevertheless, this search method in its standard form can represent a high computational time cost, because the “back up” and “forward” steps in the element (11) are string operations. The first one is equivalent to a “split” process and the second one involves a concatenation procedure. Then, if we repeat this process for all the elements, it is possible that the computation time will be greater than that related to the DFS algorithm, and therefore it would not exist an interest in this methodology. Fortunately, there is an alternative form to carry out this search, that represents one of the main advantages of the present work, and whose computational time cost is minimal compared with the standard methodology previously mentioned. It turns out that, because of using “dashes” the notation structure has hierarchical characteristics that makes it perfect for sorting techniques, being unnecessary to use strings operations. The best option for our case is a sort method based on the lexicographic order, which (speaking in a non-rigorous way) compares ASCII characters codes, that are essentially numbers, and then orders the string elements based on their equivalent values. For example, the “A” character has an ASCII value code of “65”, the “4” character has “54”, and the dash character has “45”. So, if we compare these three elements, from lowest to highest, the result would be: “-“, “4”, “A”. In computer science (Harzheim,2005) this kind of sorting uses a Cartesian product criterion, which is based on the comparison of two strings, taking element by element. After we sort the elements in -

- -

- - -

applying a lexicographic order, the result is as follows: - - - -

The asterisk superscript indicates that

- -

- - -

- - - -

- - - -

(13)

has been sorted.

Finally, several programming languages have native functions for sorting sets, vectors or list whose elements are strings. Therefore, after the condensation process described in section 4.1, it is only necessary to apply a simple instruction to sort the elements in . The linearization process is not yet complete, but now we have a structure in (13) with various features that will help us to breaking-down the network more easily.

12

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

4.3 Notation’s properties and linearization process. Let us consider the first five elements in (13): (14) From the relationship with

, the equivalent elements are: (15)

The last sequence is precisely the first linear chain appearing in Figure 3. Now, let us consider the following four elements: (16) Again, through the relationship between

and

we have: (17)

In this case, we do not have a complete linear chain. Nevertheless, if we observe the first three elements, they belong to the second chain appearing in Figure 3. Even more, except2 for , these three elements build the last part of the second linear chain. The two missing items of this linear chain, and , have already appeared in (15). Now, if we compare the second and third linear chains in Figure 3, they are identical except for their last element: the second one ends with and the third with . Finally, let us observe the following sequence in

: (18)

With their corresponding items in

: (19)

This is a fragment of the fourth linear chain in Figure 3. Again, the first element missing, has already appeared in (15), and, also, in this case the string “End” appears.

,

The last examples will help us to deduce a set of useful properties. The sequences (14), (16) and (19) were extracted from (13), searching the elements where the dashes number in the items in decreases. Also, in these extracted elements the dashes number increases, or remains constant in its final part, as shown in (16) where - - - - - - - have the same number of dashes. Finally, the missing elements in (17) and (19) are items with a dashes number decreased by at least one unit, compared with the initial elements in (16) and (18). The above properties can be summarized as follows:

2

This element does not appear because we only make 10 iterations of the Add-elements function.

13

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

1) In a linear chain the dashes number in consecutive elements increases. Therefore, if there are two consecutive elements in with a growing dashes number, then these belong to the same linear chain; even more, they are ordered. 2) If consecutive elements in have the same dashes number from the position , then it is necessary to duplicate times the previous “segment” of linear chain until the position . 3) If the dashes number decreases between two consecutive elements, and in , then the element is the final of the current linear chain, and the item is where the following linear chain begins. A formal proof of this properties can be found in the author’s doctoral dissertation (Cruz, 2017). With the first and third properties, we can conclude that when the dashes number decreases then we have found a linear chain “fragment”, as shown in (14), (16) and (18). These fragments will be complete if the element is included in them, as in (16). All the possible linear chain fragments of our example are listed in Table I in the Appendix. The second property represents an advantage over DFS. Suppose we have consecutive elements in with the same dashes number, this corresponds to the following linear chains structure (supposing that the repetition begins in the position):

(20)

The arrow in means the possibility of having more elements from the position , i.e. the possibility that this linear chain continues. Our notation allows to know this kind of repetitive structure easily, but if we use DFS for the same scheme instead, that algorithm would performs queries to know if the element has more descendants, and therefore consuming more computational time. Additionally, the kind of structure in (20) is common if we generate linear chains with a uniform length. The result of applying the second property to (16) is: ;

4.4 Breaking and structuring algorithms. From the process of linearization can be divided in two parts: 1) A breaking-down routine, and 2) a Structuring routine. In the first part we divide in linear chain fragments, while in the last part we complete these fragments, filling the missing elements and duplicating (if applicable) the linear chain with the same dashes number, as in (20). The algorithms related to these routines are in the Appendix. We use the bracket’s notation to represent vectors or lists, as well as the colon operator whose use is common in MATLAB o 14

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Python programming. It is possible to observe that these algorithms are equivalent to the process in which the DFS algorithm completes the “linear chains” or “segments”. When we use the DFS algorithm and we find an end of a linear chain (or we reach the defined length), it is necessary to back down until we reach an unexplored path or element. In this last process, when we repeat the searching procedure, starting from this unexplored path the new linear chain that is built has the same “root”, or “initial segment” of the last generated linear chain. For example, using the DFS algorithm for the network in Figure 2 we build the first linear chain:

Then, we back down until the element where the unexplored path is starting with Starting from this element we can build the following linear chain:

.

Nevertheless, in this process we have used the “root” or “initial segment” given by . These elements are common in both linear chains, but in the process of linearization, the DFS algorithm completes the second one using the initial segment. Therefore, both algorithms use “complete” procedures. In the proposed algorithm in this work this procedure is carried out by the “Breaking” and “Structuring” routines. 5. The comparison’s scheme. As it was mentioned before, it is important to improve the execution time of the linearization process, which is currently carry out by a DFS’s algorithm. Therefore, to analyze the properties and advantages of the proposed algorithm, it is convenient to use a comparison at the algorithmic level. Furthermore, it is not possible to carry out a comparison with an existing code in a straightforward way, because it would be necessary to divide the execution time of the existing code in at least three steps, as it was depicted in Figure 1, and only to consider the time related to the step 1 of such figure. Therefore, in order to perform this comparison, we programmed a standard DFS’s algorithm. Certainly, there are several ways to improve the speed of this type of algorithm. In the last years, many contributions on this subject have appeared, from graph-based to parallel programming techniques, and, therefore, nowadays different codes improve the speed of this algorithm in one way or another. Nevertheless, there are also several techniques to improve the speed in the string sorting process (which is the “core” of the proposed algorithm) and, even when such techniques have not been implemented in the present work, they represent a fertile field for future research. On the other hand, high-level programming languages use more specialized string libraries, as in the case of Python language (Goodrich et. al 2013), and therefore the implementation of the proposed algorithm is reduced to use the adequate set of sorting functions. Strictly, a formal comparison between two algorithms must be carried out based on their time and spatial complexity. A theoretical study of this topic involves an analysis of the steps and the structure 15

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

of the algorithms, using the big notation (also called Bachmann-Landau notation) (Thulasiraman et. al, 2016). Nonetheless, this kind of study is beyond the scope of the present work, and therefore an empirical approach will be used instead. The proposed comparative scheme can be divided in three parts: 1) A network of decay and transmutation of heavy isotopes, in which the fission process is presented, but the fission products do not appear explicitly. 2) A set of networks that have a fission product as their initial element, which in turn is the first element of an isobaric chain. 3) A set of networks that have a fission product as their initial element. Starting from this scheme, we can build the network for a burnup problem in two different ways, each one using part 1), and choosing between part 2) and part 3). We can model the fission of a heavy isotope supposing that we have a descendant called “Fission Product”, which is the final element in a linear chain. In other words, this “Fission Product” will be treated as a stable isotope. Table II in the Appendix illustrates this procedure for the case of U-235, considering only the , and the fission reactions, showing the first twenty linear chains (of a total of 53) with a length or depth of six elements. The “Fission Product” isotope (abbreviated as “FP”) also has been added for the isotopes with fission (U-234, U-236, U-237, etc.). For the part 2), we have a set of networks whose first element is a fission product, which is at the beginning of an isobaric chain. After the linearization process of these elements, we will have a set of linear chains with the following structure: (21)

Where , ,…, are fission products and the elements represent the descendent for the fission product . Now, the set must be inserted in the linear chains generated in part 1) using the “Fission Product” as a link. For example, for a linear chain with the structure (where the superscript indicates that it was generated in part 1), we have to replace the “Fission Product” by the set :

Which in turn produces the set

: (22)

Now it is possible to apply the Bateman solution for the set 16

.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

As described above, we can build the linear chains in two separated steps: first for the heavy isotopes, and then for the fission products. Up to this point it may seems enough to consider only part 2), with the isobaric scheme. Unfortunately, there are some cases where using only this scheme can cause problems. For example, if we use the isobaric scheme that begins with In-131, it will be necessary to use linear chains with a length of at least six elements to simulate the isotope Xe-131. So, it is possible that we are interested in an isotope whose position in an isobaric chain is distant, and therefore the length of linear chains should be large. There is a way to avoid this using the cumulative yield and redefining the start of an isobaric chain. In the example of In-131, we can consider an isobaric chain that begins with I-131 or Te-131, and considering a cumulative yield for them, reducing the length of the chains. Additionally, if we use the algorithm to track a specific reaction path, the isobaric chain scheme can be inadequate because it is possible that we are interested in an isotope that is different from an initial isobaric element. Therefore, for part 3) we can define a set of networks whose initial element is not the start of an isobaric linear chain. The following test were run on a 2.6 GHz-3.5 GHz3 Intel i7, 6700 HQ, under a 64-bit Windows, using the Python 2.7 programming language. 5.1 A brief analysis of cyclic chains. In sections 2 and 3 we mentioned that in cyclic chains the number of linear chains grows in exponential form, as a function of their length. To verify this, we use both algorithms (DFS and the proposed in this work) to determine the number of linear chains as a function of their length. We considered the heavy isotope U-235 as the initial element in the transmutation and decay network. In Table III of the Appendix, all the isotopes that appear in this network are listed. Figure 4 shows the results. We considered a set of length values in a range of 4 to 13. It is possible to observe that when we increase the deep or length by one, the number of linear chains increases by a factor greater than 2, but less than 3. We obtain the same results with both algorithms. If we use an exponential function as an approximation to fit our data, we have the following equation: (23) Where is the number of linear chains and 4 this fit appears with a red dotted line.

represents the depth or chain’s length. In Figure

The coefficients in (23) are strongly influenced by the isotopes considered and their reactions, but the exponential tendency is almost totally determined by the reactions and .

The processor’s specifications have two frequencies: a basic of 2.6 GHz and a turbo maxim of 3.5 GHz; the last one was used in the present work. 3

17

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Figure 4. Graph of the number of linear chains vs deep or chain’s length, where the fitting curve (computed using an exponential function) is showed. 5.2 Heavy isotopes comparison In addition to U-235, in this section U-238 has also been considered as the initial element in the transmutation and decay networks. Again, all the isotopes that appear in each network for the two isotopes are listed in Table III in the appendix. Table I shows the results for U-235. It is possible to observe that, in the first eight values, the DFS’s time is greater than the corresponding time of the proposed algorithm. Even more, if we compute the quotient between them, using the DFS’s time in the numerator (these values are in the fifth column in Table I), we have values ranging from 6.5 to 1.35 for the first eight points. Since we are interested in how many times, in average, our algorithm is faster than DFS, it is convenient to compute the geometric mean in the first eight points. This value is equal to 2.43, and therefore our algorithm is 2.43 times faster than the DFS algorithm for the first eight values, corresponding to a depth from 4 to 11 elements. From the depth value of 9 the quotient decreases until reaching a value less than 1, therefore it is advisable to use the proposed algorithm up to a value of length 11. Nevertheless, if we do not consider the reaction, it is possible to extend the length above this value. The

reaction for the U-235 generates the following linear chain:

Fortunately, the decay constant for the reaction of U-235 is 7.038 the contribution of fission products due to can be neglected. 18

years, and therefore

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Table I. Comparison for the running time between DFS and the proposed algorithm for U-235 Length of Number of linear DFS’s time (s) linear chains chains generated

4 5 6 7 8 9 10 11 12 13

51 106 207 430 874 1855 3981 8544 18698 40197

0.097 0.111 0.234 0.459 1.011 2.037 4.485 9.632 20.40 45.17

Proposed Algorithm's time (s) 0.022 0.044 0.075 0.203 0.366 0.901 2.251 7.446 23.22 108.6

Comparison quotient

4.31 2.52 3.11 2.25 2.75 2.26 1.99 1.29 0.87 0.41

Then, it is a very good approximation not to consider the reaction, if we are interested in computing the product fission’s atomic density. In our example, we considered it only because we wanted to include all the main reactions related to U-235. Now, it seems that the use of the proposed algorithm becomes inconvenient and disadvantageous for greater values of chain’s length, particularly from a depth value of 12. Nevertheless, we must analyze two key aspects before we can conclude that. First one: until now we have taken for granted that ordering elements is a fast task, but we have not mentioned that it depends on the number of items to order, their characteristics, and the sorting method used. Particularly, for our example with a depth of 13 items, the vector , described in Section 4.1, has 67823 elements, a considerable big number to be ordered. Additionally, the structure of its two last elements gives us an idea of the complexity of the comparisons: 'P0-2-2-1-2-1-2-1-2-1-2-1-1-0', 'P0-2-2-1-2-1-2-1-2-1-2-1-1-1' Also, as it was mentioned at the end of section 4.2, in the sorting procedure step we suppose to use a standard function included in the language programming that we were using. Nevertheless, if we have a case like this, it is advisable to use a more complex and powerful sorting method. Then, the first key point to consider is that the proposed algorithm was programmed using a standard function, and therefore its running time can be improved with a more powerful and complex method of sorting. Currently, there are several sorting algorithms whose implementation often depends on the nature of the elements to order, such as the “Merge sort”, the “Quick sort”, the “Cocktail sort”, among others (Knuth, 1997).

19

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

These algorithms have different characteristics that not only involve distinct running times, but also have differences related to their stability, their convergence, etc.; this type of analysis is beyond the scope of this paper. Therefore, implementing a more powerful and complex sorting method may require a deeper study of the characteristics of the items to be ordered, and may not be necessary. Indeed, this topic leads to the second key point: Figure 5 shows another perspective about the behavior of the algorithms, considering the execution’s time as a function of the linear chains. It is possible to observe that the proposed algorithm builds a greater number of linear chains in a shorter time, for an interval of 0 to 9000 linear chains. In Table I and Figure 5 we can observe that for a chain’s length of 11, we have 8544 linear chains. Now, within these linear chains there are nearly 3000 “Fission product” elements, where the set from (21) must be inserted. Now, if we suppose that the set has 50 linear chains related to fission products (a low value, in fact), then the set will have 150,000 linear chains, a very large number.

Figure 5. Graph of the running time vs the number of linear chains for the first eight chain’s lengths for U-235.

20

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Even more, the number of linear chains can be astronomical if we consider that for a chain’s length of 13 we have about 40,000 linear chains for part 1) and set often has at least 200 linear chains: i.e. set will have at least one million elements. Therefore, the proposed algorithm is faster than DFS in a region of practical applications, and if the user wants a more general case, the algorithm can be improved by using a more complex and powerful sorting method. In Table II we have similar results for U-238. For this isotope, the geometric mean for the first eight values of the comparison quotient is 2.816. Additionally, to verify our results we check that the number of linear chains obtained from DFS were the same as those obtained with the proposed algorithm. 5.3. Fission products For the present section we will consider the isotopes Se-87 and Sb-135 as fission products. In each case these isotopes will be the initial elements in a transmutation and decay network. All the reactions considered for these isotopes, and all the elements that appear in the corresponding networks are listed in Table IV and Table V of the Appendix. This information was mainly extracted from the ENDF/B-VII.1 library, and several schemes were sketched using the online data library from atom.kaeri.ie.kr. 5.3.1 Se-87 According to atom.kaeri, the isotope Se-87 does not have possible “parent” nuclides, and have beta decay and beta + neutron reactions. Table II. Comparison for the running time between DFS and the proposed algorithm for U-238. Lenght of the linear chains

Number of linear chains generated

DFS’s time (s)

4

31

0.092

0.012

7.24

5

79

0.105

0.030

3.50

6

199

0.248

0.060

4.11

7

506

0.547

0.164

3.33

8

1197

1.272

0.484

2.62

9

2859

2.919

1.210

2.41

10

6502

7.020

4.059

1.72

11

15124

16.17

15.58

1.03

12

33983

37.45

67.77

0.55

13

78241

81.91

399.6

0.20

21

Proposed Algorithm's time (s)

Comparison quotient

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Figure 6. Graph of the running time vs the number of linear chains for the first eight chains length for U-238. From this element it is possible to build the following isobaric chain: (24) The isotope Sr-87 is stable and therefore is the final element in the isobaric chain. The right arrow after it implies that this element has a transmutation reaction , showed in Table III of the Appendix. Then, Se-87 is a fission product at the beginning of an isobaric chain, and this case is related to part 2) of the proposed comparative scheme of Section 5. Table III contains the running times of the proposed algorithm and the DFS versus the chain’s length. Unlike the heavy isotopes, for the fission products it is necessary to use a greater depth because there are several connections between isobaric chains. For example, in our case the isobaric chain in (24) is related to the corresponding chain due to Se-88. In Figure 7 this connection is showed through the Rb-87 and Sr-87 isotopes. Even when Sr-87 is stable, it is possible to build linear chains from Se-87 with a length of 25 elements through the connections between isobaric chains by the reactions and . An example of this linear chain is shown in (25): Se-87 Br-87 Kr-87 Rb-87 Sr-87 91 Zr-92 Zr-93 Zr-94 Zr-95 98 Mo-99 Tc-99 Tc-100 Mo-100

Sr-88 Sr-89 Y-89 Y-90 Zr-90 ZrNb-95 Mo-95 Mo-96 Mo-97 Mo- (25) Mo-101

As indicated in Table III, the proposed algorithm is faster than the DFS in all the range. The time difference is remarkable for the first points, and at least for the length 5-8 the comparison quotient is greater than 5. 22

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Table III. Comparison for the running time between DFS and the proposed algorithm for Se-87. Length of the linear chains

Number of linear chains generated

DFS’s time (s)

Proposed Algorithm's time (s)

Comparison quotient

5

2

0.0077

0.00086

8.97

6

2

0.0095

0.00159

5.81

7

4

0.0098

0.00161

6.32

8

6

0.0111

0.00201

5.54

9

10

0.0120

0.00414

2.90

10

16

0.0176

0.00609

2.904

11

16

0.0238

0.00810

2.94

12

16

0.0247

0.01202

2.06

13

32

0.0281

0.01686

1.67

14

32

0.0318

0.02018

1.57

15

48

0.0832

0.01990

4.18

17

80

0.0858

0.04386

1.95

19

80

0.0941

0.0650

1.44

22

336

0.2285

0.1565

1.46

25

976

0.6774

0.5901

1.14

Figure 7. Connection between two isobaric chains, with the isotopes Se-87 and Se-88 as their corresponding initial elements.

23

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Unlike the heavy isotopes cases, where the number of linear chains is increasing with the depth (due mainly to the cyclic chains), in this case we have a constant value for several depths. This happens in linear chains where the elements have only one descendant, i.e. where there are not branches. The results show that the proposed algorithm is the best option to build linear chains in the depth range from 5 to 25. From the depth values of 5 to 12, the geometric mean of the comparison quotient is 4.1827. Then, on average, the proposed algorithm is 4.1827 times faster than the DFS for that range. 5.3.2 Sb-135. Table IV shows similar results for Sb-135. The isobaric chain, whose first element is Sb-135, contains the isotope Xe-135. For the Sb-135, the proposed algorithm is faster than the DFS for all the points in the interval. In this interval the geometric mean of the comparison quotient is 2.458. An example of the linear chains generated is shown below: Sb-135 Te-135 I-135 Xe-135 Cs-135 Ba-135 Ba-136 Ba-137 Ba- (26) 138 Ba-139 La-139 La-140 Ce-140 Ce-141 Pr-141 Pr-142 Pr-143 Nd143 Nd-144 Ce-140 Ce-141 Pr-141 Pr-142 Pr-143 Nd-143 Table IV. Comparison for the running time between DFS and the proposed algorithm for Sb-135. Proposed Algorithm's time (s)

Length of the linear chains

Number of linear chains generated

DFS’s time (s)

Comparison quotient

5

3

0.0090

0.0016

5.52

6

4

0.0127

0.0036

3.49

7

5

0.0137

0.00364

3.81

8

6

0.0138

0.0053

2.56

9

6

0.0182

0.0066

2.75

10

6

0.0191

0.0087

2.18

11

6

0.0203

0.0105

1.92

12

6

0.0206

0.0134

1.53

13

6

0.0265

0.0146

1.81

14

12

0.0292

0.0162

1.79

15

12

0.0762

0.022

3.45

17

36

0.0919

0.030

3.05

19

78

0.1138

0.080

1.40

22

300

0.4350

0.212

2.04

25

1260

1.565

1.088

1.43

6. Conclusions An alternative algorithm to build linear chains, from a transmutation and decay network, was developed. It is based on the use of a special notation, using characters and dashes to denote 24

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

the relationship between the elements in the network. In order to find the pathways or trajectories, the algorithm builds a sequence of strings based on the mentioned notation. Afterwards, most of the process of linearization is reduced to ordering (or sorting) this sequence. It is possible to process the information from nuclear data libraries in a specific data structures like list, vectors or dictionaries, and then only make single query to it using the proposed algorithm. This contrasts with the DFS algorithm, which in its standard form needs to make at least two queries, the first one to know if the element in the network is stable, and the second one involving a selection for one of the possible descendants, putting on hold the rest. In the proposed algorithm it is only necessary to know if an element has descendants, and if that were the case, it adds them to the sequence without the selection step, present in DFS. In addition to this advantages over DFS, the proposed algorithm does not have a backward routine, because it does not need to search “unexplored” pathways, as DFS must do it. Instead, the developed algorithm uses a sorting process to build “segments” of linear chains. Both algorithms have routines related to completion process, which consists in using “initial segments” or common “roots” of others linear chains. Nevertheless, in the developed algorithm in this work, the notation used allows to identify if there are several chains that only differs in their final element, and this represents another advantage over the DFS algorithm. The proposed algorithm was compared with the standard algorithm used for the linearization process: the depth first search. This analysis was carried out using the algorithms running time versus the depth or chain’s length of the linear chains and using as unique search condition the isotopes stability. For the comparison process an empirical numerical methodology was used, which is based on dividing the linearization process in two steps: 1) for the heavy isotopes that represents the fission process and 2) for the isotopes that are fission products. The two algorithms were programmed using the Python’s language in its version 2.7. For the heavy isotopes step, the elements U-235 and U-238 were considered with a range of chain’s length values from 5 to 13 for the first two, and a range from 5 to 11 for the last two isotopes. In the U-235’s case, the proposed algorithm was faster than the DFS’s algorithm in the range of the chain’s length values from 4 to 11. In that interval, on average, the proposed algorithm is 2.43 times faster than DFS. For chain’s length values greater than 11 the proposed algorithm seems to be disadvantageous for the U-235 case, but this drawback can be solved if a more advanced and complex sorting algorithm is used. A similar behavior is observed for U-238, where the proposed algorithm is on average 2.816 faster than DFS, in the range of depth values from 4 to 11. For the fission products step, the isotopes Se-87 and Sb-135 were considered, with a range of chain’s length values from 5 to 25. In all the cases, the proposed algorithm was faster than DFS. 25

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

The difference between the algorithms running time is remarkable for the first points (the range between 5 and 13 approximately), being advantageous for the proposed algorithm in that interval. The results show that the proposed algorithm can be a useful tool in the linearization process, providing flexibility and speed. Also, there are several subjects that can be improved, decreasing the running time of the algorithm. Finally, there are several topics for future research, as the implementation of the multi-point case and the study of termination criteria techniques. In both cases, it will be necessary to study, in a more detailed level, the notation that is used by the proposed algorithm and more specialized sorting techniques.

References Bateman, H., 1910. Solution of a system of differential equations occurring in the theory of radioactive transformations. Proc. Cam- bridge Philos. Soc. 15, 423–427. Bell, M. J., 1973. ORIGEN- The ORNL Isotope Generation and Depletion Code. ORNL-4628, Oak Ridge National Laboratory. Cetnar, J., Gronek, P., 2000. BISON-C: A one-dimensional transport and burnup calculation code with consideration of actinides and fission products. Nucl. Sci. Eng.134 (2), 236-237. Cetnar, J., 2006. General Solution of Bateman equations for Nuclear Transmutations. Ann. Nucl. Energy 33, 640–645. Chaitanya Tadepalli, S., Kanth, P., Indauliya, G., Saikia, I., Deshpande, S. P., Subhash, P. V., 2017. Development and validation of ACTYS, an activation analysis code. Ann. Nucl. Energy 107, 7181. Cruz López, C. A., 2017(Ph.D. Thesis in progress), Contribution to the solution of the isotope’s transmutation equations of the fuel of fission nuclear reactors, Doctoral dissertation, Universidad Nacional Autónoma de México. Dreher, R., 2013. Modified Bateman solution for identical eigenvalues. Ann. Nucl. Energy 53, 427-438. England, T.R., 1962a. Time dependent fission-product thermal and resonance absorption cross section. In AEC Research and development report. Bettis Atomic Power Laboratory, Pittsburgh. U.S. Atomic Energy Commission. Westinghouse Electric Corporation. England, T.R., 1962b. CINDER: a one-point depletion and fission product program. Bettis Atomic Power Laboratory. U.S. Atomic Energy Commission. Westinghouse Electric Corporation. Goodrich, M. T., Tamassia, R., Goldwasser, M. H., 2013. Data Structures and Algorithms in Python. Editorial Wiley. Chapter 12, p. 537. Harr, L. J., 2007. Precise calculation of complex radioactive decay chains. Master dissertation. Department of the Air Force. Air University. Wright-Patterson Air Force Base, Ohio. 26

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Harzheim, E., 2005. Ordered sets. Springer. University of Dusseldorf, Germany. Chapter 4, 91. Hermann, O. W., Westfall, R. M., 1998. Origen-S: SCALE system module to calculate fuel depletion, actinide transmutation, fission product buildup and decay, and associated radiation source terms. Tech. Rep. II. Oak Ridge National Lab., TN, USA. Huang, K., Wu, H., Cao, L., Li, Y., Shen, W., 2015. Improvements to the Transmutation Trajectory Analysis of depletion evaluation. Ann. Nucl. Energy 87, 637-647. Isotalo, A., 2013. Computational Methods for Burnup Calculation with Monte Carlo Neutronics. Doctoral dissertation. Aalto University publication series. Helsinki, Finland. Ivanov, B., Müller, E., Ouisloumen, M., Ivanov, K., 2008. Embedded lattice transport calculations based on PARAGON-NEM code system for reactor core analysis. In: Int. Conf. on the Physics of Reactors (PHYSOR 2008), Interlaken, Switzerland. Kanth, P., Chaitanya Tadepalli, S., Srinivasan, R., Subhash, P.V., 2017. ACTYS-1-GO: A faster and accurate algorithm for multipoint nuclear activation calculations. Fusion Engineering and Design 122, 154-162. Knuth, D. E., (1998). The Art of Computer Programming, Second Edition, Vol. 3, Addison Wesley. Chapter 5, USA. Leppänen, J., Pusa, M., Viitanen, T., Valtavirta, V., Kaltiaisenaho, T. 2015. The Serpent Monte Carlo code: Status, development and applications in 2013. Ann. Nucl. Energy, 82, 142-150. Leszczynski, F., López Aldama, D., Trkov, A., 2007. WIMS-D Library Update. International Atomic Energy Agency. STI/PUB/1264. Manalo, K. L., 2008. Development, optimization, and testing of a 3-D zone based burnup/depletion solver for deterministic transport. Master dissertation. University of Florida, USA. Pelowitz, D. B., 2008. MCNP Laboratory, LA-CP-07-1473.

USER’S MANUAL Versión 2.6.0. Los Alamos National

Poston, D. I., Trellue, H. R., 1999. User’s Manual, Version 2.0 for MONTEBURNS Version 5B. LAUR-99-4999. Pusa, M., 2013. Numerical methods for nuclear fuel burnup calculations. Doctoral dissertation. VVT Technical Research Centre of Finland. Kopijyvä Oy, Kuopio, Finland. Raykin, M. S., Shlyakhter, A.I., 1989. Solution of Nuclide Burnup Equations Using Transition Probabilities. Nucl. Sci. Eng. 102, 54-63. Stamm’ler, R. J. J., Abbate, M. J., 1983. Methods of Steady-state Reactor Physics in Nuclear Design, Academic Press, New York, NY, USA. Studsvik Scandpower, 2008. HELIOS-2 Methods: 7- Burnup. Nyköping, Sweden. Tasaka, K., 1977. DCHAIN: Code for Analysis of Build-up and Decay of Nuclides. Japan Atomic Energy Research Institute. Tokyo, Japan.

27

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Tasaka K., 1980. DCHAIN 2: a computer code for calculation of transmutation of nuclides. Japan Atomic Energy Research Institute. Tokyo, Japan. Thulasiraman, K (Chief-Editor), Arumugam, S., Brandstädt, A., Nishizeki, T., 2016. Handbook of Graph Theory, Combinatorial Optimization, and Algorithms. CRC Press, NW, USA. Wilson, P. P. H., 1999. ALARA: Analytic and Laplacian Adaptive Radioactivity Analysis. Doctoral dissertation. Fusion Technology Institute. University of Wisconsin. Madison Wisconsin. USA. Wu, M., Wang, S., Yang Y., Zhang, Q., Yang J., 2013. The Transport-Burnup Coupling System Between MCMG-II and STEP1.0 for High Fidelity Calculations. In 21st International Conference on Nuclear Engineering. Chengdu, China. Zhang, S., Tang, C. Huang, H., Chao, Y.A., 2008. Feasibility of embedding nodal homogenization in next generation methods for 3D pin-by-pin core simulation. In: Proc. of PHYSOR2008.

28

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Appendix Add-indexes Input: Two integer numbers, and , regarded as indexes Output: A character string stored in STEP 1 Select the item in the - position in STEP 2 Build the character string STEP 3 Concatenate the character string built in STEP 2, with the item in the -position in i.e.: STEP 4 Store

in

:

Add-elements Input: The element in the -position in Output: Add elements to and call the “Add-indexes” function If

is different from “End”: Check the “descendants” for the element in the -position in Count the number of “descendants”, and call that value as If =0: Add “End” to

:

Call the Add-indexes function with input’s values and : If

is different from 0: For Add the -descendent (from a total of ) of the - position element in : -descendent of Call the Add-indexes function with input’s values and 29

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Table I. Linear chain segments in 1 2 3 4

Linear chain fragment in [P0, P0-1, P0-1-1, P0-1-1-1, P0-1-1-1-1] [P0-1-2, P0-1-2-1, P0-1-2-1-1, P0-1-2-1-2] [P0-2, P0-2-1, P0-2-1-1] [P0-2-2, P0-2-2-1]

Equivalent element in

Structuring Algorithm Input: The vector/list , which contains all the linear chain fragments of a vector , and vector , whose elements are vectors/lists that contain the dashes number information of the vector/list Output: The vector , which contains all the linear chains of a network length of , i.e. the number of elements in length of For

: For If

For

(where is the length of in : position of in

:

: = elements that are repeated in

For

length of length of (where is the length of ): = number of times that the element = first position where the element For If

: (where is the length of

Else:

30

):

appears in appears in

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Breaking-down routine Input: A sorted vector/list , whose ordering methodology is based on a lexicographic order Output: A vector/list , whose elements are all the linear chain fragments in , and a set , whose elements are vectors with the dashes numbers of the elements in length of (i.e. the number of elements in , i.e. is an empty vector. , i.e. is an empty vector.

While

:

(an empty momentary vector)

While

and

: dashes number in

If

If dashes number in

Else:

If

Else:

:

“The vector

dashes number in :

Else:

Else:

)

is empty”

31

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Table II Linear chains for the U-235 case. “F.P.” is the link for the linear chains of fission products. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235 U-235

U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236 U-236

U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-237 U-235 U-235 U-235 U-235 U-235 U-235

Np-237 Np-237 Np-237 Np-237 Np-237 Np-237 Np-237 Np-237 U-238 U-238 U-238 U-238 U-238 U-238 FP U-236 U-236 U-236 U-236 U-236 U-236

Np-238 Np-238 Np-238 Np-236 Np-236 Np-236 Np-236 FP U-239 U-239 U-237 U-237 U-237 FP

Pu-238 Np-239 FP U-236 Pu-236 Pa-232 Np-237

U-237 U-237 U-237 U-235 U-235 U-235

Np-237 U-238 PF U-236 U-234 FP

Np-239 U-240 Np-237 U-238 FP

Table III Isotopes and reactions considered for the U-235 and U-238 comparative cases

U-235, U-238, N 1 4 7 10 13 16 19 22 25 28 31 34 37 40

Isotope Th-231 Ac-227 Pa-232 U-232 U-236 Th-234 Np-237 Np-236 U-239 Th-230 Th-229 Ra-228 Ra-226 Fr-223

Reactions , ,

,

,

,

,

,

, ,

, , ,

, ,

,

,

N 2 5 8 11 14 17 20 23 26 29 32 35 38 41

, ,

Isotope Pa-231 Th-227 Th-232 Pa-233 Th-233 U-237 Np-238 U-238 U-234 U-233 Ra-225 Ac-228 Rn-222 Ra-223

32

, ,

, , Reactions , , ,

, , ,

, , , ,

, , ,

, ,

N 3 6 9 12 15 18 21 24 27 30 33 36 39 42

Isotope Rn-220 Bi-213 Po-214 Pu-241 Tl-210 Bi-211 Pb-212 Pu-242 Am-240 Bi-210 Hg-206 Po-211 Tl-207 Bi-209

Reactions , ,

,

,

,

,

, , , ,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

43 46 49 52 55 58 61 64 67 70 73 76 79 82 85 88 91 94 97 100 103 106 109

At-219 Pa-234 Np-239 U-240 Ac-225 Rn-219 Pa-235 Np-240 Pb-214 Ra-224 Rn-219 Pa-235 Np-240 Pb-214 Ra-224 Pa-236 Ra-223 Rn-218 Bi-212 Am-243 Tl-206 Tl-205 Cm-246

, , ,

,

,

, ,

,

STABLE ,

44 47 50 53 56 59 62 65 68 71 74 77 80 83 86 89 92 95 98 101 104 107

Th-228 Pu-238 Pu-239 Pu-236 Po-218 Bi-215 Pu-237 Ra-226 At-218 Fr-221 Bi-215 Pu-237 Ra-226 At-218 Fr-221 Pu-240 Bi-214 Po-215 Pb-209 Cm-242 Tl-208 Cm-245

, ,

, ,

, ,

, , ,

, ,

,

, ,

,

,

,

,

,

,

,

,

45 48 51 54 57 60 63 66 69 72 75 78 81 84 87 90 93 96 99 102 105 108

Pb-207 Po-212 Tl-210 Cm-243 Pb-208 Cm-244 Cm-246 Cm-245 Pb-208 At-217 Pb-211 Po-216 Rn-217 Am-241 Pb-210 Po-213 Tl-209 Am-242 Pu-243 Po-210 Pb-206 Pb-208

STABLE ,

, , STABLE , , , , STABLE ,

,

, ,

,

List of all the isotopes and their reactions that appear in the network related to Se-87 Se-87, Isotope Br-087

3 5 7 9 11 13

Sr-087 Y-089 Zr-091 Nb-093 Mo-095

15 17 19 21 23 25 27

Mo-098 Ru-099 Mo-101 Nb-096 Zr-097 Sr-090 Ru-100 Tc-101

Reactions

N 29

Isotope Kr-087

31 33 35 37 39 41

Sr-088 Y-090 Zr-092 Zr-095 Mo-096

Reactions

, ,

N 16 18 20 22 24 26 28

Isotope Rb-087 Sr-089 Zr-090 Zr-093 Nb-095 Mo-097 Tc-099

Reactions , , , ,

Mo-099 STABLE , ,

2 4 6 8 10 12

30 Tc-100 Zr-094 Nb-097 Y-091 Sr-091 Ru-101

33

, ,

32 34 36 38 40

Mo-100 Tc-098 Zr-096 Y-092 Rb-088 Ru-098

,

STABLE STABLE

Table IV.

N 1

,

STABLE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

Table V. List of all isotopes and their reaction that appear in the network related to Sb-135 Sb-135, N 1 3 5 7 9 11 13 15 17 19 21 23 25 27

Isotope Te-135 I-135 Xe-135 Cs-135 Ba-135 Ba-136 Ba-137 Ba-138 Ba-139 La-139 La-140 Ce-140 Ce-141 Pr-141

Reactions

, ,

,

N 29 31 33 35 37 39 41 2 4 6 8 10 12 14

Isotope Pr-142 Pr-143 Nd-143 Nd-144 Pr-144 Ce-142 Nd-149 Ce-143 Ce-144 Ce-145 Nd-145 Nd-146 Nd-147 Pm-147

34

Reactions , ,

, , , , ,

N 16 18 20 22 24 26 28 30 32 34 36 38 40

Isotope Sm-147 Sm-148 Sm-146 Pm-148 Pm-149 Nd-148 Nd-142 Pr-145 Cs-136 Cs-137 Cs-138 Xe-136 Xe-137

Reactions , , , , ,

, ,