Optimization of High-Cost Functions for Complex Multidimensional Constraints

Abstract

A method is used to design a nuclear reactor using design variables and metric variables. A user specifies ranges for the design variables and target values ​​for the metric variables. A set of design parameter samples is selected. For each sample, the method performs three processes to calculate metric variables for thermal-hydraulic, neutron, and stress. The method applies a cost function to each sample to calculate the ensemble residuals of the metric variables compared to the target values. The method trains a machine learning model using the samples and the calculated ensemble residuals. The method reduces the range of each design variable according to the correlation of the residuals estimated using each design variable and the machine learning model. These steps are repeated until the sample with the smallest residual remains constant over multiple iterations. The method then uses the final machine learning model to evaluate the relative importance of each design variable.

Description

Related Applications

[0001] This application claims priority based on U.S. Provisional Patent Application No. 62 / 962,806, filed on January 17, 2020, the entire content of which is incorporated herein by reference.

Technical Field

[0002] The disclosed implementations generally relate to systems, methods, and user interfaces that generate designs, and more particularly, that utilize machine learning to rapidly produce realizable designs.

Background Art

[0003] In the following description, specific structures and / or methods are referred to. However, the following references should not be construed as admitting that these structures and / or methods constitute prior art. The applicant expressly reserves the right to demonstrate that such structures and / or methods are not eligible as prior art for the present invention.

[0004] Techniques described for optimizing cost functions for complex multi-dimensional constraints are described with respect to the design of a nuclear reactor core. However, the technique is not limited to this particular example.

[0005] The design of a nuclear reactor core needs to satisfy complex interactions in the field of physics. For example, the design requires neutrons to maintain criticality (nuclear fission reaction), but criticality also depends on the characteristics of the fuel and the moderator. The design also requires thermal properties such as heat flux profiles, conductivity, and power output. In addition, the design needs to satisfy stress analysis of the integrity and material properties of the assemblies that do not melt or break under the stress of energy flux and cycling.

[0006] Testing neutron cases using the Monte Carlo N - particle transport code (MCNP) or other verified simulators often takes several days for a single design, and then thermal and stress simulations or calculations also need to be performed. It may take months to find an effective combination of design parameters for a particular shape. Historically, attempts to speed up this process have taken the form of (i) adding computing power and / or using supercomputers, (ii) accelerating calculations through the use of GPU computing development, and / or (iii) dealing with the inefficiencies of workflow - to - format compatibility and utilizing top - tier software that may deploy alternative, unvalidated solutions. However, the process is still very slow and often takes months to determine that the proposed design does not meet all requirements. In addition, some systems attempt to increase fidelity and further integrate physics - based modeling and simulation software, often through government research institutes, which is costly to develop. This often makes the process even slower.

[0007] Product design optimization typically requires weighting many parameters. For example, the design of a nuclear reactor core needs to satisfy complex interactions in the field of physics. For example, the design requires neutrons to maintain criticality (nuclear fission reaction), but criticality also depends on the properties of the fuel and the moderator. The design also requires thermal properties such as heat flux profiles, conductivity, and output. In addition, the design needs to satisfy the stress analysis of the integrity and material properties of the assemblies that do not melt or break under the stress of energy flux and cycling.

[0008] Design optimization is a complex task and can take several days to complete even on the fastest computers. For example, testing neutron cases using the Monte Carlo N - particle transport code (MCNP) or other verified simulators often takes several days for a single design, and then thermal and stress simulations or calculations also need to be performed. It may take months to find an effective combination of design parameters for a particular shape.

[0009] Historically, attempts to speed up this process have taken the form of (i) adding computing power and / or using supercomputers, (ii) accelerating calculations through the use of GPU computing development, and / or (iii) addressing the inefficiencies of workflow and format compatibility and utilizing top-level software that may deploy alternative unvalidated solutions. However, the process remains very slow and often takes months to determine that the proposed designs do not meet all requirements. In addition, some systems attempt to increase fidelity and further integrate physics-based modeling and simulation software, often through government research institutions, at great expense. This often makes the process even slower.

[0010] In addition, state-of-the-art techniques such as the use of surrogate models can only find local minima. Search strategies for exploring global optimal solutions, such as genetic algorithms, simulated annealing, and particle swarms, typically require a large amount of computing resources, and many techniques are difficult to parallelize. Most techniques cannot handle categorical variables and / or cannot incorporate probabilities. SUMMARY OF THE INVENTION

[0011] The present disclosure uses an artificial intelligence (AI) suite to find an optimal design space within user-specified constraints. This provides (i) a rapid and automated evaluation of conceptual reactor designs, (ii) identification of valid parameter spaces and optimal parameters that meet neutron, thermal-hydraulic, and stress requirements, and (iii) integration and analysis of results to facilitate decision-making.

[0012] Some implementations provide a global population-based algorithm. This applies a heuristic-based process that uses machine learning, for example, to optimize the entire design space of the active core region of a nuclear fission reactor. The implementation of the algorithm (i) adaptively screens and / or eliminates unimportant variables to accelerate convergence to an optimal design solution and (ii) systematically evaluates complex multivariable interactions during optimization. This is also used to generate reports that evaluate the constraints of decision-making (design requirement analysis) and detailed core understanding (design analysis). Some implementations apply the same approach in combination with genetic algorithms to provide evolutionary optimization.

[0013] The disclosed implementations use machine learning-based algorithms to quickly identify and optimize design options along mission and engineering constraints by machine learning-based probabilistic sampling across the field of physics. By sampling the response space and learning the topology, each parameter of the potential candidate subregions is recursively adjusted according to the cost function to identify the final effective design space, and the effective design options are output to the user along with analysis information to investigate the trade-offs and characteristics of the effective designs. During processing, a "trust region" for the design parameters is initially specified by the user and typically shrinks in size during each iteration. The trust region converges to the final design space.

[0014] The design subspaces are non-spherical and are narrowed based on the selection and constraints of a user-defined baseline. The disclosed implementations employ multiphysics analysis (neutronics, thermal-hydraulic analysis, and stress analysis) in sampling mode using relatively rapid execution. This includes the effective neutron multiplication factor (k-effective or K eff) is modeled to include a solution for detecting gradients of various design variables that tend towards an optimal design space. Once an effective design space is identified, only the priority design options with a high likelihood of effectiveness need to be further verified by high-fidelity execution (e.g., MCNP, or other high-fidelity simulations that model the reactor core for neutron, thermal, and / or stress analysis). The disclosed process avoids the use of computationally expensive resources, computational delays, and the processing time of experts in individual subject areas in other ways. The disclosed process reduces the exercise of these resources for invalid designs and ultimately adds flexibility and customization.

[0015] The disclosed method provides the ability to understand interactions (within a time frame) that are too complex for humans to explicitly process. The disclosed approach provides multiple designs that meet the design criteria. Rather, the disclosed approach operates and progresses during the execution of computer analysis without interruption, analyzing the trade-offs between multiple designs that naturally occur due to evolving design discoveries and a series of design inputs and changing mission profiles.

[0016] In some implementations, the method is executed on a computing system. Typically, the computing system includes multiple computers, each having one or more processors and memory. This method is used to design the reactor core of a nuclear reactor. The design process uses multiple design variables of the nuclear reactor. The design variables are variables that are basically independently controlled. Further, the design process uses multiple metric variables related to the nuclear reactor. The design variables include, for example, variables that measure thermal-hydraulic characteristics, variables that measure neutron characteristics, and variables that measure stress characteristics. The metric variables are basically dependent variables and measure the feasibility of the design. Other metric variables can also be used.

