WO2025193751A1 - Multi-physics solvers for target platforms - Google Patents

Abstract

In general, the disclosure describes techniques for matching, by a computing system, an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, wherein each of the templates comprises syntax in the intermediate language; and compiling, by the computing system, the one or more templates to generate code for a solver, the code targeted to the target platform.

Description

MULTI-PHYSICS SOLVERS FOR TARGET PLATFORMS

RELATED APPLICATIONS

[0001] This application claims the benefit of U.S. Patent Application No. 63/564,467, filed March 12, 2024, which is incorporated by reference herein in its entirety.

GOVERNMENT RIGHTS

[0002] This invention was made with Government support under Contract Number HR00112090065 awarded by the Defense Advanced Research Projects Agency (DARPA). The Government has certain rights in the invention.

TECHNICAL FIELD

[0003] This disclosure relates to computational modeling.

BACKGROUND

[0004] Computer programming platforms may include coding libraries or other coding tools for scientists to develop solvers for multi-physics problems, where the solvers are built from software code developed for and/or using a coding platform. A solver may include a computer program configured to output solutions to multi-physics problems by modeling complex phenomena defined in a user specification.

SUMMARY

[0005] In general, the disclosure describes techniques for automatically generating code for multi-physics solvers. A computing system, according to the techniques described herein, may interpret complex equations of high-level specifications associated with multi-physics problems into syntax of an intermediate language. The computing system may, for example, interpret a differential equation of a multi-physics simulation description into an interpretation of an equation representing a set of discrete formulas or expressions of the differential equation that are written in a standardized notation specified by notation rules of an intermediate language. The computing system may match the interpretation of an equation to a template that maps syntax associated with the interpretation of the equation to code that conforms to syntax for a particular target platform. The computing system may compile matched templates to generate code for a solver associated with a multi-physics simulation description. For example, the computing system may generate code, conforming to syntax of a target platform and included in templates matched to an interpretation of an equation, that may be compiled as a multi-physics solver.

[0006] The techniques may provide one or more technical advantages that realize at least one practical application. For example, the computing system may automate generating computable code for multi-physics solvers that is physics-compatible from high-level, multiphysics simulation descriptions that include governing equations and conditions for complex phenomena. The computing system generates code for multi-physics solvers compatible with or otherwise targeted to a particular target platform, providing users flexibility to use computational software of their choice. In this way, the computing system may automatically generate and output code, targeted to a target platform (e.g., code that conforms to syntax for a target platform), and for multi-physics solvers, to allow users to rapidly prototype numerical simulations without having to be experts in numerical methods development and/or software development.

[0007] In one example, a method includes matching, by a computing system, an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, wherein each of the templates comprises syntax in the intermediate language; and compiling, by the computing system, the one or more templates to generate code for a solver, the code targeted to the target platform.

[0008] In another example, a computing system may include processing circuitry’ and memory comprising instructions that when executed by the processing circuitry, cause the processing circuitry' to: match an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, w herein each of the templates compnses syntax in the intermediate language; and compile the one or more templates to generate code for a solver, the code targeted to the target platform.

[0009] In another example, computer-readable storage media may include machine-readable instructions for configuring processing circuitry to match an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, w herein each of the templates comprises syntax in the intermediate language; and compile the one or more templates to generate code for a solver, the code targeted to the target platform. [0010] The details of one or more examples of the techniques of this disclosure are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the techniques will be apparent from the description and drawings, and from the claims.

BRIEF DESCRIPTION OF DRAWINGS

[0011] FIG. 1 is a block diagram illustrating an example computing environment for generating solvers, in accordance with techniques of this disclosure.

[0012] FIG. 2 is a block diagram illustrating an example computing system configured to output solvers, in accordance with techniques of this disclosure.

[0013] FIG. 3 is a conceptual diagram illustrating an example computing system configured to generate an example code for a solver, in accordance with techniques of this disclosure. [0014] FIG. 4 is a conceptual diagram illustrating an example computing system configured to generate an example code for solver for an example target platform, in accordance with techniques of this disclosure.

[0015] FIG. 5 is a conceptual diagram illustrating example computing system configured to generate an example code for solver, in accordance with techniques of this disclosure.

[0016] FIG. 6 is a flowchart illustrating an example mode of operation for generating code for a solver targeted to a target platform, in accordance with techniques of this disclosure. [0017] Like reference characters refer to like elements throughout the figures and description.

DETAILED DESCRIPTION

[0018] FIG. 1 is a block diagram illustrating example computing environment 10 for generating solvers, in accordance with techniques of this disclosure. Computing environment 10 includes computing system 100, target platform 156, computing device 150, and network 111. Computing system 100 may be implemented as one or more computing devices, such as desktop computers, compute nodes, servers, data centers, cloud services, etc. In the example of FIG. 1, computing system 100 may communication with computing device 150 and/or target platform 156 via network 111. Network 111 may be a public network (e.g., connected to the Internet via wired (Ethernet) or wireless (Wi-Fi)), a private network (e.g., a local area network (LAN) or wide area network (WAN)), or a combination thereof. Network 111 may also comprise a node or nodes on the Internet of Things (loT). Network 111 may include a network, such as the Internet, another public or private communications network, for instance, broadband, cellular, Wi-Fi, ZigBee, Bluetooth® (or other personal area network - PAN), Near-Field Communication (NFC), ultrawideband, satellite, enterprise, service provider and/or other types of communication networks, or other types of communication channels for transmitting data between computing system 100, target platform 156, and computing device 150.

[0019] Computing device 150 may include any suitable computing device, such as, but not limited to, a laptop, tablet, a mobile computing device, such as a mobile phone (including a smartphone), a server, an loT device, a sensor, a lab instrument, a desktop computer, a wearable computing device, or other computing device. In the example of FIG. 1, computing device 150 may include interface 154 and input specification 152. Interface 154 may include a command line interface, a user interface, an application programming interface, or other interface that may be associated with functionality of computing device 150. For example, interface 154 of FIG. 1 may include an application interface that can be used to request generation of code for one or more solvers, executable on target platform 156, that model input specification 152. Interface 154 may include graphical user interface components, output for display on an external display device, that a user may interact with to upload input specification 152 to computing system 100 via network 111. In some instances, interface 154 may provide input specification 152 to computing system 100 via data obtained from network 111 (e.g., via the Internet).

