Abstract:
The method comprises the steps of: partitioning the core in cubes to constitute nodes of a grid for computer implemented calculation, splitting the cubes into a first category and a second category, each cube of the first category being adjacent only to cubes from the second category so that the first category and second category of cubes constitute a checkerboard-like pattern, ordering the cubes of the first category and then the cubes of the second category, calculating neutron flux and/or thermohydraulics parameters by using an iterative solving procedure of at least one linear system and/or an eigensystem, the components of an iterant of the linear system and/or the eigensystem constituting the neutron flux and/or thermohydraulics parameters to be calculated, wherein, during the iterative solving procedure, calculations are conducted on the cubes of the first category then on the cubes of the second category.

Description:
The invention relates to a method for modelizing the core of a nuclear reactor. 
     BACKGROUND 
     Such a modelizing method is helpful to calculate neutron flux and/or thermohydraulics parameters within the core. 
     The results of such a modelizing method can be used to prepare safety analysis reports before building and starting a reactor. 
     These results can also be useful for existing nuclear reactors and especially for managing the nuclear fuel loaded therein. In particular, these results can be used to assess how the core design should evolve in time and decide of the positions of the fuel assemblies in the core, especially the positions of the fresh assemblies to be introduced in the core. 
     Such modelizing methods are implemented by computers. To this end, the core is partitioned in cubes, each cube constituting a node of a grid for implementing a digital computation. 
     In the state of the art methods, the cubes are numbered one after the other in a lexicographical order. 
     In such methods, most of the computational efforts are concentrated in the part dedicated to the iterative solving of large sparse systems, which end up being either linear systems or eigensystems. 
     When calculating thermohydraulics parameters, the system to be solved is a linear system and corresponds, in mathematical form, to a linear equation of the form:
 
A x = b   (1)
 
     A typical whole nuclear core computation amounts to a sparse linear system being defined on the basis of between 150 and 200 fuel assemblies and typically several tens of thousands of cubes, meaning that a nontrivial computational effort is required for solving the associated algebraic systems. 
     The actual structure of the matrix A is characterized by the systematic presence of diagonal elements plus a limited number of nonzero offdiagonal elements, which each represent interactions between a cube and the directly neighbouring cubes only. In other words, only interactions between cubes sharing common surfaces are considered. 
     With a lexicographical grid, the few nonzero values [A D +A LD ] ij , with A D  and A LD  being respectively the diagonal and lower diagonal part of A, represent the interaction of a cube i with itself and with directly neighbouring cubes j that have lower lexicographical indices, so with j≦i. 
     In order to solve the above-mentioned linear equation, a Gauss-Seidel (GS) procedure is usually implemented, meaning that the matrix A is split into its diagonal A D  plus lower-diagonal part A LD  on the one hand and its upper-diagonal part A UD  on the other hand:
 
 A=[A   D   +A   LD   ]+A   UD   (2)
 
     With the diagonal plus lower-triangular part being easy to invert implicitly, the GS procedure amounts to the iteration:
 
   x     (n+1)   =[A   D   +A   LD ] −1 (   b −A   UD     x     (n) )  (3)
 
     which can and has been programmed very compactly and efficiently in the form:
 
   x     (n+1)   =[A   D ] −1 (   b −A   LD     x     (n+1)   −A   UD     x     (n) )=   x     (n)   − r     (n+1/2)   (4)
 
with    r     (n+1/2)   =[A   D ] −1 (   b −[A   D   +A   LD   ] x     (n+1)   −A   UD     x     (n) ),  (5)
 
     according to which, during a new GS iteration, each update for cube i “profits” from already realized updates (during the same iteration) for its neighbours cubes that have lower lexicographical indices. 
     As for the coupling with the remaining neighbours, i.e. the ones with higher lexicographical indices, other values must be used that emerged from previous GS iterations. 
     The convergence speed of this GS procedure is usually accelerated by application of a systematic Successive Over-Relaxation (SOR) measure with relaxation factor ω, which amounts to the final implementation of:
 
   x     (n+1)   = x     (n)   −ω r     (n+1/2)   (6)
 
     Upon convergence, the residual  r  converges toward  0  and the iterant  x  converges toward the exact solution of the linear system. On a sequential basis, i.e. with the GS iteration being performed sequentially by a single processor, the performance of this GS/SOR procedure is certainly not bad. 
     However, an important issue of concern in the currently implemented GS/SOR procedure is the highly sensitive dependence of computational performance on the choice of a value for the relaxation factor ω to be applied in the SOR scheme. 
     Minor variations in the value for the relaxation factor ω have been found to lead to substantial differences in convergence speed, meaning that small departures from a typically empirically determined optimum will lead to heavy losses in computational efficiency. 
     The relaxation factor ω is currently a parameter to be set by the user of the computer implementing the modelizing method. This user cannot be expected to be able to determine the optimum choice for the factor ω for each individual case of relevance. The value of this optimum choice may indeed depend on several parameters, like channel dimensions, material properties, temperature, etc., anything which determines the individual components of the matrix in the linear system to be solved. For a user, it is therefore not possible to predetermine shifts in this optimum choice depending on state changes. With the identified performance sensitivity, it can be expected that default values for the relaxation factor ω will, on average, lead to performance losses when applied as a fixed SOR parameter for different computational cases. 
     Further, with the current GS procedure, the distribution of iterative workload on different processors would lead to a severe degradation of computational efficiency, even for low numbers of parallel processors, so that no major speed computation improvement could be obtained through parallelization. 
     SUMMARY OF THE INVENTION 
     An object of the present invention is to solve the above-mentioned problems by providing a modelizing method which offers a better computational robustness and a better computational efficiency so that relevant core simulations can be obtained within short computational time period. 
     The present invention provides a computer implemented method for modelizing a nuclear reactor core, comprising the steps of: partitioning the core in cubes ( 1 B,  1 R) to constitute nodes of a grid for computer implemented calculation, splitting the cubes into a first category ( 1 R) and a second category ( 1 B), each cube of the first category ( 1 R) being adjacent only to cubes ( 1 R) from the second category so that the first category and second category of cubes constitute a checkerboard-like pattern, ordering the cubes ( 1 R) of the first category and then the cubes ( 1 B) of the second category, calculating neutron flux and/or thermohydraulics parameters by using an iterative solving procedure of at least one linear system and/or an eigensystem, the components of an iterant of the linear system and/or the eigensystem constituting the neutron flux and/or thermohydraulics parameters to be calculated, wherein, during the iterative solving procedure, calculations are conducted on the cubes of the first category then on the cubes of the second category. 
     The present invention also provides a computer program product residing on a computer readable medium and comprising a computer program means for running on a computer the method provided in the present invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The invention will be better understood upon reading of the following description, which is given solely by way of example and with reference to the appended drawings, in which: 
         FIG. 1  is a schematic view illustrating the partitioning of a nuclear core according to the present invention, 
         FIG. 2-4  are graphs comparing the convergence speeds of modelizing methods according to the invention with state of the art modelizing methods, and 
         FIG. 5  is a diagram illustrating the improvements in computation time period obtained through parallelization of a modelizing method according to the invention. 
     
    
    
     DETAILED DESCRIPTION 
     In the following description, the case of a pressurized water reactor (PWR) will be considered, but it should be kept in mind that the present invention applies to other types of nuclear reactors. 
     In a first step of the computer implemented modelizing method according to the invention, the core of the reactor is partitioned in cubes as in the state of art methods. Each cube corresponds to a node of a grid or network  3  on which numerical computation will be implemented through the computer. 
     In order to ease the representation, the grid is shown on  FIG. 1  as being two-dimensional, but it should be kept in mind that the grid is actually three-dimensional in order to represent the whole core. 
     According to a first aspect of the invention, the cubes are split into a first category and a second category. 
     In the following description, the cubes  1 R of the first category will be called the red cubes and the cubes  1 B of the second category will be called the black cubes but no specific restrictive meaning should be associated with the words “black” and “red”. Each red cube  1 R has only black cubes  1 B as direct neighbours. Thus, most of the red cubes  1 R have six direct black neighbours  1 B. It should be understood by “direct” neighbours, the cubes sharing a common surface with the considered cube. 
     Consequently, and as illustrated by  FIG. 1 , the grid has a visual analogy with respect to the dark and light regions of a checkerboard. 
     Then, the cubes are numbered, starting for example by the red cubes  1 R and ending by the black cubes  1 B. 
     In the following description, such a split of the cubes in two categories and the numbering of one category after the other will be referred to as red-black ordering. 
     An advantage of a red-black ordering of the cubes in comparison with the state of the art lexicographical ordering is that, for a red cube  1 R, all its direct neighbours will be black, and vice versa. 
     In the following first embodiments of the description, a modelizing method will be implemented to calculate thermohydraulics parameters. 
     The linear Equation (1), which the computer has to solve in order to calculate the thermohydraulics parameters of the core, can be written in the general, diagonally preconditioned form:
 