[0017] The user specifies an individual range of values for each of the design variables, thereby forming an initial trust region. The trust region is initially a hypercube centered at a point whose coordinates are the average of each of the ranges. The user also specifies an individual constraint value for each of the metric variables. For example, the maximum fuel temperature or the maximum pressure loss.

[0018] The method obtains N samples of values of design parameters within an initial trust region. In some implementations, the method includes constructing the N samples using a Latin hypercube (LHS). In some implementations, the N samples are generated using random selection or received from a user (e.g., as a starting point). In some implementations, the N samples (e.g., Latin hypercube samples) are constructed such that they minimize the multivariate correlation between the design variables. The process minimizes the correlation in potentially two ways: (i) increasing the number of samples and / or (ii) selecting alternative samples. N is an integer greater than 1, e.g., 10, 25, or 50.

[0019] For each of the N samples, the method performs several actions, namely: (i) executing a thermal-hydraulic analysis process to calculate a plurality of metric variables that measure thermal-hydraulic characteristics, (ii) executing a neutron analysis process to calculate a plurality of neutron metrics corresponding to neutron characteristics, (iii) executing a stress analysis process to calculate a plurality of metric variables corresponding to stress (and related) characteristics, and (iv) applying a cost function to calculate an individual set residual of the metric variables compared to the target values of the metric variables.

[0020] The method then trains an optimization model according to the N samples and the corresponding calculated set residuals. Various machine learning techniques are used. In some implementations, the optimization model is a machine learning model. In some implementations, the optimization model is an evolutionary algorithm, and the method iterates to evolve a population of programs for the optimization problem. In some implementations, the machine learning model is a random forest of decision trees. In some implementations, the machine learning model is a neural network. Some implementations use a Gaussian process for machine learning. In some implementations, the optimization model is a Markov chain model.

[0021] The method then reduces the trust region and places the modified trust region centered around the sample point with the minimum residual (one of the N samples). The trust region initially starts as a hypercube, but the trust region is usually not a hypercube for reduction. The individual ranges of each design variable are reduced according to the correlation between the individual design variables and the residuals estimated using the optimization model.

[0022] The process then repeats constructing, performing a thermal-hydraulic process, performing a neutron process, performing a stress process, calculating, and training until the sample with the minimum residual does not change for a predetermined number of iterations. The method uses the optimization model from the last iteration to evaluate the relative importance of each design variable and provides the evaluation visually in a report. In some implementations, the report is an interactive graphical user interface having one or more data visualization diagrams showing the importance of each design variable and / or which metric variables imposed the greatest design limitations.

[0023] In some implementations, performing a thermal-hydraulic analysis process, performing a neutron analysis process, and performing a stress analysis process are done simultaneously. In some implementations, there is an initial rough screening for each of the points and sample points that produce very bad results are not fully processed (e.g., sample points with insufficient K eff are rejected).

[0024] In some implementations, performing a thermal-hydraulic analysis process, performing a neutron analysis process, and performing a stress analysis process are done sequentially. In some implementations, performing a thermal-hydraulic analysis process, performing a neutron analysis process, and performing a stress analysis process are done in parallel. In some implementations, performing a thermal-hydraulic analysis process, performing a neutron analysis process, and performing a stress analysis process are done iteratively.

[0025] In some implementations, the thermal-hydraulic analysis process, the neutron analysis process, and the stress analysis process are each performed in separate, different computational subsystems. In this way, the processes can be executed in parallel, and each computational subsystem can be optimized for a particular type of operation (e.g., hardware and / or software).

[0026] In some cases, the optimal sample point is on the boundary of the trust region. This indicates that the optimal solution may be outside the current trust region. In this case, some implementations expand the trust region. Specifically, if the method determines that, in an iteration, the sample with the minimum residual has a value of a first design variable that is on the boundary of the trust region, the method expands the trust region to include a range of the first design variable that was not previously included in the trust region. In some implementations, the expansion of the trust region is not permitted to exceed an initial parameter specified by the user (e.g., the expansion can undo a previous contraction).

[0027] In some implementations, one of the plurality of metric variables is the effective neutron multiplication factor (K eff ).

[0028] In some implementations, reducing the trust region uses a learning coefficient specified by user input.

[0029] In some implementations, the N samples are centered around the average value of a range specified by the user for a plurality of design variables.

[0030] The method works even when one or more design variables have discrete categorical values rather than numerical ranges. For example, one of the plurality of design variables can be a fluid type having categorical values such as, for example, "hydrogen", "helium", and "nitrogen". In some implementations, when the method includes a first design variable having discrete categorical values, the method further includes: (i) encoding each individual categorical value as a numerical value in a continuous range to form a first replacement design variable, and (ii) replacing the first design variable with the first replacement design variable. As another example, one of the design variables can be a fuel substance or a fuel loading pattern (e.g., the arrangement or location of fuel within a reactor core).

[0031] When there are one or more categorical design variables, the method further includes, during each iteration: (i) using an optimization model to estimate, for the sample with the smallest residual, the probability of switching to a different categorical value that produces a smaller residual according to a cost function, and (ii) using, for the next iteration, a sampling rate for N samples that is proportional to the probability. For example, some implementations normalize the probability such that the sum of all categorical values is 1.

[0032] There is a need for systems, methods, and techniques for solving high-dimensional design optimization problems. The present disclosure uses machine learning and advanced probability theory to explore an optimal design space within user-specified constraints. The disclosed techniques can be used to generate a rapid, automated evaluation of a conceptual design (e.g., a reactor core design), identify valid parameter spaces and optimal parameters (neutron, thermal hydraulic, and stress parameters), and / or synthesize and visualize results to facilitate decision-making.

[0033] Some implementations distinguish between local minima and global minima (or global optima) for optimization problems of a design. Some implementations handle categorical variables. Some implementations can handle a very large number of dimensions (parameters or search space). The disclosed techniques can be readily parallelized for execution on a large-scale computing cluster. An additional advantage of the disclosed techniques is that in at least some implementations, since the algorithm adaptively learns boundaries to avoid boundary conditions, boundary checking of function calls is no longer necessary.

[0034] According to some implementations, the method is executed on a computing system. Typically, the computing system comprises a plurality of computers, each of the plurality of computers having one or more processors and memory. The method can be used to optimize design constraints for manufacturing (e.g., the core of a nuclear reactor). The method includes receiving user input that specifies (i) design optimization constraints for a plurality of design variables, and (ii) a cost function for evaluating a design for the plurality of design variables. The method includes applying stochastic sampling to obtain a plurality of data samples for the plurality of design variables. The method includes training a first machine learning model to generate a subset of the data samples based on the plurality of data samples and the design optimization constraints. The method also includes training a mixture of Gaussians model to classify a subset of the data samples to obtain a Gaussian distribution for a determined number of groups. The method also includes training a second machine learning model to rank the Gaussian distributions based on the cost function to obtain a candidate design. The method also includes generating a new plurality of data samples based on the candidate design using a Markov chain Monte Carlo algorithm. The method also includes repeating applying stochastic sampling, training the first machine learning model, training the mixture of Gaussians model, training the second machine learning model, and generating a new plurality of data samples until the design criteria are met. In some implementations, the method includes using the first machine learning model, the mixture of Gaussians model, and the second machine learning model from the last iteration to evaluate the relative importance of each design variable, and visually reporting the evaluation in a report.

[0035] In some implementations, the cost function includes a multi-physics linear combination of thermal, nuclear, and mechanical aspects of the core design.