[0020] Input specification 152 may include data indicating a high-level description of one or more multi-physics phenomena. The high-level description may include a mathematical model or scenario indicated in a high-level description of input specification 152, that may simultaneously model different aspects of a physical system or systems and corresponding interactions thereof, such as symbolic differential equations modeling multi-physics phenomena associated with thermal properties, fluid dynamic properties, electromagnetic properties, statistical properties, or other properties associated with the physical system or systems. The data indicating the high-level description may specify one or more ordinary differential equations, partial differential equations, initial conditions, boundary conditions, or other parameters associated with the one or more multi-physics phenomena that an operator of computing device 150 plans to prototype or otherwise investigate. The data indicating the high-level description may alternatively specify the governing first principles (e.g., conservation laws and symmetries), phenomenological relationships (e.g., constitutive laws or material laws), or other empirical laws at a qualitative level (e.g., using natural language) that are not in symbolic form (e.g., as a symbolic equation). For instance, input specification 152 may include text data indicating differential equations descriptive of the one or more physical phenomena, such as a mass transport equation, a Navier-Stokes equation, an energy transport equation, an equation of state, or any other equation associated with scientific laws or theorems. Instead of the symbolic equation, the input may comprise textual descriptions of the semantics of the equation (e.g., a heat equation can be described by conservation of thermal energy and two constitutive laws governing thermal capacity and thermal conductivity of the materials involved).

[0021] Target platform 156 may include a software-executable environment or software sendee configured to process code developed for target platform 156. For example, target platform 156 may process code written in a coding language (e.g., a coding language used in OpenFOAM, FEniCS, LAPACK, PETSc, etc.) and associated with software libraries, packages, or other toolboxes, available as part of target platform 156 and that may include predefined code and binaries (e.g., predefined classes, functions, etc. usable with the coding language, such as C++ or Python). The code developed for target platform 156 may invoke or otherwise use these libraries, packages, or other toolboxes. Target platform 156 may process code for solvers written in the coding language corresponding to target platform 156 to generate a solver application that provides a solution to a mathematical problem modeling one or more physical phenomena (e.g., multi-physics simulations). In general, target platform 156 may include infrastructure associated with writing, executing, testing, debugging, or otherwise developing code in a coding language corresponding to target platform 156. Target platform 156 may represents, for instance, OpenFOAM, FEniCS, LAPACK, PETSc, or the like. Target platform 156 may include infrastructure executable at various locations. For instance, target platform 156 may be hosted or otherwise managed by a third-party, such as external devices or cloud systems (not shown). In some examples, target platform 156 may execute at computing device 150, computing system 100, and/or any other combination thereof. For instance, target platform 156 may provide, to interface 154 of computing device 154 via network 111, instructions for compiling code for a solver to create a multi-physics solver application.

[0022] Operators of computing device 150, such as scientists, engineers, data analysts, or the like, may manually develop code (e.g., write, debug, etc.) to model multi-physics phenomena described by input specification 152 according to coding conventions (e.g., syntax, classes, functions, etc.) of target platform 156. For example, operators of computing device 150 may spend years to develop code, processable by a target platform 156, to model one or more phenomena of a physical system or systems and associated with interdisciplinary, mathematical properties. Developing code for multi-physics phenomena described by input specification 152 may be a long and computationally expensive process (e.g., developers may consume, over the course of years or decades, large amounts of processing resources, memory resources, power consumption, etc. associated with writing, rewriting, or otherwise developing code that accounts for multiple physical systems described by input specification 152). Additionally or alternatively, operators of computing device 150 may consume computational resources based on the operators’ experience with target platform 156 and/or expertise with physical systems associated with input specification 152; potentially resulting in extensive computational resource consumption in instances where operators are not well- versed in target platform 156 and its supported coding language(s) and/or physical systems described by input specification 152.

[0023] Computing system 100, according to the techniques described herein, may efficiently generate code for a solver to model one or more phenomena described by input specification 152, the code being for processing by a particular target platform (e.g., target platform 156), and without additional user inputs from operators of computing device 150. In this way, computing system 100 may quickly and automatically generate code that may be compiled, using target platform 156, as a model of multi -physics phenomena for operators of computing device 150 to rapidly prototype multi-physics simulations for physical systems associated with input specification 152 without consuming excessive amounts of computational resources, even in instances where operators of computing device 150 are novices or otherwise not well-versed in a schema associated with input specification 152 and/or with capabilities and/or supported language(s) of target platform 156.

[0024] In the example of FIG. 1, computing system 100 includes solver code generator 110, code for solver 138, and templates 132. Computing system 100 may represent one or more computing devices configured to execute solver code generator 110. Solver code generator 110 may include computer-readable instructions to generate, based in part on input specification 152, code for solvers that is targeted to a particular platform, such as target platform 156. Solver code generator 110 may represent a software application that may be integrated in development tools for developing multi-physics simulations or other numerical models. For example, solver code generator 110 may include data for a software application that computing device 150 may send and receive data associated with generating code for solvers via interface 154 and/or network 111, according to the techniques described herein. In some instances, solver code generator 110 may include a software application that directly communicates with target platform 156 and/or computing device 150.

[0025] Solver code generator 110, in the example of FIG. 1, may include data representing intermediate language 134. Intermediate language 134 may include data for interpreting an equation into syntax indicating discrete formulas representing the equation (e.g., interpret a differential equation of input specification 152 into syntax indicating multiple discrete equations representing portions of the differential equation). For example, intermediate language 134 may include notation rules for generating syntax from a differential equation descriptive of one or more physical phenomena (e.g., rules for generating syntax for an equation of input specification 152 that indicates physical phenomena associated with physical systems of input specification 152). In some examples, intermediate language 134 may include a notation rule that solver code generator 110 may implement to translate a set of mathematical expressions (e.g., interpolation operators, sum operators, min operators, average operators, etc.) from equations of input specification 152 into a platform-neutral syntax by substituting the set of mathematical expressions with pseudo-code indicating the set of mathematical expressions in a standardized notation (e.g., substitute mathematical formulas of a differential equation with syntax of intermediate language 134 associated with standardized pseudo-code for multi-physics simulations). In some instances, intermediate language 134 may include configurable syntax notation rules for calculus operators that occur in physics-based equations that may influence physical systems associated with input specification 152.

[0026] Templates 132 may include discrete representations of expressions or formulas that facilitate generation of code for solvers to be executed in a particular target platform. A discrete representation of a formula may include one or more mathematical formulas or operators that represent a portion of the equation. In some examples, a discrete representation of formulas for a differential equation may include a set of mathematical formulas that represent one or more discrete equations associated with a portion of the differential equation (e.g., a set of mathematical operators representing a discrete formula of a portion of a partial differential equation). In the example of FIG. 1, templates 132 may include discrete representations of formulas as formulas 162A-162N (collectively referred to herein as “formulas 162”) mapped to code objects 164A-164N (collectively referred to herein as “code objects 164”). Formulas 162 may include data for syntax of mathematical formulas or operators that conforms to notation rules of intermediate language 134. For example, formula 162A may include platform-neutral syntax for a first mathematical formula (e.g., an interpolation operator) written according to intermediate language 134, formula 162B may include platform-neutral syntax for a second mathematical formula (e.g., a divergence operator) written according to intermediate language 134, and so on.

