Optimization of expensive cost functions subject to complex multidimensional constraints

Abstract

A method for designing a nuclear reactor using design variables and metric variables. A user specifies the range of the design variables and the target values ​​of the metric variables. A sample set of design parameters is selected. For each sample, the method runs three processes that calculate the metric variables for thermal hydraulics, neutronics, and stress. The method applies a cost function to each sample to calculate the aggregated residual of the metric variables compared to the target value. The method uses the samples and the calculated aggregated residuals to train a machine learning model. The method shrinks the range of each design variable based on the correlation between the corresponding design variable and the estimated residual using the machine learning model. These steps are repeated until the sample with the smallest residual does not change over multiple iterations. The method then uses the final machine learning model to evaluate the relative importance of each design variable.

Description

[0001] Related applications

[0002] This application is based upon and claims priority from U.S. Provisional Patent Application No. 62 / 962,806, filed on January 17, 2020, the entire contents of which are incorporated herein by reference. Technical Field

[0003] The disclosed implementations relate generally to generative design and, more particularly, to systems, methods, and user interfaces that leverage machine learning to rapidly produce feasible designs. Background Art

[0004] In the following discussion, reference is made to certain structures and / or methods. However, the following references should not be construed as an admission that these structures and / or methods constitute prior art. Applicants expressly reserve the right to demonstrate that such structures and / or methods do not qualify as prior art for the present invention.

[0005] The described techniques for optimizing a cost function over complex multi-dimensional constraints are illustrated with respect to designing a nuclear reactor core. However, the techniques are not limited to this specific example.

[0006] The design for a nuclear reactor core must address a complex interplay of physical disciplines. For example, the design requires neutronics to maintain criticality (fission reactions), which also depends on the fuel and moderator properties. The design also requires thermal properties such as heat flux curves, conductivity, and output. Furthermore, the design must satisfy stress analysis for assembly integrity and material properties to ensure it will not melt or fragment under energy flux and cyclic stresses.

[0007] Testing neutronics cases using the Monte Carlo N-Particle Transport code (MCNP) or other validated simulators typically takes several days for a single design, after which thermal and stress simulations or calculations must also be run. Finding an effective design parameter combination for a particular geometry can take months. Historically, attempts to speed up this process have taken the form of: (i) adding computing power and / or using supercomputers; (ii) accelerating computations, such as using GPU computing development; and / or (iii) utilizing cutting-edge software that addresses inefficiencies in workflow and format compatibility and can deploy alternative, but unvalidated, solvers. However, the process remains very slow, and it often takes months to determine that the proposed design does not meet all requirements. In addition, some systems have attempted to increase fidelity or further integrate physics-based modeling and simulation software, often through government laboratories, which have high development costs, which often slows the process even further.

[0008] Product design optimization often requires weighing numerous parameters. For example, the design for a nuclear reactor core must address a complex interplay of physical disciplines. The core design requires neutronics to maintain criticality (fission reactions), which also depends on the fuel and moderator properties. The design also requires thermal characteristics such as heat flux curves, conductivity, and output. Furthermore, the design must satisfy stress analysis for assembly integrity and material properties to ensure it will not melt or fragment under energy flux and cyclic stresses.

[0009] Design optimization is a complex task that can take days to complete, even on the fastest computers. For example, testing neutronics cases using the Monte Carlo N-Particle Transport code (MCNP) or other validated simulators typically takes several days for a single design, after which thermal and stress simulations or calculations must also be run. Finding an efficient combination of design parameters for a particular geometry can take months.

[0010] Historically, attempts to speed up the process have taken the form of: (i) adding computing power and / or using supercomputers; (ii) accelerating computing, such as using GPU computing development; and / or (iii) utilizing cutting-edge software that addresses inefficiencies in workflow and format compatibility and can deploy alternative, but unproven, solvers. However, the process remains very slow, and it often takes months to determine that the proposed design does not meet all requirements. In addition, some systems attempt to increase fidelity or further integrate physics-based modeling and simulation software, often through government laboratories, which have high development costs, which often slows the process even further.

[0011] Additionally, state-of-the-art techniques, such as those using surrogate models, can only find local minima. Search strategies for finding global optimal solutions, such as genetic algorithms, simulated annealing, and particle swarm optimization, typically require significant computational resources, and many techniques are difficult to parallelize. Most techniques cannot handle categorical variables and / or do not incorporate probabilities. Summary of the Invention

[0012] The present disclosure uses an artificial intelligence (AI) suite to find the optimal design space within user-specified constraints, which provides: (i) rapid, automated evaluation of conceptual reactor designs; (ii) identification of the effective parameter space and optimal parameters that meet neutronics, thermal-hydraulic, and stress requirements; and (iii) synthesis and analysis of the results to facilitate decision making.

[0013] Some implementations provide a global, swarm-based algorithm that applies a heuristic-based process using machine learning to optimize the entire design space, such as the active core region of a nuclear fission reactor. This algorithm (i) adaptively filters and / or removes insignificant variables to accelerate convergence to the optimal design solution; and (ii) systematically evaluates complex multivariable interactions during optimization, which is also used to generate reports that assess the constraints limiting decision making (design requirements analysis) and detailed core understanding (design analysis). Some implementations apply the same techniques in conjunction with genetic algorithms to provide evolutionary optimization.

[0014] The disclosed implementation uses a machine learning-based algorithm to rapidly identify and optimize design options simultaneously along task and engineering constraints through machine learning-based random sampling across physical disciplines. By sampling the response space and learning the topology, each parameter for potential candidate subregions is recursively refined according to a cost function. The final valid design space is identified and output to the user along with valid design options, along with analysis to investigate the tradeoffs and properties of the valid designs. During this process, a "trust region" for the design parameters is initially specified by the user and typically decreases in size during each iteration. The trust region converges to the final design space.

[0015] The design subspace is non-spherical and is refined based on user-defined baseline selections and constraints. The disclosed implementation employs multi-physics analysis (neutronics, thermal hydraulics, and stress analysis) in sampling mode using relatively fast runs. This includes solvers for the effective neutron multiplication factor (k-effective or K eff ) modeling to discover the gradients of various design variables that tend to reach the optimal design space. Once a valid design space is identified, only preferred design choices with a high likelihood of validity are further validated with high-fidelity operational experience (e.g., using MCNP or other high-fidelity simulations to model the reactor core for neutronics, thermal, and / or stress analysis). The disclosed process avoids the use of other expensive computational resources, computational delays, and individual subject matter expert engineering time. This process reduces the use of these resources on ineffective designs, ultimately increasing flexibility and customization.