[0036] In some implementations, the first machine learning model is a random forest of decision trees and the second machine learning model is a random forest of decision trees.

[0037] In some implementations, the first machine learning model is a random forest of decision trees, and training the first machine learning model to generate a subset of data samples includes approximating a candidate optimal variance with the within - variance of the decision trees, calculating a non - parametric upper 95% confidence interval based on the candidate optimal variance, and using a predetermined cut - off threshold and the non - parametric upper 95% confidence interval to generate a subset of data samples.

[0038] In some implementations, the plurality of optimization design constraints include one or more physical constraints. The method further includes training a third machine learning model using a plurality of data samples to predict the probability for data samples that satisfy one or more physical constraints, and using the third machine learning model to generate the probability that one or more physical constraints for a candidate design are satisfied. In such implementations, generating the new plurality of data samples is further based on the generated probability for the candidate design. In some implementations, further includes selecting a third machine learning from a list of classifier models based on the number of samples within the plurality of data samples. The list of classifier models includes k - nearest neighbor classifier models, support vector machines, and feed - forward neural networks. Model

[0039] In some implementations, the plurality of optimization design constraints include one or more physical constraints. The method further includes selecting one or more data samples from a plurality of data samples that satisfy one or more physical constraints, and training the first machine learning model is further based on the one or more data samples.

[0040] In some implementations, the Markov chain Monte Carlo algorithm uses the Metropolis - Hastings method to fit the covariance matrix.

[0041] In some implementations, the plurality of design variables includes a first design variable having discrete categorical values, and the Markov chain Monte Carlo algorithm uses a hierarchical multinomial distribution.

[0042] In some implementations, the computing system includes one or more computers. Each computer includes one or more processors and memory. The memory stores one or more programs configured for execution by the one or more processors. The one or more programs include instructions for performing any of the methods described herein.

[0043] In some implementations, the non-transitory computer-readable storage medium stores one or more programs configured for execution by a computing system having one or more computers, each computer having one or more processors and memory. The one or more programs include instructions for performing any of the methods described herein.

[0044] Accordingly, methods and systems are disclosed that provide rapid design using machine learning and probability theory. The discussions, examples, principles, compositions, structures, features, arrangements, and processes described herein can be applied to, adapted to, and embodied in manufacturing nuclear reactors.

Brief Description of the Drawings

[0045] To better understand the disclosed systems and methods, as well as additional systems and methods, reference should be made to the following description of implementations in conjunction with the following drawings. In the following drawings, like reference numerals refer to corresponding parts throughout the drawings.

[0046]

Figure 1A

Figure 1B

Figure 2

Figure 3A

Figure 3B

Figure 4A

Figure 4B

Figure 4C

Figure 4D

[0047] Here, reference is made to the implementations. Examples thereof are shown in the accompanying drawings. In the following description, many specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be apparent to those skilled in the art that the present invention may be practiced without these specific details.

Mode for Carrying Out the Invention

[0048] Figure 1A provides an overview of the process of designing a nuclear reactor core for several implementations. Input 102 is provided by one or more users. In some implementations, the input is provided to an input user interface 222 (e.g., a graphical user interface). In some implementations, input 102 is provided through a command line interface or using an input file. Input 102 includes design variables 110. Design variables 110 are parameters that specify the physical design characteristics of the core (e.g., shape, operating conditions, fuel load, fuel type pattern, size, mass, a limited list of alternatives for fuel and moderators, or construction materials). The user specifies a range of values (or a list of discrete values) for each of the design variables 110. Input 102 also includes metric variables 112. Metric variables 112 are constraints on how the core functions (e.g., output megawatts, center temperature, fluid pressure loss, thrust, flow, ISP (specific impulse), total mass, component mass, poisons, or power distribution). The user specifies target values for the metric variables. Some constraints are fundamental, for example, related to maintaining structural integrity over the intended lifetime.

[0049] Algorithm 104 is iterative and begins with a trust region 120. From this trust region 120, a plurality of sample points are selected. In some implementations, the samples form a Latin hypercube (e.g., centered at points where the coordinates are the means of each range). The algorithm selects sample points such that the maximum multivariate correlation between the design variables is minimized. In some implementations, this is an iterative process that specifies a predetermined maximum value p_max and iterates until the maximum multivariate correlation is less than p_max.

[0050] After a sample point is selected, algorithm 104 performs three processes to determine the quality of each sample point. Usually, these processes are performed in parallel, but some implementations perform an initial screening using one or more processes (e.g., neutron engine 136) to exclude designs that are far from being executable. Each of the thermal-hydraulic engine 132, the mechanical stability ("stress") engine 134, and the neutron engine 136 calculates the value of one or more metric variables 112. For each sample, the algorithm calculates a cost function that specifies the quality of the sample from the perspective of generating an executable model of the core. In some implementations, the cost function calculates a residual. The residual is a weighted polynomial in which each of the metric variables differs from its target constraint value by an amount. For example, if n metric variables y1, y2, …, y n are associated with target constraint values c1, c2, …, c n and weights w1, w2, …, w n respectively. Some implementations specify the residual as the sum w1(y1 - c1)+w1(y1 - c1)+…+w1(y1 - c1).

[0051] The sample points and the calculated residuals are input into the optimization engine 140. The optimization engine 140 uses the data to construct an optimization model 262 (or multiple models). In some implementations, the model is a machine learning model. In some implementations, the model is a Markov chain model. In some implementations, the optimization model is an evolutionary model (e.g., a genetic programming model), and the method iterates to evolve a set of programs that solve the optimization problem. In some implementations, the model is a random forest of decision trees. In some implementations, the model is a neural network. Some implementations use a Gaussian process for machine learning. Based on the optimization model 262, the algorithm 104 determines the relative importance of each of the design variables. Some of the design variables have a large impact on the residuals, while other design variables have little impact on the residuals. Using this data, the algorithm 104 can shrink (150) the trust region 120 and repeat the iteration with a smaller trust region. Since the trust region shrinks with each iteration, the algorithm 104 collects more information about the smaller region, and thus the data becomes more accurate. Note that when constructing the optimization model 262, the sample points from all iterations are used cumulatively (e.g., if the same number of sample points are generated in the second iteration, the second iteration has a total of twice the sample points for constructing the optimization model).

[0052] In some implementations, the process uses a genetic algorithm instead of or in addition to reducing the trust region in each iteration. When using a genetic algorithm, each of the sample points is weighted according to the residual. In this case, the smaller the residual of a sample, the greater its weight. In some implementations, the weight of a sample with too large a residual may be zero. These weights are used to create the samples used in the next iteration. For example, pairs of samples are randomly selected according to their weights, and for each pair, mutation and / or crossover are used to create one or two child samples for the next iteration. In some implementations, more than three samples are used to generate the child samples for the next iteration.

[0053] If the best sample point does not change after multiple iterations, algorithm 104 ends the processing loop. The data from the last iteration is used to provide the user with output analysis information 106. In some implementations, the output analysis information 106 is provided as graphical data visualization diagrams such as graphical data visualization diagrams 160 and 162. The first graphical data visualization diagram 160 shows the residual composition based on the input parameters (i.e., design variables 110). This shows how much each of the design variables 110 contributed to the calculated residual. In this example, there are eight input parameters that contribute to the residual, such as the radius of the core, the height of the core, the diameter of the flow channel holes, and the flow rate. In some implementations, input parameters with a contribution to the residual less than a threshold are excluded from FIG. 160. The second graphical data visualization diagram 162 shows the residual composition based on the metrology constraints 112. In the data visualization diagram 162 of this example, T max and K eff are two of the most important constraints, while the inlet temperature (Inlet T ) and the pressure loss dP / P are not very important. In some implementations, these data visualization diagrams 160 and 162 are interactive and allow the user to explore options.