[0027] Templates 132 may include mappings of each of formulas 162 to one or more code objects 164A-164N that may be used to generate code for a solver particular to a target platform. A template of templates 132 may include a mapping of a formula of formulas 1 2 to a corresponding code object of code objects 164. Code objects 164 may include data representing mathematical formulas written in a language associated with various target platforms. For example, code object 164A may include code representing a first mathematical formula (e.g., an interpolation operator) written in a language associated with a first target platform (e.g., C++ associated with OpenFOAM), code object 164B may include code representing the first mathematical formula written in a language associated with a second target platform (e.g., C or Fortran packages associated with LAPACK), and code object 164N may include code representing a second mathematical formula (e.g., sum operator) written in the language associated with the first target platform (e.g., C++ libraries associated with OpenFOAM). Thus, each formula of formulas 162 maps to one or more code objects 164 that implement the formula for respective target platforms. By mapping platform-neutral formulas 162 (e.g., representing operators or formulas written according to intermediate language 134) to platform-specific code objects 164, solver code generator 110 may process input description 152 into executable code for a target platform, as described in further detail below;

[0028] In some examples, solver code generator 110 may store default templates of templates 132 including mappings of formulas 162 to platform-specific code objects 164 for standard mathematical operators or formulas. In some instances, solver code generator 110 may obtain (e.g., from computing device 150 via user inputs associated with GUI 154) configuration information defining a mapping of a mathematical formula to a platformspecific code object. For example, solver code generator 110 may update templates 132 to include a template that maps a custom formula (e.g., that solver code generator 110 may have interpreted according to intermediate language 134) to one or more code objects including code representing mathematical operators that implement the custom formula written in a language associated with respective target platforms. [0029] In accordance with the techniques described herein, computing system 100 may generate code for solvers, the code being compatible with particular target platforms. For example, computing system 100, or more specifically solver code generator 110, may process input specification 152 using notation rules of intermediate language 134 to create an interpretation of an equation of input specification 152 in intermediate language 134. Solver code generator 110 may create an interpretation of an equation as a data object (e.g., string, encoding, vector, etc.) including standardized syntax defined according to intermediate language 134 that indicates mathematical formulas associated with the equation. Solver code generator 110 may then match an interpretation of an equation (e.g., included in input specification 152) to one or more templates of templates 132. For example, solver code generator 110 may match one or more patterns associated with an interpretation of an equation to one or more templates of templates 132 mapped to formulas 162 that correspond to the one or more patterns. Solver code generator 110 may generate code for solver 138, targeted to a target platform (e.g., target platform 156), for a solver based on one or more templates - matched to an interpretation of an equation included in an input specification associated with the solver. For instance, solver code generator 110 may generate code for solver 138, the code for a target platform, by converting or otherwise translating intermediate syntax language of one or more templates 132 to code for the target platform (e.g., based on code objects 164 mapped to one or more of formulas 162 determined by solver code generator 110 to correspond to patterns identified in an interpretation of an equation in the input specification). In some examples, computing system 100 may execute target platform 156 to process code for solver 138 to output a solution to a multi -physics problem associated with input specification 152. This may include compiling the code to generate a binary, interpreting code for solver 138 with target platform 156 to run code for solver 138, or some other like operations to process code for solver 138 to implement code for solver 138 for input specification 152.

[0030] In general, solver code generator 110 may generate code for solver 138 to be targeted to target platform 156. Solver code generator 110 may generate code for solver 138 to be targeted to target platform 156 by including code written in a coding language associated with target platform 156 that may be executed to implement equations of a multi-physics problem associated with input specification 152 by invoking libraries or other software-based tools of target platform 156, where the software-based tools may include detailed implementations for solving various equations represented in code for solver 138. [0031] In an example operation, computing device 150 may obtain input specification 152. For example, computing device 150 may obtain input specification 152 and an indication to generate code for a solver for input specification 152 via user inputs associated with interface 154. In some examples, computing device 150 may obtain an indication of target platform 156, i.e., to generate code for a solver for input specification 152 according to target platform 156. Computing device 150 may send, via network 111, input specification 152 and an indication to generate code for a solver to computing system 100.

[0032] Computing system 100, or more specifically solver code generator 110, may generate an interpretation of an equation associated with input specification 152. For example, solver code generator 110 may process computational recipes associated with physical systems indicated in input specification 152 to interpret raw data of input specification 152 according to notation rules specified in intermediate language 134. Solver code generator 110 may, for instance, identify equations associated with physical systems indicated in input specification 152 using natural language processing methods. Solver code generator 110 may convert identified equations indicated in input specification 152 into an interpretation of the equation using notation rules specified in intermediate language 134. For example, solver code generator 110 may interpret raw data for an equation (e.g., text data indicating the equation) associated with input specification 152 as a data object including standardized syntax, written in intermediate language 134, that indicates one or more mathematical operations associated with the equation. In some instances, solver code generator 110 may process input specification 152 into intermediate language 134 using templates that map information associated with input specifications to notation of intermediate language 134.

[0033] Solver code generator 110 may match an interpretation, written according to intermediate language 134, of an equation to one or more templates of templates 132. For example, solver code generator 110 may identify patterns of mathematical operations included in an interpretation of an equation. Solver code generator 110 may determine one or more formulas 162 of templates 132 that correspond to identified patterns of mathematical operations. For example, solver code generator 110 may determine similarity scores between an identified pattern and formulas 162, and determine one or more formulas 162 based on respective similarity scores satisfying a similarity threshold. Solver code generator 110 may match an interpretation of an equation to one or more templates of templates 132 by matching the interpretation to mappings of determined one or more formulas 162A to code objects 164 corresponding to a target platform requested by a user (e.g., target platform 156). For example, solver code generator 110 may match, based on determined similarities, a pattern for an interpretation of an equation to a first template of formula 162A mapped to code object 164 A that includes code particular to target platform 156 and to a second template of formula 162N mapped to code object 164N that include code particular to target platform 156.

[0034] Solver code generator 110 may compile one or more templates matched to an interpretation of an equation to generate code for a solver. Solver code generator 110 may compile one or more templates matched to an interpretation of an equation based on code objects 164 that are included in the one or more templates to generate code for a solver. Solver code generator 110 may generate code to include code objects 164 of one or more templates according to a structure indicated in an interpretation of an equation. For example, solver code generator 110 may generate code for a solver to include code objects 164 of one or more templates by substituting identified patterns in an interpretation of an equation with corresponding code objects 164 of matched templates. Solver code generator 110 may generate code for a solver to include code objects 164 included in one or more templates matched to an interpretation of an equation. In general, solver code generator 110 may generate code for a solver indicated in input specification 152 that includes the code capturing numerical schemes of an equation indicated in input specification 152. Solver code generator 110 may output code for a solver to computing device 150. Computing device 150 may rapidly prototy pe ideas associated with input specification 152 based on processing the code for the solver using target platform 156. In some examples, solver code generator 110 may send code for a solver to target platform 156 to process the code and create the solver that may be output to computing device 150 via network 111.