[0016] The disclosed method provides the ability to understand (within a timeframe of hours) interactions that are too complex for humans to process explicitly. The disclosed method provides more than one design that meets the design criteria. Instead, the disclosed method operates during the run of the computer analysis, without interrupting the run, and analyzes the tradeoffs between multiple designs that naturally emerge with evolving design discoveries and a series of design inputs and a changing mission profile.

[0017] According to some implementations, a method is performed at a computing system. Typically, the computing system includes multiple computers, each having memory and one or more processors. The method is used to design a nuclear reactor core. The design process uses multiple design variables for the nuclear reactor. Design variables are essentially independently controlled variables. In addition, the design process uses multiple metric variables related to the nuclear reactor. The metric variables include, for example, variables measuring thermal-hydraulic properties, variables measuring neutronics properties, and variables measuring stress properties. The metric variables are essentially dependent variables that measure the feasibility of the design. Other metric variables may also be used.

[0018] The user forms an initial trust region by specifying a range of values ​​for each design variable. The trust region is initially a hypercube centered at a point whose coordinates are the average values ​​for each range. The user also specifies a constraint value for each metric variable, for example, a maximum fuel temperature or a maximum pressure drop.

[0019] The method obtains N samples of values ​​for design parameters within an initial trust region. In some implementations, the method includes constructing the N samples using Latin Hypercube Sampling (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 so that they minimize multivariate correlations between design variables. This process minimizes correlations in two potential ways: (i) increasing the number of samples, and / or (ii) selecting samples with replacement. N is an integer greater than 1 (e.g., 10, 25, or 50).

[0020] For each of the N samples, the method performs several actions: (i) performing a thermal-hydraulic analysis process to calculate a plurality of metric variables measuring thermal-hydraulic properties; (ii) performing a neutronics analysis process to calculate a plurality of neutronics metrics corresponding to the neutronics properties; (iii) performing a stress analysis process to calculate a plurality of metric variables corresponding to stress (and related) properties; and (iv) applying a cost function to calculate corresponding aggregated residuals of the metric variables compared to target values ​​for the metric variables.

[0021] The method then trains an optimization model based on the N samples and the corresponding calculated aggregate residuals. Various machine learning techniques can be 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 Gaussian processes for machine learning. In some implementations, the optimization model is a Markov chain model.

[0022] The method then shrinks the trust region, concentrating the modified trust region at the sample point (one of the N samples) with the smallest residual. Although the trust region initially begins as a hypercube, it is typically not a hypercube as it shrinks. Using the optimization model, the corresponding range for each design variable is shrunk based on the correlation between the corresponding design variable and the estimated residual.

[0023] The process then iterates, constructing, executing the thermal-hydraulic process, executing the neutronics process, executing the stress process, calculating, and training until the sample with the smallest residual does not change for a predetermined number of iterations. Using the optimized model from the final iteration, the method evaluates 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 with one or more data visualizations that illustrates the importance of each design variable and / or illustrates which metric variable imposes the greatest design constraints.

[0024] In some implementations, performing a thermal hydraulic analysis process, performing a neutronics analysis process, and performing a stress analysis process are performed simultaneously. In some implementations, there is an initial rough screening for each point, and sample points that create very poor results (e.g., K eff Insufficient sample points were rejected).

[0025] In some implementations, executing the thermal-hydraulic analysis process, executing the neutronics analysis process, and executing the stress analysis process are performed serially. In some implementations, executing the thermal-hydraulic analysis process, executing the neutronics analysis process, and executing the stress analysis process are performed in parallel. In some implementations, executing the thermal-hydraulic analysis process, executing the neutronics analysis process, and executing the stress analysis process are performed iteratively.

[0026] In some implementations, the thermal-hydraulic analysis process, the neutronics analysis process, and the stress analysis process are each executed in a respective separate computing subsystem. This allows the processes to run in parallel, and each computing subsystem can be optimized (e.g., hardware and / or software) for a specific type of computation.

[0027] In some instances, the optimal sample point lies at the boundary of the trust region, indicating that the optimal solution may be outside the current trust region. In such cases, some implementations expand the trust region. Specifically, when the method determines in an iteration that the sample with the minimum residual has a value of the first design variable on the boundary of the trust region, the method expands the trust region to include the range of the first design variable that was not previously within the trust region. In some implementations, the expansion of the trust region does not permit expansion beyond the initial parameters specified by the user (e.g., expansion may undo an earlier contraction).

[0028] In some implementations, one of the metric variables is the effective neutron multiplication factor (Keff ).

[0029] In some implementations, the shrinkage of the trust region uses a learning rate multiplier specified by user input.

[0030] In some implementations, the N samples are centered around a mean of a user-specified range of the design variable.

[0031] The method also works when one or more design variables have discrete categorical values ​​rather than numeric ranges. For example, one of the design variables may be a fluid type, having categorical values ​​such as "hydrogen," "helium," and "nitrogen." In some implementations, when the design variables include a first design variable having discrete categorical values, the method further includes: (i) encoding each distinct categorical value as a numeric value within 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 may be a fuel material or a fuel loading pattern (e.g., the placement or location of the fuel in the core).

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

[0033] 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 find the optimal design space within user-specified constraints. The disclosed techniques can be used to generate rapid, automated evaluations of conceptual designs (e.g., core designs), identify valid parameter spaces and optimal parameters (e.g., parameters that meet neutronics, thermal-hydraulic, and stress requirements), and / or synthesize and visualize results to facilitate decision making.

[0034] For design optimization problems, some implementations distinguish local minima from global minima (or global optimal solutions). Some implementations handle categorical variables. Some implementations can handle very large numbers of dimensions (parameters or search spaces). The disclosed techniques can be easily parallelized to run on large computing clusters. An additional advantage of the disclosed techniques is that, at least in some implementations, bounds checking is not required on function calls because the algorithm adaptively learns bounds to work around boundary conditions.

[0035] According to some implementations, a method is performed at a computing system. Typically, the computing system includes multiple computers, each having memory and one or more processors. The method can be used to optimize design constraints for manufacturing (e.g., a nuclear reactor core). The method includes receiving user input to specify (i) design optimization constraints for multiple design variables, and (ii) a cost function for evaluating designs of the multiple design variables. The method includes applying random sampling to obtain multiple data samples for the multiple design variables. The method includes training a first machine learning model to generate a subset of the data samples based on the multiple data samples and the design optimization constraints. The method also includes training a Gaussian mixture model to classify the subset of data samples to obtain a Gaussian distribution for a predetermined 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 multiple new data samples based on the candidate designs using a Markov Chain Monte Carlo algorithm. The method also includes repeatedly applying random sampling, training the first machine learning model, training the Gaussian mixture model, training the second machine learning model, and generating multiple new data samples until the design criteria are met. In some implementations, the method includes evaluating the relative importance of each design variable using the first machine learning model, the Gaussian mixture model, and the second machine learning model from the final iteration, and providing the evaluation visually in a report.

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

[0037] 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.

[0038] In some implementations, the first machine learning model is a random forest of decision trees, and training the first machine learning model to generate the data sample subset includes approximating a candidate optimal variance with an internal variance of the decision tree, calculating a non-parametric 95% upper bound on the variance based on the candidate optimal variance, and generating the data sample subset by using a predetermined cutoff threshold and the non-parametric 95% upper bound on the variance.

[0039] In some implementations, the plurality of optimization design constraints include one or more physical constraints, and the method further includes: training a third machine learning model using the plurality of data samples to predict a probability that the data samples satisfy the one or more physical constraints, and using the third machine learning model to generate a probability that a candidate design satisfies the one or more physical constraints. In such implementations, generating the new plurality of data samples is further based on the generated probabilities for the candidate design. In some implementations, the method further includes selecting a third machine learning classifier 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, support vector machine, and feedforward neural network.

[0040] 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 the plurality of data samples that satisfy the one or more physical constraints, and training the first machine learning model is further based on the one or more data samples.

[0041] In some implementations, the Markov Chain Monte Carlo algorithm uses the Metropolis-Hastings method of adapting the covariance matrix.

[0042] In some implementations, the design variables include a first design variable having discrete categorical values, and the Markov Chain Monte Carlo algorithm uses a hierarchical multinomial distribution.

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

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

[0045] Thus, methods and systems are disclosed that provide rapid design optimization using machine learning and probability theory.The discussions, examples, principles, compositions, structures, features, arrangements, and processes described herein may be applied, adapted, and embodied in manufacturing nuclear reactors. BRIEF DESCRIPTION OF THE DRAWINGS

[0046] For a better understanding of the disclosed systems and methods, as well as additional systems and methods, reference should be made to the following detailed description in conjunction with the following drawings, in which like reference numerals refer to corresponding parts throughout the various figures.

[0047] Figure 1A A high-level overview of a process for designing a nuclear reactor core according to some implementations is provided.

[0048] Figure 1B A high-level overview of a process for design optimization according to some implementations is provided.

[0049] Figure 2 is a block diagram of a computing device according to some implementations.

[0050] Figure 3A and Figure 3B is a flow chart of a process for rapid digital nuclear reactor design using machine learning according to some implementations.

[0051] Figures 4A-4D Illustrated is output analysis for nuclear reactor design according to some implementations.

[0052] Reference will now be made to implementations, examples of which are illustrated in the accompanying drawings. In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. However, it should be apparent to those skilled in the art that the present invention may be practiced without these specific details. DETAILED DESCRIPTION

[0053] Figure 1A A high-level overview of a process for designing a nuclear reactor core according to some implementations is provided. Input 102 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, the input 102 is provided via a command line interface or using an input file. The input 102 includes design variables 110, which are parameters that specify the physical design characteristics of the reactor core (e.g., geometry, operating conditions, fuel loading, fuel type pattern, size, mass, a finite list of fuel and moderator alternatives, or materials of construction). The user specifies a numerical range (or a list of discrete values) for each design variable 110. The input 102 also includes metric variables 112, which are constraints on how the reactor core should operate (e.g., output megawatts, centerline temperature, fluid pressure drop, thrust, flow rate, ISP (specific impulse), total mass, component mass, poisons, or power distribution). The user specifies target values ​​for the metric variables. Some constraints are fundamental, such as those related to maintaining structural integrity over the expected lifetime.

[0054] Algorithm 104 is iterative and begins with a trust region 120. From this trust region 120, a number of sample points are selected. In some implementations, the sample points form a Latin hypercube (e.g., centered around a point whose coordinates are the mean of each range). The algorithm selects the sample points so as to minimize the maximum multivariate correlation between the design variables. In some implementations, this is an iterative process with a specified maximum value p_max, and iterates until the maximum multivariate correlation is less than p_max.

[0055] After selecting the sample points, the algorithm 104 runs three processes to determine the quality of each sample point. Typically, these processes run in parallel, but some implementations use one or more processes (e.g., the neutronics engine 136) to perform an initial screening to eliminate some designs that are too far from feasible. Each of the thermohydraulic engine 132, the mechanical stability ("stress") engine 134, and the neutronics engine 136 calculates a value for one or more metric variables 112. For each sample, the algorithm calculates a cost function that specifies the quality of the sample in terms of producing a feasible model for the reactor core. In some implementations, the cost function calculates a residual that is a weighted polynomial of the amount by which each metric variable differs from its target constraint value. For example, suppose there is n metric variables , which has the target constraint value and weights . Some implementations specify the residual as the sum of .

[0056] The sample points and calculated residuals are input to the optimization engine 140, which uses the data to build 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 iteratively evolves a set of programs to 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 Gaussian processes for machine learning. Based on the optimization model 262, the algorithm 104 determines the relative importance of each design variable. Some design variables have a significant effect on the residuals, but other design variables have little effect on the residuals. Using this data, the algorithm 104 is able to shrink (150) the trust region 120 and repeat the iterative process for smaller trust regions. Because the trust region shrinks with each iteration, the algorithm 104 collects more and more information about the smaller region, and therefore the data becomes more accurate. Note that when building the optimized model 262 , the accumulated sample points from all iterations are used (eg, if the same number of sample points are generated for the second iteration, the second iteration will have twice as many sample points in total to build the optimized model).

[0057] In some implementations, the process uses a genetic algorithm in each iteration instead of or in addition to trust region shrinkage. When using a genetic algorithm, each sample point is weighted according to its residual. In this case, samples with smaller residuals have higher weights. In some implementations, samples with excessively high residuals are assigned zero weights. These weights are used to construct the samples used in the next iteration. For example, pairs of samples are randomly selected based on their weights, and for each pair, one or two subsamples are constructed for the next iteration using mutation and / or crossover. In some implementations, more than two samples are used to generate subsamples for the next iteration.

[0058] When the optimal sample point does not change after a number of iterations, the algorithm 104 exits the processing loop. The data from the final iteration is used to provide an output analysis 106 to the user. In some implementations, the output analysis 106 is provided as graphical data visualizations, such as graphical data visualizations 160 and 162. The first graphical data visualization 160 shows the residual components based on the input parameters (i.e., design variables 110). This shows how much each design variable 110 contributes to the calculated residual. In this example, there are eight input parameters that have an impact on the residual, including core radius, core height, orifice diameter, and flow rate. In some implementations, any input parameter that contributes less than a threshold to the residual is omitted from the graph 160. The second graphical data visualization 162 shows the residual components based on the metric constraints 112. In this example data visualization 162, T max and K eff are the two most critical constraints, and the inlet temperature (Inlet T ) and the pressure drop dP / P are less important. In some implementations, these data visualizations 160 and 162 are interactive, allowing the user to investigate options.

[0059] According to some implementations, Figure 1BA high-level overview of the design optimization process is provided. 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, the input 172 is provided through a command line interface or using an input file. The input 172 includes design optimization constraints 180, which are constraints for the design optimization (e.g., design constraints for constructing a reactor core, such as geometry, operating conditions, fuel loading, fuel type pattern, size, mass, a finite list of fuel and moderator alternatives or materials of construction, or constraints on how the reactor core operates (e.g., output megawatts, centerline temperature, fluid pressure drop, thrust, flow rate, 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 a target value for a metric variable. The input 172 also includes a cost function 182 for evaluating design alternatives, such as a multi-physics linear combination of thermal, nuclear, and mechanical aspects of the core design.

[0060] The algorithm 174 is iterative, repeating the random sampling step 190, training the first machine learning algorithm 192, training the Gaussian mixture model 194, training the second machine learning model 196, and applying the Markov Chain Monte Carlo algorithm 198 until convergence is reached. According to some implementations, the trained model is then used to obtain the output analysis 176 (similar to the above reference Figure 1A Output analysis described in 106).

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

[0062] The computing device 200 may include a user interface 206 comprising a display device 208 and one or more input devices or mechanisms 210. In some implementations, the input device / mechanism comprises a keyboard. In some implementations, the input device / mechanism comprises a "soft" keyboard that is displayed on the display device 208 as needed, thereby enabling a user to "press" "keys" that appear on the display 208. In some implementations, the display 208 and the input device / mechanism 210 comprise a touch screen display (also known as a touch-sensitive display).

[0063] In some implementations, the 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, the 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 implementations, the memory 214 includes one or more storage devices remote from the CPU(s) 202. The memory 214, or alternatively, the non-volatile memory device(s) within the memory 214, includes non-transitory computer-readable storage media. In some implementations, the memory 214 or the computer-readable storage media of the memory 214 stores the following programs, modules, and data structures, or a subset thereof:

[0064] operating system 216 , which includes programs for handling various basic system services and for performing hardware-related tasks;

[0065] a communications module 218 for connecting the computing device 200 to other computers and devices via one or more communications network interfaces 204 (wired or wireless) and one or more communications networks (such as the Internet, other wide area networks, local area networks, metropolitan area networks, etc.);

[0066] a web browser 220 (or other application capable of displaying web pages), which enables a user to communicate with a remote computer or device over a network;

[0067] An input user interface 222 allows the user to specify a range 232 of allowable values ​​for the design variables 110 and to specify a target value 242 for the constraints 112. The ranges of the design variables are used to specify the initial trust region 120;

[0068] Output user interface 224 provides a graphical analysis 226 of the constructed design. Some examples of graphical analysis 226 are data visualizations 160 and 162 in FIG. 1 ;

[0069] a data sample selector 250 that selects a set of samples (e.g., a set of N samples, where N > 1) in the trust region. In some implementations, the data sample selector forms a Latin hypercube. In some implementations, the sample set is iteratively formed to reduce multivariate correlations between the sample values ​​of the design variables 110;

[0070] A thermo-hydraulic engine 132 , which determines various properties such as heat flux distribution, heat transfer, pressure drop, and melting. In some implementations, this uses the finite element method (FEM), finite difference method (FDM), or finite volume method (FVM). In some implementations, this uses an ANSYS model;

[0071] a mechanical stability analysis engine 134 that determines various mechanical properties such as the coefficient of thermal expansion (CTE), CTE mismatch, stress-strain, cycling, and cracking effects;

[0072] A neutronics engine 136 that calculates various properties such as fission criticality, range, moderation, flux, and sustainability. In some implementations, the neutronics engine uses Monte Carlo N-particle simulation (MCNP);

[0073] Materials module 138, which evaluates materials that may be used for various components, such as construction, fuel, cladding, poison, or moderator. Properties evaluated may include dissipative grain structure, material reaction properties, and material mixing state;

[0074] an optimization engine 140 that builds an optimization model 262 based on the samples and the metrics calculated for each sample. In some implementations, the optimization engine 140 includes a machine learning engine that builds the machine learning model. In some implementations, the machine learning engine builds a random forest of decision trees. In some implementations, the machine learning engine builds a neural network. In some implementations, the machine learning engine uses a Gaussian process to build the 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., an instance of genetic programming), and the optimization model 262 includes an evolutionary model; and

[0075] Zero or more databases or data sources 270 (e.g., a first data source 240A and a second data source 240B). In some implementations, the data sources are stored as spreadsheet files, CSV files, XML files, flat files, HDF files, or SQL databases. The databases can be stored in a relational or non-relational format.

[0076] Each of the executable modules, applications, or program sets identified above can be stored in one or more of the aforementioned memory devices and corresponds to an instruction set for performing the functions described above. The modules or programs (i.e., instruction sets) identified above need not be implemented as separate software programs, processes, 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. In addition, the memory 214 can store additional modules or data structures not described above.

[0077] although Figure 2 Computing device 200 is shown, but Figure 2It is intended more as a functional description of various features that may be present rather than as a schematic diagram of the architecture of the implementations described herein. In practice, and as one of ordinary skill in the art will appreciate, items shown separately may be combined, and some items may be separated.

[0078] In some implementations, although not shown, the memory 214 also includes memory for training and executing the above referenced Figure 1B Specifically, in some implementations, the memory 214 also includes the random sampling module 190, the first machine learning model 192, the Gaussian mixture model 196, and the Markov chain Monte Carlo algorithm 198, as well as any associated data.

[0079] Example Method

[0080] According to some implementations, an example algorithm for solving a high-dimensional design optimization problem is shown below for illustration.

[0081] 1. User inputs the constraints for optimization. The user defines the cost function (in our case, it is a multi-physics linear combination of thermal, nuclear, and mechanical aspects of the core design).

[0082] 2. Use random sampling (e.g., in the form of Latin hypercube) to explore the user-defined space.

[0083] 3. Based on the result of step 2, set the binary array of "yes" and "no" physical violations.

[0084] 4. Depending on the sample size, train one of k-nearest neighbors, support vector machines, or feed-forward neural networks.

[0085] a. Use standard methods for cross-validation, early stopping, Monte Carlo hyperparameter selection, etc.

[0086] 5. Train a random forest on the “not” physical violation data, using out-of-bag sampling for cross-validation.

[0087] 6. Develop a random forest approach by using the internal variance of the tree to approximate the variance of the candidate optimal.

[0088] 7. Use step 6 to calculate the upper bound of the nonparametric 95% tolerance interval.

[0089] 8. Use step 7 as a cutoff to generate subspace data regions based on the training data.

[0090] 9. Train Gaussian mixture models on subspace forces around 10+ groups or component Gaussian distributions.

[0091] 10. Use random forests to rank the means of Gaussian mixture models for potentially viable designs.

[0092] 11. For the current best design, use the Metropolis-Hastings method with a custom adaptive covariance matrix to generate a Markov chain (MCMC).

[0093] a. The Markov proposal distribution is a multivariate Gaussian distribution initially centered around the current vest vector or one of the rating vectors determined in step 10.

[0094] b. The posterior distribution used for sampling is the inner forest of the random forest. Therefore, there is always a 50% probability that the median of the best design exists, but it may not exist for the surrounding designs. 0% probability. Therefore, the inner forest is used again to calculate the empirical CDF using Markov chain random walk to find new candidate designs.

[0095] c. Each iteration of the Markov chain is multiplied by the threshold probability of the classification model in step 4 to ensure that the chain remains within the physical space.

[0096] 12. The new candidate designs identified in step 11 are then used as the next generation of random samples. Use these points for the next function call.

[0097] 13. Using the new data from step 12, return to step 2, but use MCMC points instead of hypercubes. Repeat until convergence.

[0098] 14. When using categorical variables, MCMC is modified to exploit the graded multinomial distribution.

[0099] a. When the Markov chain starts, all prior distributions in the multinomial distribution are uniformly distributed.

[0100] b. A support vector machine (SVM) is trained on the accepted proposals of the Markov chain each time MCMC adjusts the covariance matrix of the proposal distribution in step 11. A different SVM is trained for each categorical variable.

[0101] c. Once the SVM is trained, each time the multinomial distribution is called, the SVM's probabilities are used for the prior probabilities, thus creating a hierarchical model that learns from a random walk.

[0102] According to some implementations, some advantages of the disclosed invention include:

[0103] Some implementations search and determine if the algorithm is in a local minimum. Therefore, the algorithm should produce better solutions than conventional techniques.

[0104] Some implementations handle categorical variables.

[0105] Some implementations handle large numbers of dimensions (e.g., 1000s of parameters).

[0106] Some implementations are easily parallelizable for computing clusters.

[0107] The algorithm is faster and more efficient than conventional techniques.

[0108] In some implementations, there is no need to program bounds checking in function calls, because the algorithm adaptively learns the bounds and works around them.

[0109] Figure 3A A flow chart for fast nuclear reactor design using continuous design variables is provided. The process begins (302) by obtaining (304) variables (both design variables 110 and metric variables 112). The user specifies a range for each design variable 110 and a constraint (e.g., a one-sided inequality) for each metric variable 112. Sometimes the design variables 110 are referred to as parameters, and the hypercube of ranges is referred to as the parameter space. The parameter space forms (304) an initial trust region (TR). Sometimes the space for metric variables is referred to as the response space.

[0110] Next, the process generates (306) a sample set from the initial trust region. In some implementations, generating the sample set (e.g., a Latin hypercube) is iterative, and the process iterates (306) over the cube size until the multivariate correlation between the design variables of the sample is less than a predefined constant p max Each iteration increases the size of the sample (eg, Latin Hypercube) and / or replaces at least one sample with a new sample. The initial random process used to construct the sample set (eg, Latin Hypercube) is centered at the mean of the trust region (306).

[0111] The process then runs (308) a thermal-hydraulic (TH) calculation for each point in the sample set (e.g., Latin hypercube). Some implementations use true 2D calculations, which include 2D flow calculations (axial and radial) and 2D heat conduction calculations (axial and radial). However, some implementations are able to produce high-quality results using less than a full 2D calculation. In general, the geometry creates flows that only truly result in relevant axial changes. Therefore, some implementations only solve for 1D axial flow without a radial component. The opposite is true for conduction. The radial component is very important, but the axial component is not as important. Therefore, some implementations only solve for 1D radial conduction. In this scenario, there are axial and radial solutions, but they are not true 2D calculations. Computing only 1D axial flow and only 1D radial conduction is sometimes referred to as "1.5D."

[0112] The output from the thermohydraulic calculations (e.g., axial temperature distribution) is then used (310) as input to the neutronic calculations and mechanical stability analysis. The thermohydraulic process, neutronic process, and mechanical stability analysis calculate various metric variables. In particular, the process extracts (312) the nominal K from the neutronic calculations. eff and its standard error.

[0113] The calculated metric values ​​from the multiple physical processes are then used as input to a cost function that measures (314) the overall quality of the samples with respect to satisfying the constraints. Even if all of the samples fail to provide viable designs for the nuclear reactor, some of the designs are better than others and can be used to iteratively locate better designs. The metrics used by the cost function typically include metrics based on neutronics, thermal hydraulics, mechanical stability, mass, geometry, cost, and other factors. In some implementations, the cost function f is a weighted combination of the difference between the target constraint value for each metric variable and the calculated value for each metric variable, such as ,in w i is the weight, y i is the measured metric, and c i is the target constraint value.

[0114] Using the data from the cost function, the process applies (316) optimization (e.g., machine learning) to build a model. In the example illustrated in the flowchart, the machine learning uses (316) a random forest (RF) of decision trees based on the samples of the design variables and the cost function values. The cost function simplifies analysis by converting data from multiple metrics into a single number (a single dimension rather than multiple dimensions).

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

[0116] , where MSE = mean squared error of the model (e.g. using bootstrap for random forests), Gaussian quantile at the alpha confidence level, the Gaussian quantile at the beta power level, and error = A user-specified constant that indicates how small a difference must be to be important. The MSE specifies the confidence level.

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

[0118] Once the variability and confidence are known, the process shrinks (322) the trust region. In some implementations, the shrinkage is based on a user-provided learning rate multiplier. The shrinkage for each design variable is based on the variability of the cost function for that design variable. The shrinkage creates (322) a new trust region centered on the optimal vector, which is typically not a hypercube. Using the new trust region and the determined sample size, the process generates (324) a new sample set (e.g., a new Latin hypercube) and then iterates the computation (starting from block 308) on the new sample set.

[0119] During this iterative process, the vector with the minimum residual may be at a wall (aka boundary) of the trust region (326). When this happens, the optimal solution may be outside the trust region, so the trust region is expanded (326) beyond the wall (e.g., in a direction perpendicular to the boundary).

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

[0121] Once the process is complete, the data from the final random forest is used to provide the user with analytical data about the design and metric variables. The graphs in Figures 4A-4D illustrate some output examples. In some implementations, the process illustrates (330) the importance of each design variable.

[0122] Figure 3B Pictured Figure 3AHow can the procedure in be extended to include one or more categorical design variables (in addition to continuous numeric design variables). In this case, the sample set (e.g., Latin hypercube) includes (350) an additional dimension for each categorical variable. Sometimes the value range of a categorical variable is called a "level." One dimension is added to the sample set for each categorical variable, regardless of how many different data values ​​there are for the categorical variable. In some implementations, the procedure replaces each categorical variable with a numeric variable and encodes the categorical values ​​as numbers. This is sometimes called "hot encoding." For example, if there is a categorical variable for fluid type and the options are nitrogen, hydrogen, or oxygen, then the three fluid types can be encoded as 1, 2, and 3 (e.g., 01, 10, and 11). The procedure uses existing random forests to control for covariance between the design variables (352).

[0123] Once the covariates are controlled, the process calculates (354) the uncertainty under the best vector (based on a random forest). For this best vector, the process identifies (356) all permutations of the categorical variables. The number of categorical variables is typically small, so the number of permutations is also small. The process then applies (358) a random forest model to each permutation to estimate the probability that the permutation produces a better result than the current best result. For this step, the process essentially constructs new samples that retain all non-categorical variables from the best vector and include each permutation of the categorical variables. Each of these new samples is evaluated according to a machine learning model (e.g., a random forest) to estimate the probability of producing a better result than the current best vector.

[0124] In general, there will not be the same number of sample points corresponding to each categorical value. Therefore, the process scales (360) the standard error by the number of data points in each category to avoid biasing factors that have been downweighted. In some implementations, the probabilities are scaled (362) so that the sum of all probabilities is 1. The process then uses (364) the probabilities as the sampling rate. For example, if a categorical value has a higher probability of leading to a better result, it will be used in the sampling more frequently than other categorical values.

[0125] The process uses the sampling rate calculated at (366) in the generation of the next sample set, which splits the levels of each classification proportionally to the sampling rate. In other words, a sample set set for continuous values ​​is taken and the samples are "binned" based on the levels proportional to the probability values ​​calculated by the random forest. The process is then repeated (368) until it converges, as Figure 3A Described in .

[0126] The calculations for the thermohydraulic engine 132, the mechanical stability analysis engine 134, and the neutronics engine 136 can be performed at different fidelity levels. In some implementations, there are three broad fidelity levels. At the lowest level of fidelity, samples are tested for overall fitness, and many of these samples can be quickly discarded because they do not even come close to meeting the constraints. At the second level of fidelity, the calculations are slower but quite accurate. By limiting the number of sample points used at the second level of fidelity, the overall algorithm can create a design space in a few hours.

[0127] The third level of fidelity is applied outside the scope of the disclosed process. This highest level of fidelity is used to validate designs so that they meet the stringent requirements specified by government regulations. Because the disclosed process produces a very good design space, it is expected that the highest fidelity algorithm (which may take weeks or months to run) will validate designs within the generated design space.

[0128] Design optimization example using machine learning and statistical sampling

[0129] According to some implementations, a method is performed at a computing system. Typically, the computing system includes multiple computers, each having memory and one or more processors. The method can be used to optimize design constraints for manufacturing (e.g., a nuclear reactor core). The method includes receiving user input to specify (i) design optimization constraints for multiple design variables, and (ii) a cost function for evaluating designs of the multiple design variables. The method includes applying random sampling to obtain multiple data samples for the multiple design variables. The method includes training a first machine learning model to generate a subset of the data samples based on the multiple data samples and the design optimization constraints. The method also includes training a Gaussian mixture model to classify the subset of data samples to obtain a Gaussian distribution for a predetermined 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 multiple new data samples based on the candidate designs using a Markov Chain Monte Carlo algorithm. The method also includes repeatedly applying random sampling, training the first machine learning model, training the Gaussian mixture model, training the second machine learning model, and generating multiple new data samples until the design criteria are met. In some implementations, the method includes evaluating the relative importance of each design variable using the first machine learning model, the Gaussian mixture model, and the second machine learning model from the final iteration, and providing the evaluation visually in a report.

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

[0131] 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.

[0132] In some implementations, the first machine learning model is a random forest of decision trees, and training the first machine learning model to generate the data sample subset includes approximating a candidate optimal variance with an internal variance of the decision tree, calculating a non-parametric 95% upper bound on the variance based on the candidate optimal variance, and generating the data sample subset by using a predetermined cutoff threshold and the non-parametric 95% upper bound on the variance.

[0133] In some implementations, the plurality of optimization design constraints include one or more physical constraints, and the method further includes: using a plurality of data samples to train a third machine learning model to predict the probability that the data samples satisfy the one or more physical constraints, and using the third machine learning model to generate the probability that the candidate design satisfies the one or more physical constraints. In such an implementation, generating a new plurality of data samples is further based on the generated probabilities of the candidate design. In some implementations, the method further includes selecting a third machine learning classifier from a list of classifier models based on the number of samples in the plurality of data samples. The list of classifier models includes a k-nearest neighbor classification model, a support vector machine, and a feedforward neural network. Some implementations improve optimization efficiency by excluding sampling areas that may cause topological discontinuities, thereby optimizing computation time and / or avoiding wasted computation.

[0134] 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 the plurality of data samples that satisfy the one or more physical constraints, and training the first machine learning model is further based on the one or more data samples.

[0135] In some implementations, the Markov Chain Monte Carlo algorithm uses the Metropolis-Hastings algorithm, which adapts to the covariance matrix.

[0136] In some implementations, the design variables include a first design variable having discrete categorical values, and the Markov Chain Monte Carlo algorithm uses a hierarchical multinomial distribution.

[0137] Example open-source products that can be used to implement the methods and / or modules mentioned above include Scikit-sklearn, Scipy, Numpy, Pandas, Statsmodels, pyDOE2, Dexpy, and native / convenience packages included in Python / Anaconda installations. Scikit-sklearn provides many data science convenience routines and machine learning algorithms that are used as is for learning parameter spaces. Some implementations use the k-nearest neighbors algorithm, Gaussian mixture models, random forests, support vector classifiers, and multilayer perceptrons (basic feedforward neural networks) along with the convenience routines in Scikit-sklearn. Some implementations use Numpy, a package that enhances Python's matrix / array manipulation capabilities for scientific computing. In some implementations, scientific code written in Python uses Numpy. Some implementations use Pandas, which provides a "data frame" construct that improves data manipulation capabilities for data science. Some implementations use Statsmodels, which provides convenience functions. Some implementations use pyDOE2 for Latin Hypercube generation.

[0138] According to some implementations, a 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 that predicts the runtime or optimization efficiency of each topology based on a sampling of topologies.

[0139] In some implementations, the method includes testing a random sample set (e.g., 50 random samples) or Latin Hypercube samples or points. Based on the sample (e.g., 50 points), the method determines an optimization model or algorithm that is expected to find the global minimum (e.g., no user input is required to test different optimizations).

[0140] Figures 4A-4D Several graphs are provided with output analysis information about the reactor design process.

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

[0142] Figure 4B 4 is a graphical representation showing the correlation between metric variables 112 and a set of total residuals 420. In this example, metric variables 112 are inlet temperature 422, maximum fuel temperature 424, relative pressure drop 426, and effective neutron multiplication factor 428. Each box contains a number that can range between -1 (perfect negative correlation) and +1 (perfect positive correlation). Of course, each metric is perfectly correlated with itself, so boxes representing autocorrelation, such as box 434, have a value of 1. Figure 4B The graph in box 430 indicates that residual 420 is moderately correlated with maximum temperature 424 (0.42 correlation in box 430) and strongly correlated with relative pressure drop 426 (0.95 correlation in box 432). The graph also indicates that inlet temperature 422 is somewhat negatively correlated with maximum temperature 424 (0.64 correlation in box 436). Furthermore, box 438 shows a very small positive correlation of 0.09 between inlet temperature 422 and relative pressure drop 426. The graph also includes a color legend 440 that indicates how the correlation values ​​are displayed in the box. In this example, higher positive or negative correlations are displayed with both larger colors and greater color saturation. This allows the user to quickly see the more important correlations.

[0143] Figure 4C Illustrated are some graphs generated by the thermal hydraulic process. Each graph shows a different variable versus axial distance. These graphs illustrate the behavior of the thermal hydraulic calculations and allow for insights and diagnostics.

[0144] Figure 4D The graph shows the relative importance of each metric variable in the computational cost function (residual). In this example, there are five metric variables, including the effective neutron multiplication factor K. eff450, maximum centerline temperature 452, total mass 454 (i.e., the total mass of everything in the reactor core), pressure drop 456, and inlet temperature 458. In this graph, the relative importance of each metric to the residual calculation is scaled to sum to 1.0, and in some implementations, the user can select which metrics to view. For example, systems typically have metrics for both pressure drop (P) and pressure drop relative to system pressure (dP / P). In the illustrated graph, only pressure is shown. As illustrated in this graph, K eff 450 accounts for 50% of the residual, Maximum Centerline Temperature 452 accounts for 20% of the residual, and each of the other metrics accounts for 10% of the residual. These percentages are aggregated over all samples processed.

[0145] Some implementations also include batch correlation and graphs showing what happened in the previous iteration. This way, while the optimization is running, the user can see what is happening (rather than waiting until the optimization is complete).

[0146] The terms used herein in the description of the present invention are merely for the purpose of describing a particular implementation and are not intended to limit the present invention. As used in the description of the present invention and the appended claims, the singular forms "a", "an" and "the" are also intended to include plural forms, unless the context clearly indicates otherwise. It will also be understood that the terms "and / or" used herein refer to and include any and all possible combinations of one or more associated listed items. It should be further understood that the terms "include" and / or "comprising" when used in this specification specify the presence of stated features, steps, operations, elements and / or parts, but do not exclude the presence or addition of one or more other features, steps, operations, elements, parts and / or combinations thereof.

[0147] For purposes of explanation, the foregoing description has been described with reference to specific implementations. However, the illustrative discussion above is not intended to be exhaustive or to limit the invention to the precise forms disclosed. In light of the above teachings, many modifications and variations are possible. The implementations have been chosen and described in order to best explain the principles of the invention and its practical application, thereby enabling others skilled in the art to best utilize the invention and various implementations with various modifications suitable for the specific use contemplated.

Claims

1. A method for designing a nuclear reactor, comprising: Identify multiple design variables for nuclear reactors; Identifying a plurality of measurement variables of a nuclear reactor, including a plurality of measurement variables measuring thermal hydraulic properties, a plurality of measurement variables measuring neutronics properties, and a plurality of measurement variables measuring stress properties; receiving user input to specify a corresponding value range for each design variable, thereby forming an initial trust region; receiving user input to specify corresponding target values ​​for each metric variable; obtaining N samples of values ​​of the design variables within the initial trust region, the N samples minimizing the multivariate correlation between the design variables, where N is an integer greater than 1; For each of the N samples: performing a thermal-hydraulic analysis process to calculate a plurality of metric variables measuring thermal-hydraulic properties; performing a neutronics analysis process to calculate a plurality of neutronics metrics corresponding to neutronics properties; performing a stress analysis process to calculate a plurality of metric variables corresponding to stress properties; and Applying a cost function to calculate the corresponding aggregated residual of the metric variable compared to the target value of the metric variable; Train the optimization model based on N samples and the corresponding calculated aggregate residuals; Shrinking the trust region centered on the sample with the minimum residual, where the corresponding range of each design variable is shrunk according to the correlation between the corresponding design variable and the estimated residual using the optimization model; Repeating the construction, executing the thermal hydraulic process, executing the neutronics process, executing the stress process, calculating, and training until a sample with a minimum residual does not change within a predetermined number of iterations; Use the optimized model from the final iteration to evaluate the relative importance of each design variable; and Provide assessments visually in reports.

2. The method according to claim 1, wherein The optimization model is a random forest of decision trees.

3. The method of claim 1, wherein the optimization model is a neural network.

4. The method according to claim 1, wherein The thermal-hydraulic analysis process, the neutronics analysis process, and the stress analysis process are simultaneously executed.

5. The method according to claim 1, wherein The thermal-hydraulic analysis process, the neutronics analysis process, and the stress analysis process are executed serially.

6. The method according to claim 1, wherein The thermal hydraulic analysis process, the neutronics analysis process and the stress analysis process are all executed in corresponding different computing subsystems.

7. The method of claim 1 , further comprising during an iteration: Determining that the sample with the smallest residual has a value of the first design variable on the boundary of the trust region; and In response to the determination, the trust region is expanded to include a range of the first design variable that was not previously within the trust region.

8. The method according to claim 1, wherein One of the measured variables is the effective neutron multiplication factor (K eff ).

9. The method according to claim 1, wherein The shrinkage uses a learning rate multiplier specified by user input.

10. The method according to claim 1, wherein The N samples are centered around the mean of the design variable range specified by the user.

11. The method according to claim 1, wherein The design variables include a first design variable having discrete categorical values, and the method further includes: encoding each distinct categorical value as a numeric value within a continuous range to form a first replacement design variable; and The first design variable is replaced with the first replacement design variable.

12. The method of claim 10, further comprising, during each iteration: For the sample with the smallest residual, using the optimization model to estimate the probability that switching to a different classification value will produce a smaller residual according to the cost function; and For the immediately subsequent iterations, a sampling rate of N samples proportional to the estimated probability is used.

13. The method according to claim 11, wherein The first design variable is fluid type.

14. The method according to claim 13, wherein The classification values ​​for fluid type are hydrogen, helium, and nitrogen.

15. A computing system comprising: One or more computers, each computer having a memory and one or more processors, wherein the memory stores one or more programs configured for execution by the one or more processors, the one or more programs including instructions for: Identify multiple design variables for nuclear reactors; Identifying a plurality of measurement variables of a nuclear reactor, including a plurality of measurement variables measuring thermal hydraulic properties, a plurality of measurement variables measuring neutronics properties, and a plurality of measurement variables measuring stress properties; receiving user input to specify a corresponding value range for each design variable, thereby forming an initial trust region; receiving user input to specify corresponding target values ​​for each metric variable; obtaining N samples of values ​​of the design variables within the initial trust region, the N samples minimizing the multivariate correlation between the design variables, where N is an integer greater than 1; For each of the N samples: performing a thermal-hydraulic analysis process to calculate a plurality of metric variables measuring thermal-hydraulic properties; performing a neutronics analysis process to calculate a plurality of neutronics metrics corresponding to neutronics properties; performing a stress analysis process to calculate a plurality of metric variables corresponding to stress properties; and Applying a cost function to calculate the corresponding aggregated residual of the metric variable compared to the target value of the metric variable; Train the optimization model based on N samples and the corresponding calculated aggregate residuals; Shrinking the trust region centered on the sample with the minimum residual, where the corresponding range of each design variable is shrunk according to the correlation between the corresponding design variable and the estimated residual using the optimization model; Repeating the construction, executing the thermal hydraulic process, executing the neutronics process, executing the stress process, calculating, and training until a sample with a minimum residual does not change within a predetermined number of iterations; Use the optimized model from the final iteration to evaluate the relative importance of each design variable; and Provide assessments visually in reports.

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

17. The computing system of claim 15, wherein: The optimization model is a neural network.

18. The computing system of claim 15, wherein: One of the measured variables is the effective neutron multiplication factor (K eff ).

19. The computing system of claim 15, wherein: The design variables include a first design variable having discrete categorical values, and the one or more programs further include instructions for: encoding each distinct categorical value as a numeric value within a continuous range to form a first replacement design variable; and The first design variable is replaced with the first replacement design variable.

20. The computing system of claim 19, further comprising, during each iteration: For the sample with the smallest residual, using the optimization model to estimate the probability that switching to a different classification value will produce a smaller residual according to the cost function; and For the immediately subsequent iterations, a sampling rate of N samples proportional to the estimated probability is used.

21. A method for optimizing manufacturing design constraints, comprising: receiving user input to specify design optimization constraints for a plurality of design variables and specifying a cost function for evaluating designs for the plurality of design variables; (i) applying random 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 Gaussian mixture model to classify a subset of data samples, thereby obtaining a Gaussian distribution of a predetermined number of groups; (iv) training a second machine learning model to rank the Gaussian distributions based on a cost function to obtain candidate designs; (v) generating new multiple data samples based on the candidate designs using a Markov Chain Monte Carlo algorithm; Repeating the steps of (i) applying random sampling, (ii) training a first machine learning model, (iii) training a Gaussian mixture model, (iv) training a second machine learning model, and (v) generating a new plurality of data samples until a design criterion is met; Assess the relative importance of each design variable using the first machine learning model, the Gaussian mixture model, and the second machine learning model from the final iteration; and Provide assessments visually in reports.

22. The method according to claim 21, wherein The cost function comprises a multi-physics linear combination of thermal, nuclear and mechanical aspects of the nuclear reactor core design.

23. The method according to claim 21, wherein 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.

24. The method according to claim 21, wherein 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: Approximate the candidate optimal variance using the internal variance of the decision tree; Calculate a nonparametric 95% upper tolerance level based on the candidate optimal variance; and Data sample subsets were generated by using a predetermined cutoff threshold and a nonparametric 95% upper tolerance level.

25. The method according to claim 21, wherein The design optimization constraints include one or more physical constraints, and the method further comprises: training a third machine learning model using the plurality of data samples to predict a probability that the data samples satisfy the one or more physical constraints; and generating, using a third machine learning model, a probability that the candidate design satisfies the one or more physical constraints; Wherein generating the new plurality of data samples is further based on the generated probabilities of the candidate designs.

26. The method of claim 25, further comprising selecting the third machine learning model from a list of classifier models based on the number of samples in the plurality of data samples, wherein the list of classifier models comprises a k-nearest neighbor classifier model, a support vector machine, and a feedforward neural network.

27. The method according to claim 21, wherein The design optimization constraints include one or more physical constraints, and the method further comprises: selecting one or more data samples from the plurality of data samples that satisfy one or more physical constraints; Wherein training the first machine learning model is further based on the one or more data samples.

28. The method according to claim 21, wherein The Markov Chain Monte Carlo algorithm uses the Metropolis-Hastings method to adjust the covariance matrix.

29. The method according to claim 21, wherein The design variables include a first design variable having discrete categorical values, and the Markov Chain Monte Carlo algorithm uses a hierarchical multinomial distribution.

30. A computing system comprising: One or more computers, each computer having a memory and one or more processors, wherein the memory stores one or more programs configured for execution by the one or more processors, the one or more programs including instructions for: receiving user input to specify design optimization constraints for a plurality of design variables and a cost function for evaluating a design for the plurality of design variables; (i) applying random 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 Gaussian mixture model to classify a subset of data samples, thereby obtaining a Gaussian distribution of a predetermined number of groups; (iv) training a second machine learning model to rank the Gaussian distributions based on a cost function to obtain candidate designs; (v) generating new multiple data samples based on the candidate designs using a Markov Chain Monte Carlo algorithm; Iterative steps, including (i) applying random sampling, (ii) training a first machine learning model, (iii) training a Gaussian mixture model, (iv) training a second machine learning model, and (v) generating new multiple data samples until the design criteria are met; Assess the relative importance of each design variable using the first machine learning model, the Gaussian mixture model, and the second machine learning model from the final iteration; and Provide assessments visually in reports.

Images