[0054] Figure 1B provides a general overview of the process for design optimization for some implementations. Input 172 is provided by one or more users. In some implementations, the input is provided in an input user interface 222 (e.g., a graphical user interface). In some implementations, input 172 is provided through a command line interface or using an input file. Input 172 includes design optimization constraints 180, which are constraints for design optimization (e.g., design constraints for the construction of a core (e.g., shape, operating conditions, fuel load, fuel type pattern, size, mass, a limited list of alternatives for fuel and moderators, or construction materials), or constraints on how the core functions (e.g., output megawatts, center temperature, fluid pressure loss, thrust, flow, ISP (specific impulse), total mass, component mass, poisons, or power distribution)). In some implementations, the user specifies a range of values (or a list of discrete values) for one or more design variables 110, and / or the user specifies a target value for a metric variable. Input 172 also includes a cost function 182 for evaluating design alternatives. The cost function 182 is, for example, a multi-physics linear combination of the thermal, nuclear, and mechanical aspects of a core design.

[0055] Algorithm 174 is iterative and repeats the probabilistic sampling step 190, the training of the first machine learning algorithm 192, the training of the mixture Gaussian model 194, the training of the second machine learning model 196, and the application of the Markov chain Monte Carlo algorithm 198 until convergence. According to some implementations, the later trained models are used to obtain output analysis information 176 (similar to the output analysis information 106 described above with reference to Figure 1A).

[0056] FIG. 2 is a block diagram of a computing device 200 according to some implementations. Various examples of the computing device 200 include high performance clusters (HPCs) of servers, supercomputers, desktop computers, cloud servers, and other computing devices. The computing device 200 typically includes one or more processing units / cores (CPUs) 202 for performing processing operations by executing modules, programs, and / or instructions stored in the memory 214, one or more networks or other communication interfaces 204, a memory 214, and one or more communication buses 212 interconnecting these components. The communication bus 212 may include circuitry for interconnecting and controlling communication between system components.

[0057] The computing device 200 may include a user interface 206 that includes a display device 208 and one or more input devices or mechanisms 210. In some implementations, the input device / mechanism includes a keyboard. In some implementations, the input device / mechanism includes a “soft” keyboard that is displayed on the display device 208 as needed to enable a user to “press a key” that appears on the display 208. In some implementations, the display 208 and the input device / mechanism 210 comprise a touch screen display (also referred to as a touch sensor-based display).

[0058] In some implementations, memory 214 includes high-speed random access memory such as DRAM, SRAM, DDR RAM, or other random access solid state memory devices. In some implementations, memory 214 includes non-volatile memory such as one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, or other non-volatile solid state storage devices. In some embodiments, memory 214 includes one or more storage devices that are remotely located from CPU 202. Memory 214 or the non-volatile memory device within memory 214 comprises a non-transitory computer-readable storage medium. In some implementations, memory 214 or the computer-readable storage medium of memory 214 stores the following programs, modules, and data structures, or subsets thereof. · Operating system 216. This includes procedures for handling various basic system services and performing tasks that are hardware-dependent. · Communication module 218. This is used to connect computing device 200 to other computers or devices through one or more communication network interfaces 204 (wired or wireless) and one or more communication networks (e.g., the Internet, other wide area networks, local area networks, metropolitan area networks, etc.). · Web browser 220 (or other application capable of displaying web pages). This enables a user to communicate through a network using a remote computer or device. · Input user interface 222. This enables a user to specify the range 232 of acceptable values for design variable 110 and the target value 242 for constraint 112. The range of design variables is used to specify the initial trust region 120. · Output user interface 224. This provides graphical analysis information 226 regarding the constructed design. Some examples of graphical analysis information 226 are the data visualization diagrams 160 and 162 of FIG. 1. · Data sample selector 250. This selects a set of samples within the trust region (e.g., a set of N samples, where N > 1). In some implementations, the data sample selector forms a Latin hypercube. In some implementations, the set of samples is repeatedly formed to reduce the multivariate correlation between the sample values of the design variables 110. · Thermal-hydraulic engine 132. This determines various characteristics such as heat flux profile, heat transport, pressure loss, and melting. In some implementations, this uses the Finite Element method (FEM), the Finite Difference Method (FDM), or the Finite Volume Method (FVM). In some implementations, this uses an ANSYS model. · Mechanical stability engine 134. This determines various mechanical characteristics such as the coefficient of thermal expansion (CTE), CTE mismatch, stress-strain, cycling, and the effects of cracking. · Neutron engine 136. This calculates various characteristics such as nuclear fission criticality, range, moderation, flow rate quantity, and sustainability. In some implementations, the neutron engine uses the Monte Carlo N-particle simulation (MCNP). · Material module 138. This evaluates materials that may be used for various components such as materials used in construction, fuel, cladding, poisons, or moderators. The characteristics to be evaluated may include the dissipated particle structure, material reaction characteristics, and the state of material mixing. ·Optimization engine 140. This constructs an optimization model 262 based on samples and metrics calculated for each of the samples. In some implementations, the optimization engine 140 includes a machine learning engine that constructs a machine learning model. In some implementations, the machine learning engine constructs a random forest of decision trees. In some implementations, the machine learning engine constructs a neural network. In some implementations, the machine learning engine uses a Gaussian process to construct a machine learning model. In some implementations, the optimization engine 140 includes a Markov chain algorithm and the optimization model 262 includes a Markov chain model. In some implementations, the optimization engine 140 includes one or more evolutionary algorithms (e.g., genetic programming instances) and the optimization model 262 includes an evolutionary model. ·Zero or more databases or data sources 270 (e.g., first data source 240A and second data source 240B). In some implementations, the data source is stored as a spreadsheet file, CSV file, XML file, flat file, HDF file, or SQL database. The database can be stored in a relational or non-relational format.

[0059] Each of the executable modules, applications, or sets of procedures identified above can be stored in one or more of the aforementioned memory devices and corresponds to a set of instructions for performing the functions described above. The modules or programs identified above (i.e., sets of instructions) need not be implemented as separate software programs, procedures, or modules, and thus various subsets of these modules can be combined or otherwise rearranged in various implementations. In some implementations, the memory 214 stores a subset of the modules and data structures identified above. Additionally, the memory 214 can store additional modules or data structures not described above.

[0060] FIG. 2 shows a computing device 200, but FIG. 2 is more intended as a functional description of various features that may exist than as a structural schematic of the implementations described herein. In fact, and as will be appreciated by those skilled in the art, the separately shown items can be combined and some items can be separated.

[0061] In some implementations, although not shown, memory 214 also includes modules for training and executing the models described with reference to FIG. 1B above. In particular, in some implementations, memory 214 also includes a stochastic sampling module 190, a first machine learning model 192, a mixture of Gaussians model 196, and a Markov chain Monte Carlo algorithm 198, as well as any associated data. Example of methodology