[0035] In some examples, solver code generator 110 may initialize variables of a solver generated for input specification 152. For example, solver code generator 110 may identify a value of input specification 152 associated with an equation that is interpreted according to intermediate language 134. Solver code generator 110 may initialize a solver associated with an interpretation of the equation by, for example, setting, in code for the solver, one or more variables of the solver based on the value indicated in input specification 152. For instance, solver code generator 110 may initialize a pressure and/or temperature variables associated with a solver, by inputting corresponding pressure and/or temperature values indicated in input specification 152 as variables in code generated for the solver. In this way, target platform 156 may execute code for a solver for input specification 152 without manual variable inputs; potentially resulting in reduced errors associated with novice operators of computing device 150 manually inputting variables to the solver.

[0036] The techniques may provide one or more technical advantages that realize at least one practical application. For example, computing system 100 may automatically and efficiently generate code for solvers for multi-physics simulations from high-level problem specifications that may include governing equations and initial or boundary conditions. In this way, computing system 100 may generate and output code for solvers to facilitate rapid prototyping of numerical simulations indicated in the input specifications without users having to be experts in numerical methods development. Computing system 100 may automatically generate code for solvers as computable code, particular to a target platform, that is physics-compatible (e.g., accounts for scientific concepts across multiple disciplines such as thermal physics, fluid dynamics, etc.), such that users may rapidly prototype numerical simulations including complex multi-physics problems associated with urgent decision making (e.g., pandemics, infrastructure, threats, etc.). By compiling matched templates to quickly and automatically generate code for solvers, computing system 100 may reduce computational resources associated with generating simulation results with computable code of solvers. In this way, computing system improves the technical field of computational modeling (e.g., multi-physics simulations) by automatically and efficiently generating code for solvers based on high-level model descriptions.

[0037] FIG. 2 is a block diagram illustrating example computing system 200 configured to output solvers, in accordance with techniques of this disclosure. Computing system 200, solver code generator 210, intermediate language 234, one or more platforms 256, and templates 232 of FIG. 2 may be example or alternative implementations of computing system 100, solver code generator 110, intermediate language 134, target platform 156, and templates 132 of FIG. 1, respectively.

[0038] Computing system 200, in the example of FIG. 2, may include processing circuitry 202, memory⁷ 204, one or more input devices 206, one or more communication (“COMM”) units 207, one or more output devices 208, input data 244, solver code generator 210, intermediate language 234, templates 232, platforms 256, and output data 248.

[0039] One or more input devices 206 of computing system 200 may generate, receive, or process input. Such input may include input from a keyboard, pointing device, voice responsive system, video camera, biometric detection or response system, button, sensor, mobile device, control pad, microphone, presence-sensitive screen, network, or any other type of device for detecting input from a human or machine.

[0040] One or more output devices 208 may generate, transmit, or process output. Examples of output are tactile, audio, visual, and/or video output. Output devices 208 may include a display, sound card, video graphics adapter card, speaker, presence-sensitive screen, one or more USB interfaces, video and/or audio output interfaces, or any other type of device capable of generating tactile, audio, video, or other output. Output devices 208 may include a display device, which may function as an output device using technologies including liquid crystal displays (LCD), quantum dot display, dot matrix displays, light emitting diode (LED) displays, organic light-emitting diode (OLED) display s, cathode ray tube (CRT) displays, e- ink, or monochrome, color, or any other type of display capable of generating tactile, audio, and/or visual output. In some examples, computing system 200 may include a presencesensitive display that may serv e as a user interface device that operates both as one or more input devices 206 and one or more output devices 208.

[0041] One or more communication units 207 of computing system 200 may communicate with devices external to computing system 200 (or among separate computing devices of computing system 200) by transmitting and/or receiving data, and may operate, in some respects, as both an input device and an output device. In some examples, communication units 207 may communicate with other devices over a network. In other examples, communication units 207 may send and/or receive radio signals on a radio network such as a cellular radio network. Examples of communication units 207 may include a network interface card (e.g., such as an Ethernet card), an optical transceiver, a radio frequency transceiver, a GPS receiver, or any other type of device that can send and/or receive information. Other examples of communication units 207 may include Bluetooth®, GPS, 3G, 4G, and Wi-Fi® radios found in mobile devices as well as Universal Serial Bus (USB) controllers and the like.

[0042] Processing circuitry' 202 and memory' 204 may be configured to execute components of computing system 200 (e.g., execute solver code generator 210 to generate a solver for an input specification of input data 244 to execute on a target platform of platforms 256). Memory 204 may store information for processing during operation of solver code generator 210 and platforms 256. In some examples, memory' 204 may include temporary memories, meaning that a primary purpose of the one or more storage devices is not long-term storage. Memory 204 may be configured for short-term storage of information as volatile memory and therefore not retain stored contents if deactivated. Examples of volatile memories include random access memories (RAM), dynamic random access memories (DRAM), static random access memories (SRAM), and other forms of volatile memories known in the art. Memory 204, in some examples, also include one or more computer-readable storage media. Memory 204 may be configured to store larger amounts of information than volatile mcmorv Memory 204 may further be configured for long-term storage of information as non-volatile memory space and retain information after activate/off cycles. Examples of non-volatile memories include magnetic hard disks, optical discs, floppy disks, Flash memories, or forms of electrically programmable memories (EPROM) or electrically erasable and programmable (EEPROM) memories. Memory 204 may store program instructions and/or data associated with one or more of the modules (e.g., solver code generator 210, platforms 256, etc.) described in accordance with one or more aspects of this disclosure.

[0043] Processing circuitry 202 and memory 204 may provide an operating environment or platform for solver code generator 210, intermediate language 234, templates 232, and platforms 256, which may be implemented as software, but may in some examples include any combination of hardware, firmware, and software. Processing circuitry 202 may execute instructions and memory 204 may store instructions and/or data of one or more modules. The combination of processing circuitry 202 and memory 204 may retrieve, store, and/or execute the instructions and/or data of one or more applications, modules, or software. Processing circuitry 202 and memory 204 may also be operably coupled to one or more other software and/or hardware components, including, but not limited to, one or more of the components illustrated in FIG. 2. Processing circuitry 202, input devices 206, communication units 207, output devices 208, and memory 204 may each be distributed over one or more computing devices.

[0044] Platforms 256 may include data associated with one or more software-executable environments or software services configured to execute code for solvers generated by solver code generator 210. For example, platforms 256 may include data for processing code written in various coding languages associated with multi-physics simulations. Processing the code may include compiling the code to generate a solver application, executing or interpreting the code to run a solver application, or otherwise processing the code to implement a solver. Platforms 256 may include a set of libraries, coding conventions, toolboxes, or other software-based information of various coding languages. Each of platforms 256 may be configured to compile code for a solver by importing software-based information and using a compiler associated with respective coding languages (e.g., C compiler, C++ compiler, Fortran compiler, etc.). In some instances, platforms 256 may compile code for a solver using a generic or third-party compiler.