(1+ A   ND )   x = b     (7)
 
     The nondiagonal matrix A ND  is sparse, coupling red cubes  1 R only to direct black neighbours  1 B and vice versa. Thus, the red-black ordering enables the following convenient relationship between the red and the black parts of the equation: 
     
       
         
           
             
               
                 
                   { 
                   
                     
                       
                         
                           
                             
                               
                                 x 
                                 _ 
                               
                               red 
                             
                             + 
                             
                               
                                 A 
                                 ND 
                               
                               ⁢ 
                               
                                 
                                   x 
                                   _ 
                                 
                                 black 
                               
                             
                           
                           = 
                           
                             
                               b 
                               _ 
                             
                             red 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               
                                 x 
                                 _ 
                               
                               black 
                             
                             + 
                             
                               
                                 A 
                                 ND 
                               
                               ⁢ 
                               
                                 
                                   x 
                                   _ 
                                 
                                 red 
                               
                             
                           
                           = 
                           
                             
                               b 
                               _ 
                             
                             black 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
     From a calculation point of view, the use of a red-black ordering means that, during an iterative solving procedure if, in the first half of an iteration, the red components  x   red  of the iterant  x  are updated, then, during the second part of the iteration, all the black components  x   black  will be updated on the basis of the red components of their red neighbours  x   red . In other words, the value for each black cube  1 B will be calculated on the basis of the values for all its direct red neighbours  1 R. 
     Thus, an iteration amounts to: 
     
       
         
           
             
               
                 
                   ( 
                   9 
                   ) 
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   { 
                   
                     
                       
                         
                           
                             
                               x 
                               _ 
                             
                             red 
                             
                               ( 
                               
                                 n 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 b 
                                 _ 
                               
                               red 
                             
                             - 
                             
                               
                                 A 
                                 ND 
                               
                               ⁢ 
                               
                                 
                                   x 
                                   _ 
                                 
                                 black 
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               x 
                               _ 
                             
                             black 
                             
                               ( 
                               
                                 n 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 b 
                                 _ 
                               
                               black 
                             
                             - 
                             
                               
                                 A 
                                 ND 
                               
                               ⁢ 
                               
                                 
                                   x 
                                   _ 
                                 
                                 red 
                                 
                                   ( 
                                   
                                     n 
                                     + 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
     The use of a red-black ordering helps improving the computational efficiency. Indeed,  FIG. 2  shows that the number of iterations would be higher for a state of the art method based on lexicographical ordering and using a GS procedure (curve  5 ) than for a method according to the invention based on a red-black ordering and using a GS procedure (curve  7 ). 
     Indeed, and as previously stressed, if in the first half of the GS iteration the red components of the iterant  x  are updated, during the second part of the iteration all the black updates will receive co-updates from all of their red neighbours, instead of from only half of them like in the case of the lexicographical ordering. It is this particular property difference which explains the observed convergence speed difference between the two different orderings. 
     The red-black ordering constitutes a first aspect of the present invention which can be used with various solving procedures. 
     Such a red-black ordering proves to be especially useful when used with a particular solving procedure which constitutes a second aspect of the invention. 
     This procedure is a particular highly robust stabilized Bi-Conjugate Gradient Stabilized (Bi-CGStab) procedure. An adequate introductory description of this procedure can be found in the following references:
         Y. Saad, “Iterative Methods for Sparse Linear Systems”, second edition, Society for Industrial and Applied Mathematics (SIAM) (2003);   H. A. van der Vorst, “Bi-CGSTAB: a Fast and Smoothly Converging Variant of Bi-CG for the solution of nonsymmetric linear systems”, SIAM J. Sci. Stat. Comput. 13(2), pp. 631-644 (1992),       

     The Bi-CGStab method is derived from a minimization principle for a functional of  x , with given A and  b , for which stationarity applies with regard to small variations δ x  around the specific optimum  x  which satisfies, exactly, the linear system A x = b , and for which the functional assumes a minimum value. 
     Thus, it is possible to define a solving procedure driven by the minimization of a functional rather than by more direct considerations on how to solve A x = b  efficiently. The Bi-CGStab procedure follows from such a minimization principle, where the successive changes in the iterant are organized such that each change in the functional (which is like a Galerkin-weighted integrated residual) is orthogonal with respect to all of the preceding changes. 
     The particular Bi-CGStab procedure according to the second aspect of the invention is given below with solution vector  x , solution residual r (with  r =b−A x) and auxiliary vector r*, s and p, and with initial solution estimate x 0 : 
     
       
         
           
             
               
                 
                   
                     
                       1. 
                     
                     
                       
                         
                           
                             r 
                             0 
                           
                           = 
                           
                             b 
                             - 
                             
                               A 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 x 
                                 0 
                               
                             
                           
                         
                         ; 
                         
                             
                         
                         ⁢ 
                         
                           
                             r 
                             * 
                           
                           = 
                           
                             r 
                             0 
                           
                         
                       
                     
                   
                   
                     
                       2. 
                     
                     
                       
                         
                           p 
                           0 
                         
                         = 
                         
                           r 
                           0 
                         
                       
                     
                   
                   
                     
                       3. 
                     
                     
                       
                         
                           
                             do 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                           = 
                           0 
                         
                         , 
                         1 
                         , 
                         … 
                         ⁢ 
                         
                             
                         
                         , 
                         N 
                       
                     
                   
                   
                     
                       4. 
                     
                     
                       
                         
                           α 
                           i 
                         
                         = 
                         
                           
                             ( 
                             
                               
                                 r 
                                 * 
                               
                               , 
                               
                                 r 
                                 i 
                               
                             
                             ) 
                           
                           
                             ( 
                             
                               
                                 r 
                                 * 
                               
                               , 
                               
                                 A 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   p 
                                   i 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       5. 
                     
                     
                       
                         
                           s 
                           i 
                         
                         = 
                         
                           
                             r 
                             i 
                           
                           - 
                           
                             
                               α 
                               i 
                             
                             ⁢ 
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               p 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       6. 
                     
                     
                       
                         
                           ω 
                           i 
                         
                         = 
                         
                           
                             ( 
                             
                               
                                 A 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   s 
                                   i 
                                 
                               
                               , 
                               
                                 s 
                                 i 
                               
                             
                             ) 
                           
                           
                             ( 
                             
                               
                                 A 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   s 
                                   i 
                                 
                               
                               , 
                               
                                 A 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   s 
                                   i 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       7. 
                     
                     
                       
                         
                           x 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                         
                           
                             x 
                             i 
                           
                           + 
                           
                             
                               α 
                               i 
                             
                             ⁢ 
                             
                               p 
                               i 
                             
                           
                           + 
                           
                             
                               ω 
                               i 
                             
                             ⁢ 
                             
                               s 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       8. 
                     
                     
                       
                         
                           r 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                         
                           
                             s 
                             i 
                           
                           - 
                           
                             
                               ω 
                               i 
                             
                             ⁢ 
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               s 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       9. 
                     
                     
                       
                         
                           β 
                           i 
                         
                         = 
                         
                           
                             
                               ( 
                               
                                 
                                   r 
                                   * 
                                 
                                 , 
                                 
                                   r 
                                   
                                     i 
                                     + 
                                     1 
                                   
                                 
                               
                               ) 
                             
                             
                               ( 
                               
                                 
                                   r 
                                   * 
                                 
                                 , 
                                 
                                   r 
                                   i 
                                 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             
                               α 
                               i 
                             
                             
                               ω 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       10. 
                     
                     
                       
                         
                           p 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                         
                           
                             r 
                             
                               i 
                               + 
                               1 
                             
                           
                           + 
                           
                             
                               β 
                               
                                 i 
                                 + 
                                 1 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   p 
                                   i 
                                 
                                 - 
                                 
                                   
                                     ω 
                                     i 
                                   
                                   ⁢ 
                                   A 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     p 
                                     i 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       11. 
                     
                     
                       
                         end 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         do 
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
     Typically, the Bi-CGStab method requires a preconditioner for it to offer good convergence behaviour. 
     This means, for example, that both sides of the linear system are premultiplied by the so-called preconditioning matrix. This matrix can have an explicit form, like a diagonal preconditioner, or an implicit form, like an implicit approximated inverse of the system matrix A which offers a sufficiently adequate approximation for A − , which means sufficiently adequate for preconditioning purposes. 
     Another way, which is adopted in the present embodiment and which constitutes the third aspect of the invention, is to rewrite or transform the original equation such that the matrix appearing on the left allows good preconditioning using only a simple inverted diagonal matrix, by making sure that the diagonal will be sufficiently dominant in the transformed form. 
     Good preconditioners or good transformations typically manage to pre-include crucial information or the major part of that information, with regard to the physical interactions between nodes that determine the spatial couplings and hence the solution of the equation. The particular case under study here is no exception in that respect. 
     With the specific form A=1+A ND , applicable to the system to be solved iteratively, a direct red-black variant of the Bi-CGStab method, with Equation (7) applied, and no further preconditioning, converges rather slowly in comparison with the GS procedure optimized by a SOR post-measure. 
     However, it is possible to use a first-order truncation of the expansion:
 
(1 +A   ND ) −1 =1 −A   ND   +A   ND   2   −A   ND   3   +A   ND   4   −A   ND   5 +  (11)
 
     which is a Krylov expansion that follows directly from a Taylor formula, and which is also pursued implicitly during the Jacobi process  x   (n+1) = b −A ND   x   (n) , leading to: 
     
       
         
           
             
               
                 
                   
                     
                       x 
                       _ 
                     
                     
                       ( 
                       ∞ 
                       ) 
                     
                   
                   = 
                   
                     
                       lim 
                       
                         n 
                         → 
                         ∞ 
                       
                     
                     ⁢ 
                     
                       ( 
                       
                         
                           
                             
                               [ 
                               
                                 
                                   ∑ 
                                   
                                     m 
                                     = 
                                     0 
                                   
                                   n 
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       ( 
                                       
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                     m 
                                   
                                   ⁢ 
                                   
                                     A 
                                     ND 
                                     m 
                                   
                                 
                               
                               ] 
                             
                             
                               ︸ 
                               
                                 → 
                                 
                                   
                                     ( 
                                     
                                       1 
                                       + 
                                       
                                         A 
                                         ND 
                                       
                                     
                                     ) 
                                   
                                   
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                           ⁢ 
                           
                             b 
                             _ 
                           
                         
                         + 
                         
                           
                             
                               A 
                               ND 
                               n 
                             
                             ⁢ 
                             
                               
                                 x 
                                 _ 
                               
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                           
                             ︸ 
                             
                               → 
                               0 
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
     and from the limit case of which the validity of Equation (11) is confirmed. Now, using the first-order truncation 1−A ND  of the matrix expansion expressed in Equation (12) as a preconditioner, it turns out that the convergence efficiency of the Bi-CGStab method can be improved substantially. Premultiplication of the left and right hand sides of Equation (7) with this first-order preconditioner 1−A ND  yields the transformed system 
     
       
         
           
             
               
                 
                   
                     
                       A 
                       _ 
                     
                     ⁢ 
                     
                       x 
                       _ 
                     
                   
                   = 
                   
                     
                       b 
                       _ 
                       _ 
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     with 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       { 
                       
                         
                           
                             
                               
                                 A 
                                 _ 
                               
                               = 
                               
                                 1 
                                 - 
                                 
                                   A 
                                   ND 
                                   2 
                                 
                               
                             
                           
                         
                         
                           
                             
                               
                                 b 
                                 _ 
                                 _ 
                               
                               = 
                               
                                 
                                   b 
                                   _ 
                                 
                                 - 
                                 
                                   
                                     A 
                                     ND 
                                   
                                   ⁢ 
                                   
                                     b 
                                     _ 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
     Use of this particular preconditioner means that the direct neutronic interaction between neighbouring (red vs. black) nodes/cubes is preincluded in the system to be solved, making the unity operator more dominant since
 
∥A ND   2 ∥&lt;∥A ND ∥.
 
     This leads to a substantial efficiency increase when applying the Bi-CGStab procedure. 
     As will be discussed hereunder in more details, this form offers the additional crucial advantage that the iterative solution can be restricted to one colour only (either only red or only black). Then, the values of the opposite colour can be postcomputed directly, without any further need for iterations. This is because the operator A ND   2  couples nodes/cubes only if they have the same colour (so red with red, or black with black). 
     In this sense, it can be compressed to a single-colour checkerboard equation, where the entire equation as well as the solution procedure can be defined and pursued at the level of only half of the nodes/cubes, after the choice of the colour to be solved. 
     With a purely red-black form of the linear system, as indicated in Equation (9), Equation (13) is equivalent to a formulation of the equation for merely the red or merely the black part of the system. 
     Expressing  x   black  in terms of the fixed black source part  b   black  and the red solution part  x   red , and substituting this in the equation for the red part, we get the form for the red solution part only: 
     
       
         
           
             
               
                 
                   
                     
                       
                         A 
                         _ 
                       
                       red 
                     
                     ⁢ 
                     
                       
                         x 
                         _ 
                       
                       red 
                     
                   
                   = 
                   
                     
                       
                         b 
                         _ 
                         _ 
                       
                       red 
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     with 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       { 
                       
                         
                           
                             
                               
                                 
                                   A 
                                   _ 
                                 
                                 red 
                               
                               = 
                               
                                 1 
                                 - 
                                 
                                   A 
                                   ND 
                                   2 
                                 
                               
                             
                           
                         
                         
                           
                             
                               
                                 
                                   b 
                                   _ 
                                   _ 
                                 
                                 red 
                               
                               = 
                               
                                 
                                   
                                     b 
                                     _ 
                                   
                                   red 
                                 
                                 - 
                                 
                                   
                                     A 
                                     ND 
                                   
                                   ⁢ 
                                   
                                     
                                       b 
                                       _ 
                                     
                                     black 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
     For the black part, a similar form applies. 
     Hence, it is possible to solve only the red solution part on the basis of Equation (14) and, after convergence, solve the black part directly from the black equation part of Equation (9). 
     For the efficient and, especially, robust solution of Equation (14), the specially-tailored checkerboard-preconditioned Bi-CGStab method, defined on merely half of the grid, is given by: 
     
       
         
           
             
               
                 
                   
                     
                       1. 
                     
                     
                       
                         
                           
                             r 
                             
                               red 
                               , 
                               0 
                             
                           
                           = 
                           
                             
                               b 
                               red 
                             
                             - 
                             
                               
                                 
                                   A 
                                   _ 
                                 
                                 red 
                               
                               ⁢ 
                               
                                 x 
                                 
                                   red 
                                   , 
                                   0 
                                 
                               
                             
                           
                         
                         ; 
                         
                             
                         
                         ⁢ 
                         
                           
                             r 
                             * 
                           
                           = 
                           
                             r 
                             
                               red 
                               , 
                               0 
                             
                           
                         
                       
                     
                   
                   
                     
                       2. 
                     
                     
                       
                         
                           p 
                           
                             red 
                             , 
                             0 
                           
                         
                         = 
                         
                           r 
                           
                             red 
                             , 
                             0 
                           
                         
                       
                     
                   
                   
                     
                       3. 
                     
                     
                       
                         
                           
                             do 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                           = 
                           0 
                         
                         , 
                         1 
                         , 
                         … 
                         ⁢ 
                         
                             
                         
                         , 
                         N 
                       
                     
                   
                   
                     
                       4. 
                     
                     
                       
                         
                           α 
                           i 
                         
                         = 
                         
                           
                             ( 
                             
                               
                                 r 
                                 red 
                                 * 
                               
                               , 
                               
                                 r 
                                 
                                   red 
                                   , 
                                   i 
                                 
                               
                             
                             ) 
                           
                           
                             ( 
                             
                               
                                 r 
                                 red 
                                 * 
                               
                               , 
                               
                                 
                                   
                                     A 
                                     _ 
                                   
                                   red 
                                 
                                 ⁢ 
                                 
                                   p 
                                   
                                     red 
                                     , 
                                     i 
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       5. 
                     
                     
                       
                         
                           s 
                           
                             red 
                             , 
                             i 
                           
                         
                         = 
                         
                           
                             r 
                             
                               red 
                               , 
                               i 
                             
                           
                           - 
                           
                             
                               α 
                               i 
                             
                             ⁢ 
                             
                               
                                 A 
                                 _ 
                               
                               red 
                             
                             ⁢ 
                             
                               p 
                               
                                 red 
                                 , 
                                 i 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       6. 
                     
                     
                       
                         
                           ω 
                           i 
                         
                         = 
                         
                           
                             ( 
                             
                               
                                 
                                   
                                     A 
                                     _ 
                                   
                                   red 
                                 
                                 ⁢ 
                                 
                                   s 
                                   
                                     red 
                                     , 
                                     i 
                                   
                                 
                               
                               , 
                               
                                 s 
                                 
                                   red 
                                   , 
                                   i 
                                 
                               
                             
                             ) 
                           
                           
                             ( 
                             
                               
                                 
                                   
                                     A 
                                     _ 
                                   
                                   red 
                                 
                                 ⁢ 
                                 
                                   s 
                                   
                                     red 
                                     , 
                                     i 
                                   
                                 
                               
                               , 
                               
                                 
                                   
                                     A 
                                     _ 
                                   
                                   red 
                                 
                                 ⁢ 
                                 
                                   s 
                                   
                                     red 
                                     , 
                                     i 
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       7. 
                     
                     
                       
                         
                           x 
                           
                             red 
                             , 
                             
                               i 
                               + 
                               1 
                             
                           
                         
                         = 
                         
                           
                             x 
                             
                               red 
                               , 
                               i 
                             
                           
                           + 
                           
                             
                               α 
                               i 
                             
                             ⁢ 
                             
                               p 
                               
                                 red 
                                 , 
                                 i 
                               
                             
                           
                           + 
                           
                             
                               ω 
                               i 
                             
                             ⁢ 
                             
                               s 
                               
                                 red 
                                 , 
                                 i 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       8. 
                     
                     
                       
                         
                           r 
                           
                             red 
                             , 
                             
                               i 
                               + 
                               1 
                             
                           
                         
                         = 
                         
                           
                             s 
                             
                               red 
                               , 
                               i 
                             
                           
                           - 
                           
                             
                               ω 
                               i 
                             
                             ⁢ 
                             
                               
                                 A 
                                 _ 
                               
                               red 
                             
                             ⁢ 
                             
                               s 
                               
                                 red 
                                 , 
                                 i 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       9. 
                     
                     
                       
                         
                           β 
                           i 
                         
                         = 
                         
                           
                             
                               ( 
                               
                                 
                                   r 
                                   red 
                                   * 
                                 
                                 , 
                                 
                                   r 
                                   
                                     red 
                                     , 
                                     
                                       i 
                                       + 
                                       1 
                                     
                                   
                                 
                               
                               ) 
                             
                             
                               ( 
                               
                                 
                                   r 
                                   red 
                                   * 
                                 
                                 , 
                                 
                                   r 
                                   
                                     red 
                                     , 
                                     i 
                                   
                                 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             
                               α 
                               i 
                             
                             
                               ω 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       10. 
                     
                     
                       
                         
                           p 
                           
                             red 
                             , 
                             
                               i 
                               + 
                               1 
                             
                           
                         
                         = 
                         
                           
                             r 
                             
                               red 
                               , 
                               
                                 i 
                                 + 
                                 1 
                               
                             
                           
                           + 
                           
                             
                               β 
                               
                                 i 
                                 + 
                                 1 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   p 
                                   
                                     red 
                                     , 
                                     i 
                                   
                                 
                                 - 
                                 
                                   
                                     ω 
                                     i 
                                   
                                   ⁢ 
                                   A 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     p 
                                     
                                       red 
                                       , 
                                       i 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       11. 
                     
                     
                       
                         end 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         do 
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
     As previously indicated, procedure (15) can be referred to as a single-colour checkerboard equation, where the entire equation as well as the solution procedure can be defined and pursued at the level of only half of the nodes/cubes, after the choice of the colour to be solved. 
     The nodes/cubes of opposite colour are then typically used for enabling the application of A ND   2  by two successive applications of A ND  which is a red-black operator. 
     From this approach, the convenient red-black sparsity of the applied matrix is preserved, i.e. a precomputed and prestored explicit checkerboard-preconditioned offdiagonal matrix, which would allow ignorance of the nodes of opposite colour, would simply have a lot more offdiagonal nonzero elements. 
     It is worth noting here that the main workload per iteration, i.e. the application of A ND   2  on half of the grid (red cubes only for example), gives a computational effort similar to the one involved in pursuing one GS iteration on a red-black ordered grid, with A ND  applied on the full grid (red cubes first, then black cubes). The workload for computing the scalar sums is low. 
     In  FIG. 3 , the convergence behaviour of the checkerboard-preconditioned Bi-CGStab procedure (curve  9 ), up to solution accuracy ε=10 −8  is plotted in comparison with GS/SOR procedure (curve  11 ) with the best SOR parameter value applied (ω=1.8), both of these procedures being applied on a red-black ordered grid. 
     From  FIG. 3 , it is clear that the parameter-free checkerboard-preconditioned Bi-CGStab procedure offers at least the same convergence speed as the GS procedure with the highest possible degree of SOR acceleration. 
     With the checkerboard-preconditioned Bi-CGStab procedure being parameter-free, it can be expected to offer a guaranteed competitive (or even better) performance also for cases where the optimum SOR parameter is different from the one that was applied here. 
     The computational effort per Bi-CGStab step is slightly larger than twice a GS-step, but not much larger if the Bi-CGStab procedure is programmed efficiently. However, the Bi-CGStab procedure, if combined with a good preconditioner, requires dramatically fewer iterative steps for fulfilling a prespecified error criterium. 
     Therefore, keeping in mind heavy performance sensitivity with regard to small variations in the SOR parameters, the checkerboard-preconditioned Bi-CGStab procedure thereby presents itself as a substantially more robust, reliable and parameter-free choice for pursuing iterations on the platform of a red-black ordered grid. 
     Thus, the above-disclosed method can be efficiently used to obtain relevant core simulations in a shorter time period. 
     Another convenient property, worth mentioning separately, is the fact that the node residuals appear explicitly in the Bi-CGStab equations, such that they do not have to be computed separately for purposes of convergence monitoring. 
     In the convergence examples disclosed so far, the convergence criterium adopted was the one which is conventionally used for the i th  iteration of traditional SOR-accelerated Jacobi or Gauss-Seidel iterations, 
     
       
         
           
             
               
                 
                   
                     
                       ɛ 
                       max 
                     
                     ⁡ 
                     
                       ( 
                       i 
                       ) 
                     
                   
                   = 
                   
                     
                       max 
                       
                         
                           j 
                           = 
                           1 
                         
                         , 
                         … 
                         ⁢ 
                         
                             
                         
                         , 
                         N 
                       
                     
                     ⁢ 
                     
                        
                       
                         
                           
                             x 
                             j 
                             
                               ( 
                               i 
                               ) 
                             
                           
                           
                             x 
                             j 
                             
                               ( 
                               
                                 i 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                         - 
                         1 
                       
                        
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
     for the specific reason that this is the currently still default definition of the convergence criterium. However, instead of merely monitoring how much an iterant differs from its predecessor, one can also monitor directly the evolution in the actual residual  b −A x  of the linear equation to be solved, which is to converge to 0 when exact fulfillment of the equation is established. 
     This can, optionally, be done for merely the transformed unicolor part of the unicolor-transformed equation in this case:
 
 r   red   =  b     red   −Ā   red     x     red   (17)
 
     As mentioned previously, a convenient property of the Bi-CGStab procedure is the fact that the node residuals appear explicitly, such that they do not have to be computed separately for purposes of convergence monitoring. When using the maximum cube residual:
 
 r   max ( i )=max j=1, . . . , N   |r   j   (i)|   (18)
 
     s the convergence monitoring quantity, which constitutes a fourth aspect of the invention, it turns out that the Bi-CGStab procedure in fact offers a noticeable performance enhancement in comparison with the optimized GS procedure. 
     This is connected to the property that the Bi-CGStab procedure is specifically tailored for optimally efficient and fast minimization of an integrated, Galerkin-weighted residual of the linear equation. 
     Repeating the comparison between the checkerboard-preconditioned Bi-CGStab procedure (curve  13 ) and red-black SOR-accelerated GS procedure (curve  15 ), the latter with the empirically determined optimum choice (ω=1.8) for the SOR parameter, we get the picture shown in  FIG. 4 . 
     This particular comparison confirms the expected performance enhancement connected to the use of checkerboard-preconditioned Bi-CGStab compared to red-black GS, in case of a use of r max  (i) as the convergence monitoring quantity for the i th  iteration. 
     Thus, in case of the red-black GS approach, the black part of the solution is always ahead of the red part since the black nodes always profit from the updated information in their red neighbours. 
     Another way of formulating this is that the red part of the iterant is always “lagging behind”, which means that one will always have to expect an “unfair” difference in absolute residuals between red and black nodes. With the checkerboard-preconditioned Bi-CGStab approach, this “unfair” difference is eliminated totally, which serves to explain the convergence speed advantage of checkerboard-preconditioned Bi-CGStab compared to red-black GS that can be observed in  FIG. 4 . 
     Further, it is recommended, according to the fourth aspect of the invention, to adopt r max (i) as the convergence monitoring quantity for red-black Bi-CGStab applications, since this:
         is a fundamentally more meaningful convergence monitoring quantity, which indicates much more strictly whether the equation is satisfied, or not   will avoid the storage of old iterants x (i)      will spare the computation, for each step i, of the old convergence criterium ε i  as in Equation (16).       

     Another point worth mentioning is that a solving procedure based on a red-black ordering can be parallelized straightforwardly so that the computational efficiency can be further improved. 
     Indeed, with a red-black ordering, there is no degradation when the red and black node computations are subdivided subsequently between processors, i.e. with the red node computations being first subdivided between the processors and then the black node computations being subdivided between the processors. 
     This holds true not only when a GS procedure is used but also with other procedures such as a CG procedure. 
     For a GS procedure, this independence is connected to the property that, in the first half of a red-black GS iteration, the red updates depend on old neighbour information from the previous parallelized GS iteration, all the results of which have been communicated already to all the parallel processors. This feature is independent on how many parallel processors are used. During the second, black part of the iteration, all updates on all the red values will be known in all processors since these were uniformly communicated and distributed by the master processor at the end of the first half of the present GS iteration. 
     Again, this is independent on how many parallel processors are used, meaning that the application of N parallel processors will result in a theoretical speed-up factor of N. 
     In practice, due to interprocessor communications, this gain is reduced a bit but typically not much, meaning that very large speedups are possible in any case. 
     Commonly, the very outer part of a red-black GS iteration is a loop over red and black cubes, usually represented by something in the nature of “do i_rb=1,2”, and it&#39;s typically the inner loops over the large numbers of cubes which are parallelly assigned to the different processors. 
     In  FIG. 5 , different simulated waiting times scenarios are plotted as a function of the numbers of available parallel processor(s)  1  (curve  17 ),  2  (curve  19 ),  4  (curve  21 ) and  8  (curve  23 ), in case of red-black ordering. In case of lexicographic ordering, the algorithm efficiency degrades more and more as the number of processors increases, leading to very disappointing speedups when doing parallel computations. 
     The above examples have been given with reference to the computation of thermohydraulics parameters. 
     However, the invention also applies to the computation of neutron flux as disclosed hereunder. 
     In this case, the sparse system to solve is an eigensystem. 
     Such a system amounts to:
 
 {circumflex over (M)} d =λ{circumflex over (F)} d + Q     (19)
 
     with {circumflex over (M)} and {circumflex over (F)} the loss-migration and production operators, respectively, and with  Q = 0  for steady-state cases and λ def =1 for transient cases. For specific numerical solution purposes, the loss and migration operator {circumflex over (M)} can be divided in its diagonal and non-diagonal parts:
 
 {circumflex over (M)}={circumflex over (M)}   D   +{circumflex over (M)}   ND   (20)
 
     with the non-diagonal part {circumflex over (M)} ND  being a red-black operator, i.e. when applied to a red vector it yields a black vector and vice versa. The red-black ordering of the nodes is used in the setup of the iterations, using the property [{circumflex over (M)} ND   d   (n) ] red ={circumflex over (M)} ND   d   black   (n)  and [{circumflex over (M)} ND   d   (n) ] black ={circumflex over (M)} ND   d   red   (n) , which are specific for the relationship between currents defined over the surface boundaries of red and black nodes in an interface current formulation of the neutronic balance equation (out-currents of red nodes are in-currents for black nodes). 
     A classical GS iterative procedure (with iteration index n) can be set up such that each iterative sweep consist of a red part followed by a black part: first the red part of the iterant  d   red  is updated, after which this updated part of the iterant  d   red  is used to generate a further improved update of the black part  d   black  of the iterant: 
     
       
         
           
             
               
                 
                   
                     
                       
                         d 
                         _ 
                       
                       red 
                       
                         ( 
                         
                           n 
                           + 
                           1 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           M 
                           ^ 
                         
                         D 
                         
                           - 
                           1 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               λ 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             ⁢ 
                             
                               F 
                               ^ 
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               red 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                           - 
                           
                             
                               
                                 M 
                                 ^ 
                               
                               ND 
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               black 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                           + 
                           
                             
                               Q 
                               _ 
                             
                             red 
                           
                         
                         ] 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         d 
                         _ 
                       
                       black 
                       
                         ( 
                         
                           n 
                           + 
                           1 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           M 
                           ^ 
                         
                         D 
                         
                           - 
                           1 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               λ 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             ⁢ 
                             
                               F 
                               ^ 
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               black 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                           - 
                           
                             
                               
                                 M 
                                 ^ 
                               
                               ND 
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               red 
                               
                                 ( 
                                 
                                   n 
                                   + 
                                   1 
                                 
                                 ) 
                               
                             
                           
                           + 
                           
                             
                               Q 
                               _ 
                             
                             black 
                           
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
     or, with the restricted production operator {circumflex over (F)} being diagonal, through application of 
     
       
         
           
             
               
                 
                   
                     
                       
                         d 
                         _ 
                       
                       red 
                       
                         ( 
                         
                           n 
                           + 
                           1 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ( 
                           
                             
                               
                                 M 
                                 ^ 
                               
                               D 
                             
                             - 
                             
                               
                                 λ 
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 F 
                                 ^ 
                               
                             
                           
                           ) 
                         
                         
                           - 
                           1 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               - 
                               
                                 
                                   M 
                                   ^ 
                                 
                                 ND 
                               
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               black 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                           + 
                           
                             
                               Q 
                               _ 
                             
                             red 
                           
                         
                         ] 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         d 
                         _ 
                       
                       black 
                       
                         ( 
                         
                           n 
                           + 
                           1 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ( 
                           
                             
                               
                                 M 
                                 ^ 
                               
                               D 
                             
                             - 
                             
                               
                                 λ 
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 F 
                                 ^ 
                               
                             
                           
                           ) 
                         
                         
                           - 
                           1 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               - 
                               
                                 
                                   M 
                                   ^ 
                                 
                                 ND 
                               
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               red 
                               
                                 ( 
                                 
                                   n 
                                   + 
                                   1 
                                 
                                 ) 
                               
                             
                           
                           + 
                           
                             
                               Q 
                               _ 
                             
                             black 
                           
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
     and with the eigenvalue estimate λ (n)  computed (for steady-state cases only) through use of a unity weighting function: 
     
       
         
           
             
               
                 
                   
                     λ 
                     
                       ( 
                       n 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         〈 
                         
                           
                             1 
                             _ 
                           
                           ❘ 
                           
                             
                               M 
                               ^ 
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                         
                         〉 
                       
                       
                         ( 
                         red 
                         ) 
                       
                     
                     
                       
                         〈 
                         
                           
                             1 
                             _ 
                           
                           ❘ 
                           
                             
                               F 
                               ^ 
                             
                             ⁢ 
                             
                               
                                 d 
                                 _ 
                               
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                           
                         
                         〉 
                       
                       
                         ( 
                         red 
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
     Now, as an alternative, one can also choose to solve only the red currents (or only the black currents), according to
 
   d     red   (n+1) =[( {circumflex over (M)}   D −λ (n)   {circumflex over (F)} ) −1   {circumflex over (M)}   ND ] 2     d     red   (n)   +{tilde over ( Q )}   red   (24)
 
     with the fixed transformed source
 
 {tilde over ( Q )}   red =( {circumflex over (M)}   D −λ (n)   {circumflex over (F)} ) −1   [ Q     red   −{circumflex over (M)}   ND ( {circumflex over (M)}   D −λ (n)   {circumflex over (F)} ) −1     Q     black ],  (25)
 
     The attractive computational property of this approach is related to the lower norm of the operator [({circumflex over (M)} D −λ (n) {circumflex over (F)}) −1 {circumflex over (M)} ND ] 2  compared to the norm of ({circumflex over (M)} D −λ (n) {circumflex over (F)}) −1 {circumflex over (M)} ND , which is beneficial to the equation residual decay regardless of whether one uses a classical iteration procedure or an iteration procedure as disclosed hereunder. Furthermore, the computation of the eigenvalue updates and the convergence monitoring will involve loops which are twice as short, meaning that the improvement in error decay condition number can be obtained without computational penalty in this case. A matrix-vector product applied to the red or black vector involves only a sum over half of the nodes. After convergence of the iteration procedure, one can compute, directly, the black part of the solution:
 
   d     black   exact =( {circumflex over (M)}   D −λ (exact)   {circumflex over (F)} ) −1   [−{circumflex over (M)}   ND     d     red   (exact)   + Q     black ]  (26)
 
     According to a fifth aspect of the invention, a specific solving procedure has proven to be particularly efficient when dealing with eigensystems. 
     This solving procedure is known as Bi-CGSTAB (Bi-Conjugate Gradient Stabilized) and is disclosed in:
         H. A. van de; Vorst, “Bi-CGSTAB: a Fast and Smoothly Converging Variant of Bi-CG for the solution of nonsymmetric linear systems”, SIAM J. Sci. Stat. Comput. 13(2), pp. 631-644 (1992), and   Y. Saad, “Iterative Methods for Sparse Linear Systems”, second edition, Society for Industrial and Applied Mathematics (SIAM) (2003).       

     The Bi-CGSTAB procedure belongs to the general class of Krylov subspace methods which incorporates also the Bi-CGStab procedure and the Generalized Minimized Residual (GMRES) procedure. 
     When considering a system of the form:
 
 {tilde over (Θ)} d     (n)   ={tilde over ( s )}   (n)   +q   (27)
 
     with the source term {tilde over ( s )} (n)  determined by {tilde over ( s )} (n) ={tilde over (S)} d   (n−1) , the Bi-CGSTAB sequence, truncated after N steps (with usually N&lt;5), can be written as 
     
       
         
           
             
               
                 
                   
                     
                       1. 
                     
                     
                       
                         
                           r 
                           0 
                         
                         = 
                         
                           
                             s 
                             ~ 
                           
                           - 
                           
                             
                               Θ 
                               ~ 
                             
                             ⁢ 
                             
                               d 
                               0 
                             
                           
                         
                       
                     
                   
                   
                     
                       2. 
                     
                     
                       
                         
                           p 
                           0 
                         
                         = 
                         
                           r 
                           0 
                         
                       
                     
                   
                   
                     
                       3. 
                     
                     
                       
                         
                           
                             do 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             i 
                           
                           = 
                           0 
                         
                         , 
                         1 
                         , 
                         … 
                         ⁢ 
                         
                             
                         
                         , 
                         N 
                       
                     
                   
                   
                     
                       4. 
                     
                     
                       
                         
                           α 
                           i 
                         
                         = 
                         
                           
                             ( 
                             
                               
                                 r 
                                 * 
                               
                               , 
                               
                                 r 
                                 i 
                               
                             
                             ) 
                           
                           
                             ( 
                             
                               
                                 r 
                                 * 
                               
                               , 
                               
                                 
                                   Θ 
                                   ~ 
                                 
                                 ⁢ 
                                 
                                   p 
                                   i 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       5. 
                     
                     
                       
                         
                           s 
                           i 
                         
                         = 
                         
                           
                             r 
                             i 
                           
                           - 
                           
                             
                               α 
                               i 
                             
                             ⁢ 
                             
                               Θ 
                               ~ 
                             
                             ⁢ 
                             
                               p 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       6. 
                     
                     
                       
                         
                           ω 
                           i 
                         
                         = 
                         
                           
                             ( 
                             
                               
                                 
                                   Θ 
                                   ~ 
                                 
                                 ⁢ 
                                 
                                   s 
                                   i 
                                 
                               
                               , 
                               
                                 s 
                                 i 
                               
                             
                             ) 
                           
                           
                             ( 
                             
                               
                                 
                                   Θ 
                                   ~ 
                                 
                                 ⁢ 
                                 
                                   s 
                                   i 
                                 
                               
                               , 
                               
                                 
                                   Θ 
                                   ~ 
                                 
                                 ⁢ 
                                 
                                   s 
                                   i 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       7. 
                     
                     
                       
                         
                           d 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                         
                           
                             d 
                             i 
                           
                           + 
                           
                             
                               α 
                               i 
                             
                             ⁢ 
                             
                               p 
                               i 
                             
                           
                           + 
                           
                             
                               ω 
                               i 
                             
                             ⁢ 
                             
                               s 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       8. 
                     
                     
                       
                         
                           r 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                         
                           
                             s 
                             i 
                           
                           - 
                           
                             
                               ω 
                               i 
                             
                             ⁢ 
                             
                               Θ 
                               ~ 
                             
                             ⁢ 
                             
                               s 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       9. 
                     
                     
                       
                         
                           β 
                           i 
                         
                         = 
                         
                           
                             
                               ( 
                               
                                 
                                   r 
                                   * 
                                 
                                 , 
                                 
                                   r 
                                   
                                     i 
                                     + 
                                     1 
                                   
                                 
                               
                               ) 
                             
                             
                               ( 
                               
                                 
                                   r 
                                   * 
                                 
                                 , 
                                 
                                   r 
                                   i 
                                 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             
                               α 
                               i 
                             
                             
                               ω 
                               i 
                             
                           
                         
                       
                     
                   
                   
                     
                       10. 
                     
                     
                       
                         
                           p 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                         
                           
                             r 
                             
                               i 
                               + 
                               1 
                             
                           
                           + 
                           
                             
                               β 
                               
                                 i 
                                 + 
                                 1 
                               
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   p 
                                   i 
                                 
                                 - 
                                 
                                   
                                     ω 
                                     i 
                                   
                                   ⁢ 
                                   
                                     Θ 
                                     ~ 
                                   
                                   ⁢ 
                                   
                                     p 
                                     i 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       11. 
                     
                     
                       
                         end 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         do 
                       
                     
                   
                 
               
               
                 
                   ( 
                   28 
                   ) 
                 
               
             
           
         
       
     
     Whereas the Bi-CGSTAB procedure for solving a nonsymmetric linear system can be put into code very easily, the principal challenges are related to the requirement of having a well-preconditioned linear system in order to enable Bi-CGSTAB procedure to offer an optimum efficiency. 
     Since a good preconditioning typically means an explicit or implicit strong diagonal dominance for the preconditioned operator, the art is to find a (usually implicit) preconditioned form that realizes an optimum trade-off between (i) an effected sufficient degree of diagonal dominance and (ii) a limited computational penalty associated with the systematic implicit preconditioning measure per step in the Bi-CGSTAB procedure. 
     For the Bi-CGSTAB procedure, the preconditioning is based on the shift-inverted implicit form:
 
[ {circumflex over (M)}−μ   (n)   {circumflex over (F)}] d     (n+1) =(λ (n)−μ   (n) ) {circumflex over (F)} d     (n) , μ (n) =αλ (n) ,  (29)
 
     with typically 0.9&lt;α&lt;0.97. With this choice for the shift μ, the operator {circumflex over (M)}−μ{circumflex over (F)} is guaranteed to remain nonsingular since, during the solution process, μ=αλ will converge down to α times the smallest possible eigenvalue of the system. 
     Solving Equation (29) is numerically equivalent to determining the flux distribution in a slightly subcritical system with a neutron source, which is a perfect scenario for deploying advanced preconditioned Krylov procedure. 
     Typical inner/outer iterative procedure for solving Equation (29) adopt an implicit transformation, meaning that, between successive iterative steps, one solves linear source equations of the form
 
[ {circumflex over (M)}−μ   (n)   {circumflex over (F)}] d     (n+1)   = s     (n)  with    s     (n) =(λ (n) −μ (n) ) {circumflex over (F)} d     (n)   (30)
 
     During the iterative procedure, λ (n)  can be updated by application of λ−rebalancing of weighted volume integrals of the different terms in the equation as in Equation (23). Now, we can transform the combined red-black iterative system 
     
       
         
           
             
               
                 
                   
                     
                       
                         [ 
                         
                           
                             M 
                             ^ 
                           
                           - 
                           
                             
                               μ 
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             ⁢ 
                             
                               F 
                               ^ 
                             
                           
                         
                         ] 
                       
                       ⁢ 
                       
                         
                           d 
                           _ 
                         
                         red 
                       
                     
                     + 
                     
                       
                         
                           M 
                           ^ 
                         
                         ND 
                       
                       ⁢ 
                       
                         
                           d 
                           _ 
                         
                         black 
                       
                     
                   
                   = 
                   
                     
                       
                         
                           
                             
                               s 
                               _ 
                             
                             red 
                           
                           ⁢ 
                           
                             
 
                           
                           [ 
                           
                             
                               M 
                               ^ 
                             
                             - 
                             
                               
                                 μ 
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 F 
                                 ^ 
                               
                             
                           
                           ] 
                         
                         ⁢ 
                         
                           
                             d 
                             _ 
                           
                           black 
                         
                       
                       + 
                       
                         
                           
                             M 
                             ^ 
                           
                           ND 
                         
                         ⁢ 
                         
                           
                             d 
                             _ 
                           
                           red 
                         
                       
                     
                     = 
                     
                       
                         s 
                         _ 
                       
                       black 
                     
                   
                 
               
               
                 
                   ( 
                   31 
                   ) 
                 
               
             
           
         
       
     
     into the following equivalent iterative scheme for the red solution part only: 
     
       
         
           
             
               
                 
                   
                     
                       
                         Θ 
                         ~ 
                       
                       red 
                     
                     ⁢ 
                     
                       
                         d 
                         _ 
                       
                       red 
                     
                   
                   = 
                   
                     
                       
                         s 
                         _ 
                         ~ 
                       
                       red 
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     with 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       { 
                       
                         
                           
                             
                               
                                 
                                   Θ 
                                   ~ 
                                 
                                 red 
                               
                               = 
                               
                                 
                                   1 
                                   ^ 
                                 
                                 - 
                                 
                                   
                                     [ 
                                     
                                       
                                         
                                           ( 
                                           
                                             
                                               
                                                 M 
                                                 ^ 
                                               
                                               D 
                                             
                                             - 
                                             
                                               μ 
                                               ⁢ 
                                               
                                                 F 
                                                 ^ 
                                               
                                             
                                           
                                           ) 
                                         
                                         
                                           - 
                                           1 
                                         
                                       
                                       ⁢ 
                                       
                                         
                                           M 
                                           ^ 
                                         
                                         ND 
                                       
                                     
                                     ] 
                                   
                                   2 
                                 
                               
                             
                           
                         
                         
                           
                             
                               
                                 
                                   
                                     s 
                                     _ 
                                     ~ 
                                   
                                   red 
                                 
                                 = 
                                 
                                   
                                     
                                       s 
                                       _ 
                                     
                                     red 
                                   
                                   - 
                                   
                                     
                                       
                                         ( 
                                         
                                           
                                             
                                               M 
                                               ^ 
                                             
                                             D 
                                           
                                           - 
                                           
                                             μ 
                                             ⁢ 
                                             
                                               F 
                                               ^ 
                                             
                                           
                                         
                                         ) 
                                       
                                       
                                         - 
                                         1 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         
                                           
                                             M 
                                             ^ 
                                           
                                           ND 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           
                                             
                                               
                                                 M 
                                                 ^ 
                                               
                                               D 
                                             
                                             - 
                                             
                                               μ 
                                               ⁢ 
                                               
                                                 F 
                                                 ^ 
                                               
                                             
                                           
                                           ) 
                                         
                                       
                                       
                                         - 
                                         1 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         s 
                                         _ 
                                       
                                       black 
                                     
                                   
                                 
                               
                               , 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   32 
                   ) 
                 
               
             
           
         
       
     
     This preconditioned system constitutes the sixth aspect of the invention. 
     Once Equation (32) has been solved through the Bi-CGSTAB procedure the black solution part is to be computed from the black part of Equation (31). 
     Use of this particular way of preconditioning, which means that the direct neutronic interaction between neighboring (red vs. black) nodes, as projected onto the rebalancing grid, is preincluded in the system to be solved, making the unity operator in Equation (32) more dominant since
 
∥(( {circumflex over (M)}   D   −μ{circumflex over (F)} ) −1   {circumflex over (M)}   ND ) 2 ∥&lt;∥( {circumflex over (M)}   D   −μ{circumflex over (F)} ) −1   {circumflex over (M)}   ND ∥,  (33)
 
given that
 
∥( {circumflex over (M)}   D   −μ{circumflex over (F)} ) −1   {circumflex over (M)}   ND ∥&lt;1  (34)
 
     This way of preconditioning manages to pre-include, at low computational cost, crucial information (or the major part of that information) with regard to the physical interactions between nodes that determine the spatial couplings and hence the solution of the equation. 
     As set forth in the previous description, the first to sixth aspects of the invention help to achieve robust and efficient modelizing methods. 
     It should be kept in mind that the first aspect in itself helps in achieving this goal and can thus be used separately from the second to fifth aspects, for example by using a GS iterative procedure. Also, the third and fourth aspects are not necessarily implemented with the second aspect and the fifth aspect is not necessarily implemented with the sixth aspect. 
     The results obtained through the modelizing method can be used to control an existing nuclear reactor core, e.g. for managing the nuclear fuel, or be used for building a new reactor core. 
     The modelizing method can be used to compute both thermohydraulics parameters and neutron flux.