[0062] Exemplary algorithms for solving high-dimensional design optimization problems are shown for illustrative purposes in accordance with some implementations. 1. The user inputs the optimization constraints. The user defines a cost function (in this example, a multi-physics linear combination of the thermal, nuclear, and mechanical aspects of a core design). 2. Use stochastic sampling (e.g., in the form of a Latin hypercube) to explore the space defined by the user. 3. Based on the results of step 2, set up a two-dimensional array of "yes" and "no" for physical violations. 4. Train one of the k-nearest neighbor method, support vector machine, or feed-forward neural network according to the sample size. a. Use standard methods for cross-validation, early stopping, Monte Carlo hyperparameter selection, etc. 5. Train a random forest with data where there are no physical violations and use out-of-bag sampling for cross-validation. 6. Utilize the random forest method by approximating the candidate optimal variance with the within-tree variance. 7. Use step 6 to calculate the non-parametric upper bound 95% tolerance range. 8. Use step 7 as a cutoff for generating a subspace data region based on the training data. 9. Train a mixture Gaussian model in the subspace to enforce about 10 or more groups or component Gaussian distributions. 10. Use a random forest to rank the mixture Gaussian model method for possible realizable designs. 11. Generate a Markov chain (MCMC) that utilizes the Metropolis-Hastings method with a custom adaptive covariance matrix for the current best design. a. The distribution proposed by the Markov is initially a multivariate Gaussian distribution centered around either the current best vector or one of the ranked vectors determined in step 10. b. The posterior distribution used to obtain samples therefrom is the internal forest of the random forest. Thus, it is always at 50% probability at the median of the best design, but not more than 0% probability for peripheral designs. Therefore, the internal forest is used again to calculate the empirical CDF using the random walk of the Markov chain to find new candidate designs. c. To ensure that the chain remains within the physical space, each iteration of the Markov is multiplied with the probability marked by the threshold of the classification model in step 4. 12. The new candidate designs identified in step 11 are used as the next generation's statistical samples. Use these points as the next function call. 13. Return to step 2 with the new data from step 12, but use the MCMC points instead of the hypercube. Repeat until convergence. 14. When using categorical variables, the MCMC is modified to use a hierarchical multinomial distribution. a. When the Markov chain starts, all prior distributions in the multinomial distribution are uniformly distributed. b. Each time the MCMC adapts the covariance matrix of the proposed distribution in step 11, the support vector machine (SVM) is trained with the accepted proposals of the Markov chain. Different SVMs are trained for each categorical variable. c. Once the SVM is trained, the probability of the SVM is used as the prior distribution each time the multinomial distribution is called, thereby generating a hierarchical model learned from a random walk.

[0063] According to some implementations, some of the advantages of the disclosed invention include the following. · Some implementations explore and determine whether the algorithm is within a minimum. Thereby, the algorithm may provide a better solution than the prior art. · Some implementations handle categorical variables. · Some implementations handle many dimensions (e.g., 1000 parameters). · Some implementations are easily parallelizable for a computing cluster. · The algorithm is faster and more efficient than the prior art. · In some implementations, since the algorithm adaptively learns the boundary to avoid the boundary, the boundary check of the function call is no longer necessary.

[0064] Figure 3A provides a flowchart of a rapid reactor design using continuous design variables. The process begins (302) by obtaining (304) variables (both design variable 110 and metric variable 112). The user specifies the range of each of the design variables 110 and the constraints (e.g., one-sided inequalities) of each metric variable 112. The design variables 110 may be called parameters, and the hypercube of ranges may be called the parameter space. The parameter space forms the first trust region (TR) (304). The space of metric variables may be called the response space.

[0065] Next, the process generates a set of samples from the initial trust region (306). In some implementations, the generation of the set of samples (e.g., Latin hypercube) is iterative, and the process iterates on the size of the cube until the multivariate correlation between the design variables of the samples is less than a predetermined constraint p max is less than a threshold (306). Each iteration increases the size of the sample (e.g., Latin hypercube) and / or replaces at least one of the samples with a new sample. The first stochastic process for constructing the set of samples (e.g., Latin hypercube) is centered around the mean of the trust region (306).

[0066] The process then performs a thermal-hydraulic (TH) calculation for each point within the set of samples (e.g., Latin hypercube) (308). In some implementations, true two-dimensional calculations are used that include both two-dimensional fluid calculations (axial and radial) and two-dimensional heat conduction calculations (axial and radial). However, some implementations can produce high-quality results with less than a full two-dimensional calculation. Generally, the shape produces a flow that actually only results in relevant axial variations. Thus, some implementations solve only for one-dimensional axial flow without a radial component. The reverse is true for conduction. The radial component is very important, while the axial component is less so. Thus, some implementations solve only for one-dimensional radial conduction. In this situation, both the axial and radial directions may be solved, but they are not true two-dimensional calculations. Solving only for one-dimensional axial flow and one-dimensional radial conduction is sometimes referred to as "1.5-dimensional."

[0067] The output from the thermal-hydraulic calculation (e.g., axial temperature distribution) is then used as input to the neutron calculation and mechanical stability analysis (310). The thermal-hydraulic process, neutron process, and mechanical stability analysis calculate various metrics. In particular, the process extracts nominal K eff and its standard error from the neutron calculation in this process (312).

[0068] Metrics calculated from multiple physical processes are then used as inputs to a cost function. The cost function measures the overall quality of the samples with respect to satisfying the constraints (314). Even if not all samples can provide a viable design for a nuclear reactor, some designs are better than others and can be used to iteratively find better designs. The metrics used in the cost function typically include metrics based on neutrons, thermal hydraulics, mechanical stability, mass, shape, cost, and other factors. In some implementations, the cost function f is a weighted combination of the differences between the target constraint values of each metric variable and the calculated values of each metric variable, e.g., Σ i w i (y i -c i ) where w i is the weight, y i is the measured metric value, and c i is the target constraint value.

[0069] Using the data from the cost function, the process applies optimization (e.g., machine learning) to build a model (316). In the example shown in this flowchart, the machine learning uses a random forest (RF) of decision trees according to samples of design variables and values of the cost function (316). The cost function simplifies the analysis by converting data of multiple metrics into a single numerical value (one-dimensional rather than multi-dimensional).

[0070] From among the samples, the process identifies the vector (i.e., the sample point) that produces the minimum residual (i.e., the minimum value of the cost function) (318). The process uses the random forest and bootstrap to evaluate the variability and reliability of the region around this vector. In particular, the process calculates the statistical power at this sample point (320) to determine the sample size n of the next Latin cube. Some implementations perform these steps using Gaussian-based analysis. Using a Gaussian distribution often works well due to the central limit theorem. Some implementations use the following equation for the Gaussian distribution to determine the next sample size n.

[0071]

Number

[0072] As an alternative, some implementations use a non-Gaussian distribution based on a binomial that requires more complex equations.

[0073] If the variability and reliability are known, the process shrinks the confidence region (322). In some implementations, the shrinkage follows a learning coefficient provided by the user. The shrinkage of each design variable follows the variability of the cost function of that design variable. The shrinkage creates a new confidence region (322) centered on the best vector, which is usually not a hypercube. Using this new confidence region and the determined sample size, the process generates a new set of samples (e.g., a Latin hypercube) (324), and then repeats the operation on the new set of samples (starting from box 308).

[0074] During this iterative process, the vector with the minimum residual can be on the wall (alias, boundary) of the confidence region (326). If this occurs, since the optimal solution may be outside the confidence region, the confidence region is expanded beyond the wall (e.g., expanded in a direction perpendicular to the boundary) (326).

[0075] The iterative process continues until the best vector remains the same over multiple iterations (328). Some implementations, in some cases, specify a predetermined number of generations of the invariant best vector before the process stops. For example, some implementations set the predetermined number of iterations to 3, 5, or 10.

[0076] When the process is complete, the data from the final random forest is used to provide the user with analysis data regarding the design and metric variables. Some examples of the output are illustrated in FIGS. 4A - 4D. In some implementations, the process illustrates the importance of each design variable (330).

