{"id":13574894,"url":"https://github.com/terrapower/armi","last_synced_at":"2026-02-05T03:01:04.473Z","repository":{"id":37451356,"uuid":"218863590","full_name":"terrapower/armi","owner":"terrapower","description":"An open-source nuclear reactor analysis automation framework that helps design teams increase efficiency and quality","archived":false,"fork":false,"pushed_at":"2026-01-30T23:41:34.000Z","size":15336,"stargazers_count":261,"open_issues_count":174,"forks_count":97,"subscribers_count":16,"default_branch":"main","last_synced_at":"2026-01-31T14:34:33.361Z","etag":null,"topics":["clean-energy","nuclear","nuclear-reactor"],"latest_commit_sha":null,"homepage":"https://terrapower.github.io/armi/","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/terrapower.png","metadata":{"files":{"readme":"README.rst","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2019-10-31T21:18:34.000Z","updated_at":"2026-01-30T23:41:36.000Z","dependencies_parsed_at":"2023-12-20T07:28:29.580Z","dependency_job_id":"f25c73a7-9517-4ac3-92c4-368476dd7bc5","html_url":"https://github.com/terrapower/armi","commit_stats":{"total_commits":1153,"total_committers":59,"mean_commits":19.54237288135593,"dds":0.6964440589765828,"last_synced_commit":"c7d02f98c29e2983dc5e6c471f72a35d675ca232"},"previous_names":[],"tags_count":25,"template":false,"template_full_name":null,"purl":"pkg:github/terrapower/armi","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/terrapower%2Farmi","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/terrapower%2Farmi/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/terrapower%2Farmi/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/terrapower%2Farmi/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/terrapower","download_url":"https://codeload.github.com/terrapower/armi/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/terrapower%2Farmi/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29108234,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-05T02:48:39.389Z","status":"ssl_error","status_checked_at":"2026-02-05T02:48:27.400Z","response_time":65,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["clean-energy","nuclear","nuclear-reactor"],"created_at":"2024-08-01T15:00:55.732Z","updated_at":"2026-02-05T03:01:04.462Z","avatar_url":"https://github.com/terrapower.png","language":"Python","funding_links":[],"categories":["Other"],"sub_categories":["Related Tools"],"readme":"\n|Build Status| |Code Coverage| |Commit Activity| |Good First Issues|\n\n#################\nARMI Introduction\n#################\n\nThe Advanced Reactor Modeling Interface (ARMI\\ :sup:`®`) is an open-source tool that\nstreamlines your nuclear reactor design/analysis needs by providing a\nsoftware *reactor at your fingertips* and a rich ecosystem of utilities working in concert.\nIt is made for and by professional reactor analysis teams and\nis maintained by `TerraPower LLC \u003chttp://terrapower.com/\u003e`_, a nuclear technology\ndevelopment company.\n\nARMI:\n\n* Provides a hub-and-spoke mechanism to standardize communication and coupling between\n  physics kernels and the specialist analysts who use them,\n\n* Facilitates the creation and execution of detailed models and complex analysis\n  methodologies,\n\n* Provides an ecosystem within which to rapidly and collaboratively build new analysis\n  and physics simulation capabilities, and\n\n* Provides useful utilities to assist in reactor development.\n\nA few demos of ARMI can be seen in the `ARMI example gallery\n\u003chttps://terrapower.github.io/armi/gallery/index.html\u003e`_.\n\nUsing ARMI plus a collection of ARMI-aware physics plugins, an engineering team can\nperform a full analysis of a reactor system and then repeat the same level of analysis\nwith some changed input parameters for almost no additional cost. Even better, thousands\nof perturbed cases can be executed in parallel on large computers, helping conceptual\ndesign teams home in on an optimal design, or helping detailed design teams understand\nsensitivities all the way from, for example, an impurity in a control material to the\npeak structural temperature in a design-basis transient.\n\n.. note:: ARMI does not come with a full selection of physics kernels. They will need to\n   be acquired or developed for your specific project in order to make full use of this\n   tool. Many of the example use-cases discussed in this manual require functionality\n   that is not included in the open-source ARMI Framework.\n\nIn general, ARMI aims to enhance the quality, ease, and rigor of computational nuclear\nreactor design and analysis. Additional high-level overview about this system can be\nfound in [#touranarmi]_.\n\n\n.. list-table:: Quick links\n   :widths: 30 70\n\n   * - Source code\n     - https://github.com/terrapower/armi\n   * - Documentation\n     - https://terrapower.github.io/armi\n   * - First time contributor's guide\n     - https://terrapower.github.io/armi/developer/first_time_contributors.html\n   * - Bug tracker\n     - https://github.com/terrapower/armi/issues\n   * - Plugin directory\n     - https://github.com/terrapower/armi-plugin-directory\n   * - Contact\n     - armi-devs@terrapower.com\n\nQuick start\n===========\nBefore starting, you need to have `Python \u003chttps://www.python.org/downloads/\u003e`_ 3.9+.\n\nGet the ARMI code, install the prerequisites, and fire up the launcher with the following\ncommands. You probably want to do this in a virtual environment as described in the `Installation\ndocumentation \u003chttps://terrapower.github.io/armi/installation.html\u003e`_. Otherwise, the\ndependencies could conflict with your system dependencies.\n\nFirst, upgrade your version of pip::\n\n    $ pip install -U pip\u003e=22.1\n\nNow clone and install ARMI::\n\n    $ git clone https://github.com/terrapower/armi\n    $ cd armi\n    $ pip install -e .\n    $ armi --help\n\nThe ARMI tests are meant to be run using `pytest \u003chttps://docs.pytest.org/en/8.0.x/\u003e`_\nlocally ::\n\n    $ pip install -e \".[test]\"\n    $ pytest -n 4 armi\n\nFrom here, we recommend going through a few of our `gallery examples\n\u003chttps://terrapower.github.io/armi/gallery/index.html\u003e`_ and\n`tutorials \u003chttps://terrapower.github.io/armi/tutorials/index.html\u003e`_ to\nstart touring the features and capabilities and then move on to the\n`User Manual \u003chttps://terrapower.github.io/armi/user/index.html\u003e`_.\n\n\nBackground\n==========\nNuclear reactor design requires, among other things, answers to the following questions:\n\n* Where are the neutrons? How fast are they moving? In which direction?\n\n* How quickly are atomic nuclei splitting? How long until the fuel runs out? How many\n  atoms in the structure are being energetically displaced?\n\n* How much heat do these reactions produce? How quickly must coolant flow past the fuel\n  to maintain appropriate temperatures? What are the temperatures of the fuel, coolant,\n  and structure?\n\n* Can the structural arrangement support itself given the temperatures and pressures\n  induced by the flowing coolant? For how long?\n\n* If a pump loses power or a control rod accidentally withdraws, how quickly will the\n  chain reaction stop while keeping radiation contained?\n\n* How much used nuclear fuel is generated per useful energy produced? How long until it\n  decays to stability?\n\n* Where and when should we move the fuel to most economically maintain the chain\n  reaction?\n\n* What's the dose and activation above the head and in the secondary loop?\n\n* How does containment handle various postulated accidents?\n\n* How does the building handle earthquakes?\n\nDigital computers have assisted in nuclear technology development since the days of the\nENIAC in the 1940s. We now understand reactor physics well enough to build detailed\nsimulations, which can answer many of these design questions in a cost-effective, and\nflexible manner. This allows us to simulate all kinds of different reactors with\ndifferent fuels, coolants, moderators, power levels, safety systems, and power cycles.\nWe can run our virtual reactors through the decades, tossing various off-normal\nconditions at them now and then, to see how they perform in terms of capability,\neconomics, and safety.\n\n.. note:: Of course, experimental validation remains necessary for many new configurations and situations during licensing.\n\nPerhaps surprisingly, some nuclear software written in the 1960s is still in use today\n(mostly ported to Fortran 90 by now). These codes are validated against physical\nexperiments that no longer exist. Meanwhile, new cutting-edge nuclear software is being\ndeveloped today for powerful computers. Both old and new, these tools are often\nchallenging to operate and to use in concert with other sub-specialty codes that are\nnecessary to reach a full system analysis.\n\nThe ARMI approach was born out of this situation: how can we best leverage an eclectic\nmix of legacy and modern tools with a small team to do full-scope analysis? We built an\nenvironment that lets us automate the tedious, uncoupled, and error-prone parts of\nreactor engineering/analysis work. We can turn around a very meaningful and detailed\ncore analysis given a major change (e.g. change power by 50%) in just a few weeks. We\ncan dispatch hundreds of parameter sweeps to multiple machines and then perform\nmultiobjective optimization on the resulting design space.\n\nThe ARMI system is largely written in the Python programming language. Its high-level\nnature allows nuclear and mechanical engineers to rapidly automate their analysis tasks\nfrom their sub-specialties. This helps eliminate the translation step between\ncomputer-scientists and power plant design engineers. This allows good division of\nlabor: the computer scientists can focus on the overall performance and maintainability\nof the framework, while the power plant engineers focus on power plant engineering.\n\nWe've spent 10 years developing this system in a reactor design context. We focused\nprimarily on what's needed to do advanced reactor design and analysis.\n\nBecause of ARMI's high-level nature, we believe we can collaborate effectively with all\nongoing reactor software developments.\n\nCommunication and coupling\n==========================\nARMI provides a central place for all physics kernels to interact: the Reactor Model.\nAll modules read *state* information from this Reactor and write their output to it.\nThis common interface allows seamless communication and coupling between different\nphysics sub-specialties. If you plug one new physics kernel into ARMI, it becomes\ncoupled to N other kernels. The ARMI Framework, depicted in green below, is the majority\nof the open source package. Several skeletal analysis routines are included as well to\nperform basic data management and to help align efforts on external physics kernels.\n\n.. figure:: https://terrapower.github.io/armi/_static/armiSchematicView.png\n   :figclass: align-center\n\n   **Figure 1.** The schematic representation of the ARMI data model.\n\n\nAutomation\n==========\n\nARMI can quickly and easily produce complex input files with high levels of detail in\nvarious approximations. This enables users to perform rapid high-fidelity analyses to\nmake sure all important physics are captured. It also enables sensitivity studies of\ndifferent modeling approximations (e.g. symmetries, transport vs. diffusion vs. Monte\nCarlo, subchannel vs. CFD, etc.).\n\n\n.. figure:: https://terrapower.github.io/armi/_static/armiGeometries.png\n   :figclass: align-center\n\n   **Figure 2.** A variety of approximations in hexagonal geometry (1/3-core, full core, pin detailed, etc.) are shown,\n   all derived from one consistent input file. ARMI supports Cartesian, Hex, RZ, and RZTheta geometric grids\n   and includes many geometric components. Additionally, users can provide custom geometric elements.\n\n\nNew analysis and physics capabilities\n=====================================\nThe ARMI reactor model is fully accessible via a Python-based API, meaning that\npower-users and developers have full access to the details of the plant at all times.\nDevelopers adding new physics features can take advantage of the ARMI data management\nstructure by simply reading and writing to the Reactor state. Leveraging the\ninfrastructure of ARMI, progress can be made rapidly.\n\nPower-user analysts can modify the plant in many ways. For instance, removing all sodium\ncoolant is a one-liner::\n\n    core.setNumberDensity('NA23',0.0)\n\nand finding the peak power density is easy::\n\n    core.getMaxParam('pdens')\n\nAny ARMI state can be written out to whichever format the user desires, meaning that\nnominally identical cases can be produced for multiple similar codes in sensitivity\nstudies. To read power densities, simply read them off the assembly objects. Instead of\nproducing spreadsheets and making plots manually, analysts may write scripts to generate\noutput reports that run automatically.\n\nWriting a module within ARMI automatically features access to the ARMI API, including:\n\n* Cross section processing\n* Material properties\n* Thermal expansion\n* Database persistence\n* Data visualization\n* A code testing, documentation, and version control system\n\n\nUse cases\n=========\n\nGiven input describing a reactor, a typical ARMI run loops over a set of plugins in a\ncertain sequence. Some plugins trigger third-party simulation codes, producing input\nfiles for them, executing them, and translating the output back onto the reactor model\nas state information. Other plugins perform physics simulations directly. A variety of\nplugins are available from TerraPower LLC with certain licensing terms, and it is our\nhope that a rich ecosystem of useful plugins will be developed and curated by the\ncommunity (university research teams, national labs, other companies, etc.).\n\nFor example, one ARMI sequence may involve the calculation of:\n\n* nuclear cross sections,\n* global flux and power,\n* subchannel temperatures,\n* duct wall pressures,\n* cladding strain and wastage,\n* fission gas pressure,\n* reactivity feedbacks (including from core mechanical),\n* flow orificing,\n* the equilibrium fuel cycle,\n* control rod worth,\n* shutdown margin,\n* frequency stability margins,\n* total levelized cost of electricity for the run,\n* and the peak cladding temperature in a variety of design and beyond-design basis\n  transients.\n\nAnother sequence may simply compute the cost of feed uranium and enrichment in an\ninitial core and quit. The possibilities are limited only by our creativity.\n\nThese large runs may also be run through the multiobjective design optimization system,\nwhich runs many cases with input perturbations to help find the best overall system,\nconsidering all important physics at the same time.\n\nOther interest may come from the following:\n\nThe Research Scientist\n----------------------\nA nuclear reactor research scientist, whether at a national lab or on a graduate or\nundergraduate university team, may benefit greatly from using ARMI. It's not uncommon\nfor such people to spend significant fractions of effort on data management. ARMI will\nhandle the tedium so that researchers can better focus on designing and testing their\nresearch.\n\nFor example, if an ARMI input file describing the FFTF reactor in detail is provided,\nthe researcher can start running benchmark cases with their new code method very\nrapidly, rather than spending the time building their own FFTF model.\n\nIf someone wants to try varying nuclear cross sections by a percent here and there to\ncompute sensitivities, ARMI is a perfect platform upon which to operate.\n\nIf a reactor designer wants to try out a new Machine Learning algorithm for fuel\nmanagement, plugging it into ARMI and having it run on all the physics kernels of the\nARMI ecosystem will be a great way to prove its true value (note that this requires a\nrich ARMI physics ecosystem).\n\nThe Nuclear Startup Engineer\n----------------------------\nAs various companies evaluate their ideas, they need tools for analysis. They\ncan pick up ARMI and save 10 years of development and hit the ground running by\nplugging in their design-specific physics kernels and proprietary design\ninputs. ARMI's parameter sweep features, reactor model, and parallel utilities will\nall come in handy immediately.\n\n\nOperating and Vendor Engineers\n------------------------------\nPeople at well-established utilities or vendors can hook ARMI into their legacy\nsystems and increase their overall productivity.\n\nThe Enthusiast\n--------------\nIf an enthusiast wants to try out a reactor idea they have, they can use ARMI\n(plus some physics kernels) to quickly get some performance metrics. They can\nsee if their idea has wings, and if it does, they can then find a way to bring\nit to engineering and commercial reality.\n\n\nHistory of ARMI\n===============\nARMI was originally created by TerraPower, LLC near Seattle WA starting in 2009. Its\nfounding mission was to determine the optimal fuel management operations required to\ntransition a fresh Traveling Wave Reactor core from startup into an equilibrium state.\nIt started out automating the Argonne National Lab (ANL) fast reactor neutronics codes,\nMC2 and REBUS. The reactor model design was made with the intention of adding other\nphysics capabilities later. Soon, simple thermal hydraulics were added and it's grown\never since. It has continuously evolved towards a general reactor analysis framework.\n\nFollowing requests by outside parties to use ARMI, we started working on a more modular\narchitecture for ARMI, allowing some of the intertwined physics capabilities to be\nseparated out as plugins from the standalone framework.\n\nThe nuclear industry is small, and it faces many challenges. It also has a tradition of\nsecrecy. As a result, there is risk of overlapping work being done by other entities.\n\nWe hypothesize that collaborating on software systems can help align some efforts\nworldwide, increasing quality and efficiency. In reactor development, the idea is\ngenerally cheap. It's the shakedown, technology and supply chain development,\nengineering demo, and commercial demo that are the hard parts.\n\nThus, ARMI was released under an open-source license in 2019 to facilitate mutually\nbeneficial collaboration across the nuclear industry, where many teams are independently\ndeveloping similar reactor analysis/automation frameworks. TerraPower will make its\nproprietary analysis routines, physics kernels, and material properties available under\ncommercial licenses.\n\nWe also hope that if more people can rapidly analyze the performance of their reactor\nideas, limited available funding can be spent more effectively.\n\n\nSystem Requirements\n===================\nBeing largely written in the Python programming language, the ARMI system works on\nbasically any kind of computer. We have developed it predominantly within a Microsoft\nWindows environment, but have performed tests under various flavors of Linux as well. It\ncan perform meaningful analysis on a single laptop, but the full value of design\noptimization and large problems is realized with parallel runs over MPI with 32-128\nCPUs, or more (requires installation optional ``mpi4py`` library).\nSerious engineering models can consume significant RAM, so at least 16 GB\nis recommended.\n\nThe original developer's HPC environment has been Windows based, so some development is\nneeded to support the more traditional Linux HPC environments.\n\n.. _getting-help:\n\nGetting help\n============\nYou can get help with ARMI by either making issues on `our github page\n\u003chttps://github.com/terrapower/armi/issues\u003e`_ or by e-mailing armi-devs@terrapower.com.\n\nDisclaimers\n===========\nDue to TerraPower goals and priorities, many ARMI modules were developed with the\nsodium-cooled TWR as the target, and are not necessarily yet optimized for other plants.\nOn the other hand, we have attempted to keep the framework general where possible, and\nmany modules are broadly applicable to many reactors. We have run parts of ARMI on\nvarious SFRs (TWRs, FFTF, Joyo, Phenix), some fast critical assemblies (such as ZPPRs\nand BFS), molten salt reactors, and some thermal systems. Support for the basic\nneeds of thermal reactors (like a good spatial description of pin maps) exists but\nhas not been subject to as much use.\n\nARMI was developed within a rapidly changing R\u0026D environment. It evolved accordingly,\nand naturally carries some legacy. We continuously attempt to identify and update\nproblematic parts of the code. Users should understand that ARMI is not a polished\nconsumer software product, but rather a powerful and flexible engineering tool. It has\nthe potential to accelerate work on many kinds of reactors. But in many cases, it will\nrequire serious and targeted investment.\n\nARMI was largely written by nuclear and mechanical engineers. We (as a whole) only\nreally, truly, recognized the value of things like static typing in a complex system\nlike ARMI somewhat recently.\n\nARMI has been written to support specific engineering/design tasks. As such, polish in\nthe GUIs and output is somewhat lacking.\n\nThe ARMI framework uses the ``camelCase`` style, which is not the standard style for Python. As this\nis an issue of style, it is not considered worth the API-breaking cost to our downstream users to\nchange it.\n\n\nLicense\n=======\nTerraPower and ARMI are registered trademarks of TerraPower, LLC.\nOther trademarks and registered trademarks used in this Manual are the property of the\nrespective trademark holders.\n\nThe ARMI system is licensed as follows:\n\n.. code-block:: none\n\n\tCopyright 2009-2024 TerraPower, LLC\n\n\tLicensed under the Apache License, Version 2.0 (the \"License\");\n\tyou may not use this file except in compliance with the License.\n\tYou may obtain a copy of the License at\n\n\t    http://www.apache.org/licenses/LICENSE-2.0\n\n\tUnless required by applicable law or agreed to in writing, software\n\tdistributed under the License is distributed on an \"AS IS\" BASIS,\n\tWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\tSee the License for the specific language governing permissions and\n\tlimitations under the License.\n\nBe careful when including any dependency in ARMI (say in the ``pyproject.toml`` file) not\nto include anything with a license that supersedes our Apache license. For instance,\nany third-party Python library included in ARMI with a GPL license will make the whole\nproject fall under the GPL license. But a lot of potential users of ARMI will want to\nkeep some of their work private, so we can't allow any GPL dependencies.\n\nFor that reason, it is generally considered best-practice in the ARMI ecosystem to\nonly use third-party Python libraries that have MIT or BSD licenses.\n\n.. [#touranarmi] Touran, Nicholas W., et al. \"Computational tools for the integrated design of advanced nuclear reactors.\"\n   Engineering 3.4 (2017): 518-526. https://doi.org/10.1016/J.ENG.2017.04.016\n\n.. |Build Status| image:: https://github.com/terrapower/armi/actions/workflows/unittests.yaml/badge.svg?branch=main\n    :target: https://github.com/terrapower/armi/actions/workflows/unittests.yaml\n\n.. |Code Coverage| image:: https://coveralls.io/repos/github/terrapower/armi/badge.svg?branch=main\u0026kill_cache=2\n    :target: https://coveralls.io/github/terrapower/armi?branch=main\n\n.. |Commit Activity| image:: https://img.shields.io/github/commit-activity/m/terrapower/armi\n    :target: https://github.com/terrapower/armi/pulse\n\n.. |Good First Issues| image:: https://img.shields.io/github/issues/terrapower/armi/good%20first%20issue\n    :target: https://github.com/terrapower/armi/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fterrapower%2Farmi","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fterrapower%2Farmi","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fterrapower%2Farmi/lists"}