[0045] Solver code generator 210, in the example of FIG. 2, may include interpreter 212, compiler 214, equation modifier 216, parameter conditions module 218, template generator 222, and benchmark module 224. Interpreter 212 may include computer-readable instructions for generating an interpretation of an equation for an input specification (e.g., input specification 152) included in input data 244. Compiler 214 may include computer- readable instructions for matching interpretations of equations to templates 232 and/or generating code for solvers (e.g., output as output data 248) based on matched templates. [0046] Equation modifier 216 of solver code generator 210 may modify symbolic equations. Equation modifier 216 may modify symbolic equations to assist interpreter 212 in creating an interpretation of an equation that may include various versions of symbolic equations. For example, equation modifier 216 may pre-process data associated with symbolic operators or formulas for equations to modify’ how interpreter 212 interprets an input specification that may include the symbolic operators or formulas.

[0047] Parameter conditions module 218 of solver code generator 210 may determine parameter conditions to improve accuracy of solvers output by solver code generator 210. For example, parameter conditions module 218 may process an interpretation of an equation to identify a structure associated with the equation. Parameter conditions module 218 may determine parameter conditions (e.g., conditions of a multi-physics simulation associated with boundedness, stability, and/or accuracy of physical systems targeted by the multiphysics simulation) according to an identified structure associated with an interpretation of an equation. For instance, parameter conditions module 218 may determine stability, boundedness, accuracy, or the like of discrete equations indicated in an interpretation of an equation to supplement a solver to include parameter conditions that improve the scientific accuracy of solvers generated by solver code generator 210.

[0048] Template generator 222 of solver code generator 210 may generate templates 232. Template generator 222 may generate templates 232 according to configuration information for functions and code objects that may be included in input data 244. Template generator 222 may generate templates 232 to include discrete representations of differential equations that are neutral between various mathematical operators and facilitates disambiguation between various discretization options available to a user. For example, template generator 222 may include templates 232 to include mappings of functions, written according to intermediate language 234, to code objects representing corresponding functions and written in coding languages associated with platforms 256 to discretely represent discrete equations or functions of differential equations of an input specification in a standardized manner. Template generator 222 may modify a template to allows users to override default heuristics of functions associated with the template on a variable-by-variable basis. In general, template generator 222 may create templates 232 to facilitate disambiguation between various discretization options available to a user.

[0049] An example of a formula of a template generated by template generator 222 that expands a temperature gradient formula, V7(c). in platform-neutral syntax associated with intermediate language 234 may be as follows: sum(in(fy d(dual(c))), T( centroid (/))normal(/) orientation (f, dual (c))) size(dual(c)) where V7’(c) is implemented on a grid by taking the value of T at the centroid of each face, multiplying it by the normal of the face to get a vector, summing all of the vectors to get the overall gradient, and then dividing by the volume to get the gradient at the cell center.

[0050] An example of a formula of a template generated by template generator 222 that expands a divergence formula, V • U(c), in platform-neutral syntax associated with intermediate language 234 may be as follows: sum(in(fy d(dual(c))), (U(centroid(/)) • normal ( ) orientation (/, dual(c)))) size(dual(c)) where template sums over face terms like the gradient template, but the face terms are the dot product of the oriented normal of the face and the divergence variable at the face instead of their multiplication. Finally, the sum is divided by the size of the volume that contains c in order the get the divergence at the center of the volume.

[0051] Template generator 222 may generate templates 232 to include grid geometry' elements. Template generator 222 may generate templates 232 to include grid geometry elements according to notation of intermediate language 234 and using typed variables indicating a geometric space associated with intermediate language 234. For example, template generator 222 may generate templates 232 to include mappings of functions, written in intermediate language 234, to code objects, written in one or more coding languages associated with platforms 256, as grid geometry elements including the mappings and variables associated with volume, volume centers, volume faces, and lines between two volume centers that indicate a position in a geometric space of intermediate language 234. In some examples, template generator 222 may generate templates to include grid time elements that represent grid geometry elements as a sequence of discrete instances (e.g., including a time variable to grid geometry elements such that t +1 represents the next time instant, and t - 1 represents the previous time instant).

[0052] In general notation of expressions or formulas represented in templates 232 corresponds to notation rules of intermediate language 234. Template notation of templates 232 may be based on pseudo-code associated with known coding languages, such as SyrnPy, by, for example, using functions of the coding languages. For instance, +, *, -, V X, V, V ■, and (dot product) may be implemented using pseudo-code associated with SymPy functions. Additional pseudo-code may be developed and implemented to represent other functions that may be undefined in known coding languages.

[0053] Template notation of templates 232 may support geometric functions associated with concepts of dual cell complexes from algebraic topology to provide flexibility in defining templates 232. For instance, template notation of templates 232 may support the following geometric functions:

• boundaries^) - the end points of a line (printed as £?(/))

• boundaries(v) - the faces of a volume (printed as ( ))

• centroid(/) - the centroid of a face

• dual(c) - the volume containing a center

• dual(/) - the line betw een two centers that passes through a face

• dual(Z) - the face that a line passes through

• dual(v) - the center of a volume

• normal(/) - the normal of a face

• normal)/) - the line as a vector

• orientation(c, I) - the orientation of an end point relative to its line ( A l )

• on entail on (/. v) - the orientation of a face relative to its volume ( A l )

• size(/) - the area of a face

• size(/) - the length of a line

• size(v) - the volume of a volume

[0054] Templates 232 may include discrete functions associated with physical variables and constants. For example, functions of templates 232 may include physical variables that take two arguments: (1) the geometric element that physical variables apply to; and (2) the time instant that the physical variables apply to. For instance, T (c, t) may represent temperature at the given center variable and the given time variable. Likewise, T (centroid(f), t + 1) may represent temperature at the centroid of the given face variable and the next time instant after the given time variable. By convention, if the time argument is not given (e.g., T (c)), then it is implicitly assumed to be t. Physical variables can also have properties, such as their value type (i.e., scalar, vector, or tensor), their meaning (e.g., “temperature”), their range (e.g., “positive”), and how they are initialized. Physical constants are like physical variables except for the fact that they do not take a geometric argument or a time argument.

[0055] In some examples, template generator 222 may combine templates of templates 232. For example, template generator 222 may combine a first template associated with a first mathematical formula with a second template associated with a second mathematical formula to create a third template associated with the first formula applied to the second formula, for example. For instance, template generator 222 may create a new template for a formula that applies a first formula associated with a first template to a second formula associated with a second template (e.g. V ■ VT (c)), by first expanding the outer formula. In other words, template generator 222 may create a template associated with a Laplacian formula of V ■ VT (c) by, for example, first expanding a first formula associated with a first template as sum(in(/, d(dual(c))), (normal( ) orientation (J, dual(c))) • VT(centroid(/))) size(dual(c))