[0077] FIG. 3B illustrates how the process of FIG. 3A is extended to include one or more categorical design variables (in addition to continuous numerical design variables). In this case, the set of samples (e.g., Latin hypercube) includes additional dimensions for each categorical variable (350). The range of values of a categorical variable is sometimes referred to as a "level". Regardless of the number of individual data values of a categorical variable, a dimension is added to the set of samples for each categorical variable. In some implementations, this process uses numerical variables instead of each categorical variable and encodes the categorical values as numbers. This is sometimes referred to as "one - hot encoding". For example, if there is a categorical variable for fluid type and the options are nitrogen, hydrogen, or oxygen, these three fluid types are encoded as 1, 2, and 3 (e.g., 01, 10, and 11). The process uses the existing random forest to control the covariance between the design variables (352).

[0078] Once the covariance is controlled, the process computes the uncertainty at the best vector (based on the random forest) (354). For this best vector, the process identifies all permutations of the categorical variables (356). Usually, since the number of categorical variables is small, the number of permutations is not large. Next, the process applies the random forest model for each permutation (358) and evaluates the probability that the permutation produces a better result than the current best. In this step, the process basically holds all non - categorical variables from the best vector and constructs a plurality of new samples that include each permutation of the categorical variables. Each of the plurality of new samples is evaluated according to a machine - learning model (e.g., random forest) to estimate the probability of obtaining a better result than the current best vector.

[0079] Generally, the number of sample points corresponding to each category value is not the same. Therefore, the process adjusts the standard error by the number of data points in each category (360) to avoid factors that are incorrectly biased with a small weight. In some implementations, the probabilities are adjusted so that the sum of all probabilities is 1 (362). The process then uses the probabilities as sampling rates (364). For example, if a particular category value is more likely to lead to better results, it can be used for sampling at a higher frequency than other category values.

[0080] The process uses the sampling rates calculated in the generation of the next set of samples (366). The next set of samples divides the levels of each category in proportion to the sampling rate. In other words, a set of samples set for continuous values is obtained, and the samples are classified into "bins" based on levels proportional to the probability values calculated by the random forest. The process then repeats as shown in FIG. 3A until it converges (368).

[0081] The computations for the thermohydraulic engine 132, the mechanical stability analysis engine 134, and the neutron engine 136 can be performed at various levels of fidelity. In some implementations, there are three broad levels of fidelity. At the lowest level of fidelity, the overall fitness of the samples is tested, and many of such samples can be discarded immediately since they are far from meeting the constraints. At the second level of fidelity, the computations are slower but fairly accurate. By limiting the number of sample points that use the second level of fidelity, the design space can be generated in a few hours across the entire algorithm.

[0082] The third level of fidelity is applied outside the scope of the disclosed process. This highest level of fidelity is used to verify the design to meet the strict requirements specified by government regulations. Since the disclosed process generates a very good design space, the highest fidelity algorithms (which may take weeks or months to execute) are expected to verify the designs within the generated design space. Example of design optimization using machine learning and statistical sampling

[0083] According to some implementations, the method is executed on a computing system. Typically, the computing system comprises a plurality of computers, each of the plurality of computers having one or more processors and memory. The method can be used to optimize design constraints for manufacturing (e.g., of a nuclear reactor core). The method includes receiving user input specifying (i) design optimization constraints for a plurality of design variables, and (ii) a cost function for evaluating designs for the plurality of design variables. The method includes applying stochastic sampling to obtain a plurality of data samples for the plurality of design variables. The method includes training a first machine learning model to generate a subset of the data samples based on the plurality of data samples and the design optimization constraints. The method also includes training a mixture of Gaussians model to classify a subset of the data samples to obtain Gaussian distributions for a determined number of groups. The method also includes training a second machine learning model to rank the Gaussian distributions based on the cost function to obtain candidate designs. The method also includes generating a new plurality of data samples based on the candidate designs using a Markov chain Monte Carlo algorithm. The method also includes repeating applying stochastic sampling, training the first machine learning model, training the mixture of Gaussians model, training the second machine learning model, and generating a new plurality of data samples until design criteria are met. In some implementations, the method includes using the first machine learning model, the mixture of Gaussians model, and the second machine learning model from the last iteration to evaluate the relative importance of each design variable, and providing the evaluation visually in a report.

[0084] In some implementations, the cost function includes a multi-physics linear combination of thermal, nuclear, and mechanical aspects of the core design.

[0085] In some implementations, the first machine learning model is a random forest of decision trees, and the second machine learning model is a random forest of decision trees.

[0086] In some implementations, the first machine learning model is a random forest of decision trees, and training the first machine learning model to generate a subset of data samples includes approximating a candidate optimal variance with the within - variance of the decision trees, calculating a non - parametric upper 95% confidence interval based on the candidate optimal variance, and generating a subset of data samples using a predetermined cut - off threshold and the non - parametric upper 95% confidence interval.

[0087] In some implementations, the plurality of optimization design constraints includes one or more physical constraints. The method further includes training a third machine learning model using a plurality of data samples to predict a probability for data samples that satisfy one or more physical constraints, and using the third machine learning model to generate a probability that a candidate design satisfies one or more physical constraints. In such implementations, generating the new plurality of data samples is further based on the generated probability for the candidate design. In some implementations, further includes selecting the third machine learning from a list of classifier models based on the number of samples in the plurality of data samples. The list of classifier models includes k - nearest neighbor classifier models, support vector machines, and feed - forward neural networks. Some implementations improve the efficiency of optimization by excluding sampling regions that can result in topological discontinuities, thereby optimizing computation time and / or avoiding wasted computations. Model In some implementations, the plurality of optimization design constraints includes one or more physical constraints. The method further includes selecting one or more data samples from a plurality of data samples that satisfy one or more physical constraints, and training the first machine learning model is further based on the one or more data samples.

[0088] In some implementations, the plurality of optimization design constraints includes one or more physical constraints. The method further includes selecting one or more data samples from a plurality of data samples that satisfy one or more physical constraints, and training the first machine learning model is further based on the one or more data samples.

[0089] In some implementations, the Markov chain Monte Carlo algorithm uses the Metropolis-Hastings method to fit the covariance matrix.

[0090] In some implementations, the plurality of design variables includes a first design variable having discrete categorical values, and the Markov chain Monte Carlo algorithm uses a hierarchical multinomial distribution.

[0091] Examples of open source products that can be used to implement the above methods and / or modules include Scikit-sklearn, Scipy, Numpy, Pandas, Statsmodels, pyDOE2, Dexpy, and native / convenience packages included in the installation of Python / Anaconda. Scikit-sklearn provides a number of convenient routines for data science and machine learning algorithms that can be used directly for learning in the parameter space. Some implementations use the k-nearest neighbor algorithm, Gaussian mixture model, random forest, support vector classifier, and multilayer perceptron (basic feedforward neural network), as well as convenient routines within Scikit-sklearn. Some implementations use Numpy, a package that enhances the capabilities of Python for handling matrix / array operations for scientific computing. In some implementations, scientific code written in Python uses Numpy. Some implementations use Pandas, which provides the construction of "dataframes" to improve the data science capabilities for data manipulation. Some implementations use Statsmodels, which provides convenient functions. Some implementations use pyDOE2 for the generation of Latin hypercubes.

[0092] According to some implementations, the method uses statistical models and machine learning to select an optimization method for a given topology. Some implementations use test functions for numerous topologies. Some implementations benchmark different heuristic global optimization methods. Some implementations develop a model to predict the execution time or optimization efficiency of each topology based on sampling of the topologies.

[0093] In some implementations, the method includes testing a random set of samples (e.g., 50 random samples) or samples or points of a Latin hypercube. Based on the samples (e.g., 50 points), the method determines an optimization model or algorithm that is expected to find the global minima (e.g., without requiring user input to test different optimizations).

[0094] Figures 4A-4D provide several figures including output analysis information regarding a nuclear reactor design process.

[0095] In Figure 4A, each of the bar graphs is a histogram showing the distribution of samples regarding various design variables. For example, the first histogram 402 shows the distribution of samples having various core radii. The second histogram 404 shows the distribution of samples regarding the thickness of the radial reflector (rr_thickness). The third histogram 406 shows the distribution of samples regarding the thickness of the top reflector (tr_thickness). The fourth histogram 408 shows the distribution of samples regarding the thickness of the bottom reflector (br_thickness). The fifth histogram 410 shows the distribution of sample points regarding the "flat to flat" which is essentially the width of the fuel hexagon. The sixth distribution 412 shows the distribution of samples regarding the core height. The seventh histogram 414 shows the distribution of sample points regarding the size of the fluid flow path.

[0096] Figure 4B is an image display showing the correlation between a set of measurement variables 112 and the total residual 420. In this example, the measurement variables 112 are the inlet temperature 422, the maximum fuel temperature 424, the relative pressure loss 426, and the effective neutron multiplication factor 428. Each box has a value that can range between -1 (perfect negative correlation) and 1 (perfect positive correlation). Of course, since each of the measurements is perfectly correlated with itself, the value of the box representing autocorrelation (box 434, etc.) is 1. The figure in Figure 4 shows that the residual 420 is moderately correlated with the maximum temperature 424 (a correlation of 0.42 in box 430), and that the residual 420 is strongly correlated with the relative pressure loss 426 (a correlation of 0.95 in box 432). This figure also shows that the inlet temperature 422 is somewhat negatively correlated with the maximum temperature 424 (a correlation of -0.64 in box 436). Further, box 438 shows a very small positive correlation of 0.09 between the inlet temperature 422 and the relative pressure loss 426. This figure also includes a color legend 440 showing how the correlation values are displayed within the boxes. In this example, higher positive or negative correlations are displayed with both a stronger color and a greater saturation. This allows the user to quickly identify the more important correlations.

[0097] Figure 4C shows several graphs generated by the thermal-hydraulic treatment. Each of the graphs shows a different variable plotted against the axial distance. These graphs show the behavior of the thermal-hydraulic calculations and enable insight and diagnosis.

[0098] Figure 4D shows the relative importance of each measurement variable in the calculation of the cost function (residual). In this example, there are five measurement variables including the effective neutron multiplication factor K eff 450, the maximum center temperature 452, the total mass 454 (i.e., the total mass of all of the core), the pressure loss 456, and the inlet temperature 458. In this figure, the relative importance of each measurement to the residual calculation is adjusted so that the total is 1.0. In some implementations, the user can select which measurements to display. For example, the system typically has measurements for both the pressure loss (P) and the pressure loss relative to the system pressure (dP / P). In the figure shown, only the pressure is displayed. As shown in this figure, Keff 450 accounts for 50% of the residuals, the maximum central temperature 452 accounts for 20% of the residuals, and each of the other metrics accounts for 10% of the residuals. These percentages are aggregated based on all the processed samples.

[0099] Some implementations also include batch correlations and plots showing what happened in previous iterations. In this way, while the optimization is running, the user can see what is happening (rather than waiting until the optimization is complete).

[0100] The terms used in the description of the invention herein are for the purpose of describing particular implementations only and are not intended to limit the invention. As used in the description of the invention and the appended claims, the singular forms "a", "an", and "the" are intended to include the plural forms as well, unless the context clearly dictates otherwise. It is also understood that the term "and / or" as used herein refers to and encompasses any and all possible combinations of one or more of the associated listed items. Further, the terms "comprising" and / or "including" as used herein, when used, specify the presence of the described functions, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other functions, steps, operations, elements, components, and / or groups thereof.

[0101] The above description has been presented for purposes of illustration and is described with reference to particular implementations. However, the above exemplary discussion is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teachings. The implementations were chosen and described in order to best explain the principles of the invention and its practical application, thereby enabling one of ordinary skill in the art to best utilize the various implementations with various modifications suited to the particular use contemplated.

Claims

Claim 1 A method for designing a nuclear reactor, comprising: identifying a plurality of design variables for the nuclear reactor; identifying a plurality of measurement variables for the nuclear reactor, including a plurality of measurement variables for measuring the thermal-hydraulic characteristics of the nuclear reactor, a plurality of measurement variables for measuring the neutron characteristics of the nuclear reactor, and a plurality of measurement variables for measuring the stress characteristics of the nuclear reactor; forming an initial trust region by receiving user input for specifying an individual range of values for each of the plurality of design variables; receiving user input for specifying an individual target value for each of the plurality of measurement variables; obtaining N samples of values of the plurality of design variables within the initial trust region that minimize the multivariate correlation between the plurality of design variables; for each of the N samples, performing a thermal-hydraulic analysis process to calculate the plurality of measurement variables for measuring the thermal-hydraulic characteristics; performing a neutron analysis process to calculate the plurality of measurement variables for measuring the neutron characteristics; performing a stress analysis process to calculate the plurality of measurement variables for measuring the stress characteristics; and applying a cost function to calculate an individual set residual of the plurality of measurement variables compared to the target values for the plurality of measurement variables; training an optimization model according to the N samples and the calculated set residuals respectively corresponding to the N samples; narrowing the initial trust region around the sample with the smallest residual among the N samples, wherein the individual range for each design variable of the plurality of design variables is narrowed using the optimization model according to the correlation between the individual design variable and the estimated residual; repeating constructing, performing the thermal-hydraulic analysis process, performing the neutron analysis process, performing the stress analysis process, calculating, and training until the sample with the smallest residual among the N samples no longer changes during a predetermined number of iterations; using the optimization model from the last iteration to evaluate the importance of each design variable of the plurality of design variables; and visually reporting the evaluation in a report, comprising a method for designing a nuclear reactor. Claim 2 The method according to claim 1, wherein the optimization model is a random forest of decision trees. The method of claim 1. Claim 3 The method according to claim 1 or 2, wherein the optimization model is a neural network. The method of claim 1 or 2. Claim 4 Performing the thermal-hydraulic analysis process, performing the neutron analysis process, and performing the stress analysis process are performed simultaneously. The method according to any one of claims 1 to 3.

5. Performing the thermal-hydraulic analysis process, performing the neutron analysis process, and performing the stress analysis process are performed sequentially. The method according to any one of claims 1 to 3.

6. The thermal-hydraulic analysis process, the neutron analysis process, and the stress analysis process are each performed in separate and different calculation subsystems. The method according to any one of claims 1 to 5.

7. During the iteration, Determining that the sample with the minimum residual has the value of the first design variable on the boundary of the first trust region; and In response to the determination, expanding the first trust region to include the range of the first design variable that was not previously in the first trust region; Further comprising The method according to any one of claims 1 to 6.

8. One of the plurality of metric variables is the effective neutron multiplication factor (Keff). The method according to any one of claims 1 to 7.

9. The shrinking uses a learning coefficient specified by user input. The method according to any one of claims 1 to 8.

10. The N samples are centered around the average value of the range specified by the user of the plurality of design variables. The method according to any one of claims 1 to 9.