[0056] Next, template generator 222 may expand, using interpolation, a second formula associated with a second template of VT (centroid(f)) to substituted in the expansion of the first formula associated with the first template. Template generator 222 thus produces the template for the Laplacian formula as sum(in( , d(dual(c))),

(normal(/')orientation(/, dual(c))) • (normal (dual ( )) sum(in(c, d(dual(/))), T(c) orientation (c, dual( ))) /size(dual(/))²))/size(dual(c)).

[0057] In some examples, templates 232 may include additional information associated with grid geometries associated with intermediate language 234. In other words, templates 232 may be populated with data indicating how many boundaries a geometric element may have or how the boundaries are related to each other. A formula of a template that includes information specialized to the geometry for V7’(c) may be as follows:

[0058] Compiler 214 may compile an equation of an input specification to a computational platform of platforms 256. For example, compiler 214 may expand terms of an equation (e.g., a differential equation) of an input specification using templates 232. Compiler 214 may determine one or more geometric elements each variable of the equation applies to. Compiler 214 may, by default, determine that variables are defined at centers, because most platforms 256 (e.g., OpenFOAM) use collocated grids where variables are stored at cell centers. For instance, compiler 214 may determine that variables of a heat equation of V ■ VT = 0 is defined at a geometric center associated with a grid of templates 232 and implemented as V ■ VT(c) = 0.

[0059] Compiler 214 may compile an equal to platform-specific code for solver using templates 232. For example, compiler 214 may first expand an equation (e.g., differential equation) using templates 232, then translate the expanded equation into platform-specific source code written in a coding language associated with a target platform (e.g., OpenFOAM- readable source code written in C). A target platform of platforms 256 may compile source code for a solver and use the results to simulate multi-physics phenomena associated with a physical system of an input specification. Compiler 214 may create code for a solver to store problem geometry, such as, compiler and C code agnostically generated based on a geometry' associated with intermediate language 234.

[0060] Compiler 214 may match templates 232 to an interpretation of an equation (e.g., an expansion of an equation into an interpretation of an equation written in intermediate language 234) using specialized code associated identifying patterns in the interpretation of the equation. For example, compiler 214 may identify a pattern for an interpretation of an interpolated equation as follows: sum(in(c, d(dual( ))), ? arg 1/2) interpolation (? argl, linear) where patterns are applied to templates bottom up. If a left part of a template matches, then it is replaced by the right part. Any symbol that begins with a question mark may be a variable that can match an expression (e.g., a platform-specific code based expression).

[0061] Compiler 214 may translate template variables (e.g., T(c)) into platform-specific code variables (e.g., C variables). Compiler 214 may give platform-specific code variable the same name as template variables mapped to the platform-specific code variables in templates 232. Compiler 214 may introduce variables to represent internal computations to improve clarity'. In general, compiler 214 may name variables in a way that is easily understood by a user.

[0062] After compiler 214 translates templates 232 into one or more platform-specific code expressions using patterns or specialized code, compiler 214 may generate platform-specific code (e.g., C code) from the one or more platform-specific code expressions (e.g., OpenFOAM expressions). For instance, compiler 214 may determine an interpretation of an equation of “interpolation(T, linear)’⁷ is matched to a template that maps the interpretation of the equation to a platform-specific code expression of “fvc::interpolate(T)” with an entry in a fvSchemes case file saying that the interpolation should be linear. Compiler 214 may compile the matched template to generate code for the equation as follows: interpolationschemes

{ interpol ate(T) linear;

}

[0063] Compiler 214 may initialize variables in a header file associated with code for a solver. Compiler 214 may read in values from an input specification and initialize or otherwise set variable properties of code for a solver (e.g., variable properties of “T”) in the header file associated with the code. For example, compiler 214 may generate a header file initializing a temperature variable as follows:

Info« "Initializing temperature T\n" « endl; volScalarField T ( lOobject (

"T", runTime. timeN ame(), mesh, lOobject: :NO_READ, lOobj ect: : AUTO WRITE ), mesh

);

[0064] Compiler 214 may set an initialization property to an expression, such as p / (Rp).

Compiler 214 may generate code to initialize variables with this value as follows:

Info« "Initializing temperature T\n" « endl; volScalarField T ( lOobject ( It Jt ! runTime.timeNameQ, mesh, lOobject: :NO_READ, lOobj ect: : AUTO_WRITE ), mesh

);

T = p / (R * rho + dimensionedScalarf'eps", R.dimensionsO * rho.dimensions(), le-10));

T.correctBoundaryConditions();

[0065] If an expression includes a divisor that is known to be positive because of user declarations (such as R * rho above), compiler 214 may automatically add a small value "‘epsilon’⁷ to the divisor in order to avoid division-by-zero errors.

[0066] Compiler 214 may automatically generate code to correct boundary conditions. For example, if variable T is set to an expression, compiler 214 may generate “T.correctBoundaryConditions()” immediately after initializing or setting the variable. If the variable is solved for, compiler 214 may generate boundary correction code for the “boundary Correction” property if it exists, and otherwise for the initialized property if it is in an expression. For instance, if the initialized property for rhoU is U * rho, compiler 214 may generate the boundary correction code as follows: rhoU.boundaryFieldRef() == U.boundaryField() * rho.boundaryField():

[0067] Compiler 214 may support temporal integrations built for platforms 256 (e.g., OpenFOAM). Compiler 214 may allow’ a user to specify a time scheme to generate code for a solver according to the time scheme. For instance, if a user specifies a time scheme as a built-in explicit time scheme, compiler 214 may use “fvc::” calls (explicit) rather than “fvm: :” calls (implicit) for spatial operators or formulas. If the user specifies a built-in implicit time scheme, compiler 214 may generate “fvm::” calls for spatial operators on variables that are being solved for and “fvc: :” otherwise. If the user specifies a non-built-in scheme (e.g., Runge-Kutta method, RK4), compiler 214 may explicitly generate code to iterate over variation stages of a Runge- Kutta algorithm. [0068] Compiler 214 may determine a value of a variable at a centroid of a face associated with grid elements of a template. For example, compiler 214 may determine a value of a variable at a centroid of a face (e.g., T (centroid(f)) by, for example, interpolating values of the variables at the center of neighboring volumes. Compiler 214 may determine a uniform grid as: sum(in(c, d(dual ( ))), T(c)/2)

[0069] The dual of is the line between the centers of the neighboring volumes of f denoted by /dual (/’))). In other words, compiler 214 may perform template interpolation by interpolating variables (e.g., T), at the face center by, for example, computing an average of values at the centers of volumes neighboring grid elements of the template.

[0070] Benchmark module 224 of solver code generator 210 may update solvers generated by compiler 214. For example, benchmark module 224 may update a solver based on numerical parameters, geometry and mesh information, or other information associated with benchmarking solvers for multi-physics simulations. Benchmark module 224 may determine information to improve accuracy of solvers based on benchmark examples that may include previously generated solvers annotated with performance indications of the previously generated solvers.

[0071] FIG. 3 is a conceptual diagram illustrating example computing system 300 configured to generate example code for solver 338, in accordance with techniques of this disclosure. Computing system 300 and benchmark module 324 of FIG. 3 may be an alternative or example implementation of computing system 200 and benchmark module 224 of FIG. 2, respectively.

[0072] Computing system 300 may process a high-level description of a multi-physics problem by identifying formulas 326 (e.g., mathematical operators associated with representing aspects of multi-physics phenomena) indicated in the high-level description. Computing system 300 may identify expressions or formulas of a high-level description such as mathematical operators of discrete equations such as exterior derivatives, interpolation, or the like. Computing system 300 may break down formulas 326 of a high-level description into interpretations 328 that each include syntax in an intermediate language (372). For example, computing system 300 may generate syntax, written in an intermediate language, for mathematical formula 326C to create interpretations 328C and 328D that represent equations associated with formula 326C. [0073] Computing system 300 may group interpretations 328 to create code for solver 338 (374). Code for solver 338 may include a source code file, written in a coding language associated with a target platform, that is executable to create a solver that may simulate or otherwise model multi-physics phenomena of a physical system or other mathematical based system. Computing system 300 may group or otherwise translate interpretations 328 into code for solver 338 using templates that map interpretations 328 to code included in code for solver 338 (e.g., a template that maps interpretations 328B, 328C, 328G, and 328H to code for solver 338B). In this way, computing system 300 may automatically represent, in a standardized manner as interpretations 328, discrete equations for complex combinations of formulas 326 associated with multi-physics simulations that can be converted into code for solver 338 that is particular to a target platform. In some examples, computing system 300 may provide interpretations 328 to benchmark module 324 to perform robustness analysis (e.g., stability, boundedness, etc.) based on breaking down formulas 326 into interpretations 328 (376).

[0074] FIG. 4 is a conceptual diagram illustrating example computing system 400 configured to generate example code for solver 438 for example target platform 456, in accordance with techniques of this disclosure. Computing system 400, input specification 452, intermediate language 434, templates 432, code for solver 438, and target platform 456 of FIG. 4 may be example or alternative implementations of computing system 100, input specification 152, intermediate language 134, templates 132, code for solver 138, and target platform 156 of FIG. 1, respectively. Additionally or alternatively, computing system 400, interpreter 412, compiler 414, equation modifier 416, parameter conditions module 418, benchmark module 424, intermediate language 434, and templates 432 of FIG. 4 may be example or alternative implementations of computing system 200, interpreter 212, compiler 214, equation modifier 216, parameter conditions module 218, benchmark module 224, intermediate language 234, and templates 232 of FIG. 2 respectively.

[0075] Interpreter 412 may obtain input specification 452 (480). Interpreter 412 may determine an interpretation of an equation associated with input specification 452 based on notation rules indicated in intermediate language 434 (481). Interpreter 412 may provide an interpretation of an equation to compiler 414 (482). Compiler 414 may match an interpretation of an equation to a template of templates 432 (483). Compiler 414 may generate code for solver 438 by compiling templates matched to an interpretation of an equation (490). Computing system 400 may output code for solver 438 to be executed on target platform 456 (492).

[0076] In some examples, target platform 456 may output a solution to a multi-physics simulation problem associated with code for solver 438 to equation modifier 416 (494). Equation modifier 416 may modify symbolic equations of an interpretation of an equation based on the solution and notation rules of intermediate language 434 (494) (495). Equation modifier 416 may output modified symbolic equations to interpreter 412 to potentially create code for a new solver based on the modified symbolic equations (496).

[0077] In some examples, interpreter 412 may provide an interpretation of an equation to parameter conditions module 418 (484). Parameter conditions module 418 may determine parameter conditions 436 based on an interpretation of an equation (485). For example, parameter conditions module 418 may process an interpretation of an equation to symbolically derive parameter conditions 436 as conditions for boundedness, stability, and accuracy. Parameter conditions module 418 may provide parameter conditions 436 to benchmark module 424 to inform numerical parameters that may be used in generating code for solver 438 (488). Benchmark module 424 may update, instantiate, or otherwise modify code for solver 438 based on numerical parameters, benchmark examples, mesh geometries, or other conditions associated with multi-physics simulations (489). In some instances, target platform 456 may output a solution to a multi-physics simulation problem associated with code for solver 438 to benchmark module 424 to use as benchmark examples for modifying code for solver 438 (493).

[0078] FIG. 5 is a conceptual diagram illustrating example computing system 500 configured to generate example code for solver 538, in accordance with techniques of this disclosure. Computing system 500, templates 532, computing device 550, code for solver 538, and target platform 556 of FIG. 5 may be example or alternative implementations of computing system 100, templates 132, computing device 150, code for solver 138, and target platform 156 of FIG. 1, respectively. Additionally, or alternatively, computing system 500, interpreter 512, compiler 514, templates 532, and target platform 556 may be example or alternative implementations of computing system 200, interpreter 212, compiler 214, templates 232, and platforms 256 of FIG. 2, respectively.

[0079] In the example of FIG. 5, computing device 550 may send computing system 500 user input 552. User input 552 may include a high-level description of a multi-physics simulation problem and/or one or more equations associated with the multi-physics simulation problem. For example, user input 552 may include text data for an equation of: V • ( U(c) ■ r(c) - q(c) ), where q(c) = -k VT(c).

[0080] Interpreter 512 of computing system 500 may determine an interpretation, written in an intermediate language, of an equation indicated in user input 552. Interpreter 512 may determine an interpretation of an equation as discrete formulas 554 for an equation of user input 552 using notation rules of an intermediate language to create an interpretation of the equation. Discrete formulas 554 may include discrete or distinct portions of an equation associated with user input 552 (e.g., one or more mathematical operators, formulas, or functions applied to variables of a differential equation representing one or more phenomena). Discrete formulas 554 may include formulas or other functions associated with multi-physics phenomena represented in a grid geometry space associated with an intermediate language as discussed in FIG. 2, for example. Interpreter 512 may substitute an equation for the user input 552 example above with discrete equations 554 of an interpretation of the equation that includes the following intermediate language syntax: { sum(in(f, 6(dual(c))),

(orientation(f, dual(c)) * size(f) * unit_vector(f)) - def_q(centroid(f)), -k * sum(in(c, 6(dual(f))), T(c) * orientation(c, dual(f)) * unit_vector(dual(f)) / size(dual(f)))) / size(dual(c))

}■

[0081] Compiler 514 may identify patterns of syntax associated with discrete equations 554 written in an intermediate language. For example, compiler 514 may match syntax for discrete equations 554 in the example above to a template of templates 532 including code associated with target platform 556 mapped to syntax, written in the intermediate language, as follows: {

(orientation(f, dual(c)) * unit_vector(f)) * (sum(in(c, 5(dual(f))), ?ARG * orientation(c, dual(f)))) * unit_vector(dual(f)) / size(dual(f))) = snGrad(?ARG) } where ’ ’ARG " indicate differences between syntax of discrete formulas 554 and syntax of formulas mapped to code in templates 532. In some instances, based on a minimum threshold number of differences between a template and a discrete formula being satisfied, compiler 514 may match the discrete formula to the template. In some examples, compiler 514 may substitute “?ARG” with platform-specific expressions associated with a target platform.

[0082] Compiler 514 may generate code for solver 538 based on templates of templates 532 matched to discrete formulas 554. Compiler 514 may combine platform-specific code of templates 532 mapped to formulas similar to discrete formulas 554 to generate the code for solver 538. For example, compiler 514 may generate code for solver 538, based on a template in the example above and that is particular to target platform 556 (e.g., OpenFOAM), as follows: { surfaceScalarField U_flux = linearlnterpolate(U) & mesh.Sf(); surfaceScalarField flux2 = k * mesh.magSfO * fvc::snGrad(T); fvc::div(U_flux, tau) + fvc: : div(flux2) }.

[0083] Target platform 556 may compile or otherwise execute code for solver 538 to output solver 539 to computing device 550. Solver 539 may include data indicating a solution to a multi-physics problem associated with user input 552 that is determined based on execution of code for solver 538. Target platform 556 may output solver 539 to computing device 550 via an interface, such as interface 154 of FIG. 1.

[0084] FIG. 6 is a flowchart illustrating an example mode of operation for generating code for a solver targeted to a target platform, in accordance with techniques of this disclosure. FIG. 6 may be discussed with respect to FIG. 1 for example purposes only. Computing system 100 may match an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, wherein each template comprises syntax in the intermediate language (602). Computing system 100 may compile one or more templates to generate code for a solver, the code targeted to the target platform (604).

[0085] The techniques described in this disclosure may be implemented, at least in part, in hardware, software, firmware or any combination thereof. For example, various aspects of the described techniques may be implemented within one or more processors, including one or more microprocessors, digital signal processors (DSPs), application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), or any other equivalent integrated or discrete logic circuitry, as well as any combinations of such components. The term “processor"’ or “processing circuitry"’ may generally refer to any of the foregoing logic circuitry, alone or in combination with other logic circuitry, or any other equivalent circuitry. A control unit comprising hardware may also perform one or more of the techniques of this disclosure.

[0086] Such hardware, software, and firmware may be implemented within the same device or within separate devices to support the various operations and functions described in this disclosure. In addition, any of the described units, modules or components may be implemented together or separately as discrete but interoperable logic devices. Depiction of different features as modules or units is intended to highlight different functional aspects and does not necessarily imply that such modules or units must be realized by separate hardware or software components. Rather, functionality associated with one or more modules or units may be performed by separate hardware or software components or integrated within common or separate hardware or software components.

[0087] The techniques described in this disclosure may also be embodied or encoded in computer-readable media, such as a computer-readable storage medium, containing instructions. Instructions embedded or encoded in one or more computer-readable storage mediums may cause a programmable processor, or other processor, to perform the method, e.g., when the instructions are executed. Computer-readable storage media may include random access memory (RAM), read only memory (ROM), programmable read only memory (PROM), erasable programmable read only memory (EPROM), electronically erasable programmable read only memory (EEPROM), flash memory, a hard disk, a CD-ROM, a floppy disk, a cassette, magnetic media, optical media, or other computer-readable media.

Claims

CLAIMS What is claimed is:

1. A method for generating solvers, comprising: matching, by a computing system, an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, wherein each of the templates comprises syntax in the intermediate language; and compiling, by the computing system, the one or more templates to generate code for a solver, the code targeted to the target platform.

2. The method of claim 1, wherein the intermediate language specifies notation rules for syntax indicating discrete formulas.

3. The method of claim 1, further comprising generating, by the computing system, the interpretation based on an input specification that includes data describing the equation.

4. The method of claim 1, further comprising executing, on the target platform, the code for the solver.

5. The method of claim 1, wherein matching the interpretation of the equation to the one or more templates comprises matching a pattern in the interpretation of the equation to at least one template of the one or more templates.

6. The method of claim 1 , wherein each template of the one or more templates includes one or more formulas, written in the intermediate language, mapped to one or more code objects comprising code for respective target platforms.

7. The method of claim 6, wherein compiling the one or more templates to generate the code for the solver comprises including a code object of the one or more code objects in the code for the solver.

8. The method of claim 1, wherein the equation includes a differential equation, and wherein the interpretation of the equation includes discrete formulas, written in the intermediate language, associated with the differential equation.

9. The method of claim 1, further comprising: receiving, from a user device, an indication to generate the code for the solver; and outputting, to the user device, the code for the solver.

10. A computing system comprising: processing circuitry; and memory comprising instructions that when executed by the processing circuitry, cause the processing circuitry to: match an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, wherein each of the templates comprises syntax in the intermediate language; and compile the one or more templates to generate code for a solver, the code targeted to the target platform.

11. The computing system of claim 10, wherein the intermediate language specifies notation rules for syntax indicating discrete formulas.

12. The computing system of claim 10, wherein the instructions further cause the processing circuitry to generate the interpretation based on an input specification that includes data describing the equation.

13. The computing system of claim 10, wherein to match the interpretation of the equation to the one or more templates, the instructions cause the processing circuitry⁷ to match a pattern in the interpretation of the equation to at least one template of the one or more templates.

14. The computing system of claim 10, wherein each template of the one or more templates includes one or more formulas, written in the intermediate language, mapped to one or more code objects comprising code for respective target platforms.

15. The computing system of claim 14, wherein to compile the one or more templates to generate the code for the solver, the instructions cause the processing circuitry to include a code object of the one or more code objects platforming the code for the solver.

16. The computing system of claim 10, wherein the equation includes a differential equation, and wherein the interpretation of the equation includes discrete formulas, written in the intermediate language, associated with the differential equation.

17. The computing system of claim 10, wherein the instructions further cause the processing circuitry to: receive, from a user device, an indication to generate the code for the solver; and output, to the user device, the code for the solver.

18. Computer-readable storage media comprising machine-readable instructions for configuring processing circuitry to: match an interpretation, written in an intermediate language, of an equation descriptive of one or more physical phenomena to one or more templates for a target platform, wherein each of the templates comprises syntax in the intermediate language; and compile the one or more templates to generate code for a solver, the code targeted to the target platform.

19. The computer-readable storage media of claim 18, wherein the intermediate language specifies notation rules for syntax indicating discrete formulas.

20. The computer-readable storage media of claim 18, wherein the machine-readable instructions further configure the processing circuitry to generate the interpretation based on an input specification that includes data describing the equation.