11. The plurality of design variables includes a first design variable having discrete categorical values, The method includes Encoding each discrete categorical value as a numerical value within a continuous range to form a first replacement design variable; and Replacing the first design variable with the first replacement design variable. Further comprising The method according to any one of claims 1 to 10.

12. During each iteration, Using the optimization model to estimate the probability of producing a smaller residual by switching to a different categorical value for the sample with the minimum residual according to the cost function; and For the next iteration, using a sampling rate for the N samples proportional to the estimated probability. Further comprising The method of claim 10 or 11.

13. The first design variable is a fluid type. The method of claim 7 or 11.

14. The categorical values of the fluid type are hydrogen, helium, and nitrogen. The method of claim 13.

15. Comprising one or more computers each having one or more processors and a memory, the memory storing one or more programs configured for execution by the one or more processors, the one or more programs comprising: identifying a plurality of design variables for a nuclear reactor; identifying a plurality of measurement variables for the nuclear reactor, including a plurality of measurement variables for measuring the thermal-hydraulic characteristics of the nuclear reactor, a plurality of measurement variables for measuring the neutron characteristics of the nuclear reactor, and a plurality of measurement variables for measuring the stress characteristics of the nuclear reactor; forming an initial trust region by receiving user input for specifying an individual range of values for each of the plurality of design variables; receiving user input for specifying an individual target value for each of the plurality of measurement variables; acquiring N samples of values of the plurality of design variables within the initial trust region that minimize a multivariate correlation between the plurality of design variables; for each of the N samples, performing a thermal-hydraulic analysis process to calculate the plurality of measurement variables for measuring thermal-hydraulic characteristics; performing a neutron analysis process to calculate the plurality of measurement variables for measuring neutron characteristics; performing a stress analysis process to calculate the plurality of measurement variables for measuring stress characteristics; and applying a cost function to calculate an individual set residual of the plurality of measurement variables compared to the target values for the plurality of measurement variables; training an optimization model according to the N samples and the calculated set residuals respectively corresponding to the N samples; shrinking the initial trust region centered on the sample with the smallest residual among the N samples, wherein the individual ranges for each design variable of the plurality of design variables are shrunk using the optimization model according to the correlation between the individual design variables and the estimated residuals; repeating constructing, performing the thermal-hydraulic analysis process, performing the neutron analysis process, performing the stress analysis process, calculating, and training until the sample with the smallest residual among the N samples stops changing for a predetermined number of iterations; using the optimization model from the last iteration to evaluate the importance of each design variable of the plurality of design variables; and visually reporting the evaluation in a report, including instructions for a computing system.

16. The optimization model is a random forest of decision trees, The computing system of claim 15.

17. The optimization model is a neural network, The computing system of claim 15 or 16.

18. One of the plurality of metric variables is an effective neutron multiplication factor (Keff), The computing system according to any one of claims 15 to 17.

19. The plurality of design variables includes a first design variable having discrete categorical values, The instruction is, encoding each discrete categorical value as a numerical value within a continuous range to form a first replacement design variable; and replacing the first design variable with the first replacement design variable, further comprising, The computing system according to any one of claims 15 to 18.

20. During each iteration, using the optimization model to estimate the probability of generating a smaller residual according to the cost function by switching to different categorical values for the sample among the N samples with the smallest residual; and using a sampling rate for the N samples proportional to the estimated probability for the immediately subsequent iteration, further comprising, The computing system of claim 19.

21. A method for optimizing design constraints for manufacturing, comprising receiving user input specifying design optimization constraints for a plurality of design variables and specifying a cost function for evaluating designs for the plurality of design variables; applying probabilistic sampling to obtain a plurality of data samples for the plurality of design variables; training a first machine learning model to generate a subset of the data samples based on the plurality of data samples and the design optimization constraints; training a mixture of Gaussians model to classify a subset of the data samples to obtain Gaussian distributions for a determined number of groups; training a second machine learning model to rank the Gaussian distributions based on the cost function to obtain candidate designs; generating a new plurality of data samples based on the candidate designs using a Markov chain Monte Carlo algorithm; Repeating (i) applying probabilistic sampling, (ii) training the first machine learning model, (iii) training the mixture Gaussian model, (iv) training the second machine learning model, and (v) generating the new plurality of data samples until the design criteria stop changing for a predetermined number of iterations; Using the first machine learning model, the mixture Gaussian model, and the second machine learning model from the last iteration to evaluate the importance of each design variable of the plurality of design variables; And Providing the evaluation visually in a report, Including, A method for optimizing design constraints for manufacturing. [

22. ] The cost function includes a multi-physics linear combination of thermal, nuclear, and mechanical aspects of the core design, The method of claim 21. [

23. ] The first machine learning model is a random forest of decision trees, The second machine learning model is a random forest of decision trees, The method of claim 21 or 22. [

24. ] The first machine learning model is a random forest of decision trees, Training the first machine learning model to generate the subset of data samples includes: Approximating a candidate optimal variance with the within-variance of the decision trees; Calculating a non-parametric upper 95% tolerance based on the candidate optimal variance; Generating the subset of data samples using a predetermined cut-off threshold and the non-parametric upper 95% tolerance, Including, The method of any one of claims 21 to 23. [

25. ] The design optimization constraints include one or more physical constraints, The method further includes, Training a third machine learning model using the plurality of data samples to predict the probability that a data sample among the plurality of data samples meets the one or more physical constraints; and Generating a probability for the candidate design using the third machine learning model; Including, Generating the new plurality of data samples is further based on the generated probability for the candidate design, The method of any one of claims 21 to 24. [

26. ] Further including selecting the third machine learning model from a list of classifier models based on the number of samples within the plurality of data samples, The list of classifier models includes a k-nearest neighbor classifier model, a support vector machine, and a feedforward neural network. The method of claim 25. Claim 27 The design optimization constraints include one or more physical constraints, The method further includes selecting one or more data samples from the plurality of data samples that meet the one or more physical constraints, Training the first machine learning model is further based on the one or more data samples, The method according to any one of claims 21 to 26. Claim 28 The Markov chain Monte Carlo algorithm uses the Metropolis-Hastings method to fit the covariance matrix. The method according to any one of claims 21 to 27. Claim 29 The plurality of design variables include a first design variable having discrete categorical values, The Markov chain Monte Carlo algorithm uses a hierarchical multinomial distribution. The method according to any one of claims 21 to 28. Claim 30 Comprising one or more computers each having one or more processors and a memory, The memory stores one or more programs configured for execution by the one or more processors, The one or more programs are Receiving user input that specifies design optimization constraints for a plurality of design variables and specifies a cost function for evaluating designs for the plurality of design variables; (i) Applying probabilistic sampling to obtain a plurality of data samples for the plurality of design variables; (ii) Training a first machine learning model to generate a subset of data samples based on the plurality of data samples and the design optimization constraints; (iii) Training a mixture of Gaussian models to classify a subset of data samples to obtain Gaussian distributions for a determined number of groups; (iv) Training a second machine learning model to rank the Gaussian distributions based on the cost function to obtain candidate designs; (v) Using a Markov chain Monte Carlo algorithm to generate a new plurality of data samples based on the candidate designs; Repeating (i) applying probabilistic sampling, (ii) training the first machine learning model, (iii) training the mixture Gaussian model, (iv) training the second machine learning model, and (v) generating the new plurality of data samples until the design criteria stop changing for a predetermined number of iterations; Using the first machine learning model, the mixture Gaussian model, and the second machine learning model from the last iteration to evaluate the relative importance of each design variable of the plurality of design variables; and Providing the evaluation visually in a report, including instructions for a computing system.

Images