neml2 1.3.1__tar.gz

neml2-1.3.1/.clang-format

@@ -0,0 +1,31 @@
+BasedOnStyle: LLVM
+
+TabWidth: 2
+ColumnLimit: 100
+UseTab: Never
+
+CommentPragmas: "^/"
+ReflowComments: true
+AlignTrailingComments: true
+SpacesBeforeTrailingComments: 1
+
+SpaceBeforeParens: ControlStatements
+SpacesInSquareBrackets: false
+BreakBeforeBraces: Allman
+PointerAlignment: Middle
+
+BinPackParameters: false
+BinPackArguments: false
+PackConstructorInitializers: Never
+AllowShortBlocksOnASingleLine: false
+AllowShortFunctionsOnASingleLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+
+SortIncludes: false
+IndentCaseLabels: true
+ConstructorInitializerIndentWidth: 2
+AlwaysBreakAfterDefinitionReturnType: TopLevel
+AlwaysBreakTemplateDeclarations: true
+
+FixNamespaceComments: false

neml2-1.3.1/.github/workflows/build_docs.yml

@@ -0,0 +1,49 @@
+name: Documentation
+
+on:
+  # Triggers the workflow on push or pull request
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Newer commits should cancel old runs
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+      - run: pip install -r requirements.txt
+      - run: |
+          cmake \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_UNITY_BUILD=OFF \
+            -DNEML2_UNIT=ON \
+            -DNEML2_REGRESSION=OFF \
+            -DNEML2_VERIFICATION=OFF \
+            -DNEML2_BENCHMARK=OFF \
+            -DNEML2_PROFILING=OFF \
+            -DNEML2_PYBIND=OFF \
+            -DNEML2_DOC=ON \
+            .
+      - run: make doc-syntax -j 2
+      - run: make doc-html
+      - run: cat doc/doxygen.log
+      - name: Deploy to GitHub Pages
+        if: ${{ github.event_name == 'push' }}
+        uses: JamesIves/github-pages-deploy-action@v4.4.1
+        with:
+          branch: gh-pages
+          folder: doc/build/html
+          single-commit: true

neml2-1.3.1/.github/workflows/python.yml

@@ -0,0 +1,146 @@
+name: python
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+  release:
+    types:
+      - published
+
+permissions:
+  contents: read # Required when overriding permissions
+  pull-requests: write # For posting coverage report
+  checks: write
+
+# Newer commits should cancel old runs
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  black:
+    name: Formatting Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: psf/black@stable
+        with:
+          options: "--check -v"
+          src: "python/neml2 tests/python"
+  build-test:
+    name: Build and test Python bindings
+    needs: black
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: "3.23"
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+      - name: Install Python dependencies
+        run: pip install -r requirements.txt
+      - name: Install PyTorch
+        run: pip install torch==2.2.1
+      - run: |
+          cmake \
+            -DCMAKE_BUILD_TYPE=Debug \
+            -DCMAKE_UNITY_BUILD=ON \
+            -DNEML2_UNIT=OFF \
+            -DNEML2_REGRESSION=OFF \
+            -DNEML2_VERIFICATION=OFF \
+            -DNEML2_BENCHMARK=OFF \
+            -DNEML2_PROFILING=OFF \
+            -DNEML2_PYBIND=ON \
+            -DNEML2_DOC=OFF \
+            -B build \
+            .
+      - run: cd build && make -j 2
+      - run: PYTHONPATH=build/python pytest --junitxml=build/python/pytest.xml tests
+      - name: Publish Test Results
+        uses: EnricoMi/publish-unit-test-result-action@v2
+        if: matrix.os == 'ubuntu-latest'
+        with:
+          files: build/python/pytest.xml
+          check_name: Python Binding Test Results (${{ matrix.os }})
+      - name: Publish Test Results
+        uses: EnricoMi/publish-unit-test-result-action/composite@v2
+        if: matrix.os == 'macos-latest'
+        with:
+          files: build/python/pytest.xml
+          check_name: Python Binding Test Results (${{ matrix.os }})
+  sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build SDist
+        run: pipx run build --sdist
+      - name: Upload SDist
+        uses: actions/upload-artifact@v4
+        if: github.event_name == 'release' && github.event.action == 'published'
+        with:
+          name: package-sdist
+          path: dist/*.tar.gz
+  wheels:
+    needs: build-test
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Backup docker
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo mv /var/lib/docker ${GITHUB_WORKSPACE}/docker
+      - name: Maximize build space
+        if: matrix.os == 'ubuntu-latest'
+        uses: easimon/maximize-build-space@master
+        with:
+          remove-dotnet: "true"
+          remove-android: "true"
+          remove-haskell: "true"
+          remove-codeql: "true"
+          build-mount-path: "/var/lib/docker/"
+      - name: Remount docker
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo sh -c "mv ${GITHUB_WORKSPACE}/docker/* /var/lib/docker"
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: "3.23"
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.16.5
+      - name: Upload wheels
+        if: github.event_name == 'release' && github.event.action == 'published'
+        uses: actions/upload-artifact@v4
+        with:
+          name: package-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+  PyPI:
+    needs: [sdist, wheels]
+    environment: pypi
+    permissions:
+      id-token: write
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release' && github.event.action == 'published'
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: package-*
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

neml2-1.3.1/.github/workflows/tests.yml

@@ -0,0 +1,179 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+permissions:
+  contents: read # Required when overriding permissions
+  pull-requests: write # For posting coverage report
+  checks: write
+
+# Newer commits should cancel old runs
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  clang-format:
+    name: Formatting Check
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        path:
+          - "src"
+          - "include"
+          - "tests"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run clang-format style check
+        uses: jidicula/clang-format-action@v4.11.0
+        with:
+          clang-format-version: "17"
+          check-path: ${{ matrix.path }}
+  copyright:
+    name: Copyright check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+      - name: Check to see if source files have the correct copyright header
+        run: ./scripts/check_copyright.py
+  build-test:
+    needs: clang-format
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        btype: [Release, Debug]
+        unity: [ON, OFF]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: jwlawson/actions-setup-cmake@v2
+        with:
+          cmake-version: "3.23"
+      - run: |
+          cmake \
+            -DCMAKE_BUILD_TYPE=${{ matrix.btype }} \
+            -DCMAKE_UNITY_BUILD=${{ matrix.unity }} \
+            -DNEML2_UNIT=ON \
+            -DNEML2_REGRESSION=ON \
+            -DNEML2_VERIFICATION=ON \
+            -DNEML2_BENCHMARK=OFF \
+            -DNEML2_PROFILING=OFF \
+            -DNEML2_PYBIND=OFF \
+            -DNEML2_DOC=OFF \
+            .
+      - run: make -j 2
+      - run: cd tests && ./unit_tests -r junit > unit_tests.xml
+        continue-on-error: true
+      - run: cd tests && ./regression_tests -r junit > regression_tests.xml
+        continue-on-error: true
+      - run: cd tests && ./verification_tests -r junit > verification_tests.xml
+        continue-on-error: true
+      - name: Publish Test Results
+        uses: EnricoMi/publish-unit-test-result-action@v2
+        if: matrix.os == 'ubuntu-latest'
+        with:
+          files: tests/*.xml
+          check_name: Test Results (${{ matrix.os }}-${{ matrix.btype }}-${{ matrix.unity }})
+      - name: Publish Test Results
+        uses: EnricoMi/publish-unit-test-result-action/composite@v2
+        if: matrix.os == 'macos-latest'
+        with:
+          files: tests/*.xml
+          check_name: Test Results (${{ matrix.os }}-${{ matrix.btype }}-${{ matrix.unity }})
+  build-all:
+    needs: clang-format
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        btype: [Release, Debug]
+        unity: [ON, OFF]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - run: |
+          cmake \
+            -DCMAKE_BUILD_TYPE=${{ matrix.btype }} \
+            -DCMAKE_UNITY_BUILD=${{ matrix.unity }} \
+            -DNEML2_UNIT=ON \
+            -DNEML2_REGRESSION=ON \
+            -DNEML2_VERIFICATION=ON \
+            -DNEML2_BENCHMARK=ON \
+            -DNEML2_PROFILING=ON \
+            -DNEML2_PYBIND=OFF \
+            -DNEML2_DOC=OFF \
+            .
+      - run: make -j 2
+  coverage:
+    name: Code coverage check
+    needs: build-test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - run: sudo apt install lcov
+      - run: |
+          cmake \
+            -DCMAKE_BUILD_TYPE=Coverage \
+            -DCMAKE_UNITY_BUILD=OFF \
+            -DNEML2_UNIT=ON \
+            -DNEML2_REGRESSION=ON \
+            -DNEML2_VERIFICATION=ON \
+            -DNEML2_BENCHMARK=OFF \
+            -DNEML2_PROFILING=OFF \
+            -DNEML2_DOC=OFF \
+            .
+      - run: make -j 2
+      - run: ./scripts/coverage.sh
+      - uses: romeovs/lcov-reporter-action@v0.3.1
+        with:
+          lcov-file: ./coverage/coverage.info
+          github-token: ${{ secrets.PR_ACTION }}
+          delete-old-comments: true
+  cmake-integration:
+    name: Test CMake integration as a subproject
+    needs: clang-format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          path: neml2
+      - name: Create a source file for testing purposes
+        run: |
+          echo -e "\
+            #include \"neml2/base/Registry.h\"\n\
+            int main() {\n\
+              neml2::Registry::print(std::cout);\n\
+              return 0;\n\
+            }\
+            " > main.cxx
+      - run: cat main.cxx
+      - name: Create a CMakeLists.txt file for testing purposes
+        run: |
+          echo -e "\
+            cmake_minimum_required(VERSION 3.5)
+            project(FOO)\n\
+            add_subdirectory(neml2)\n\
+            add_executable(foo main.cxx)\n\
+            target_link_libraries(foo neml2)\n\
+            " > CMakeLists.txt
+      - run: cat CMakeLists.txt
+      - name: Configure with CMake
+        run: cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF -DNEML2_DOC=OFF -B build .
+      - name: Compile
+        run: cd build && make -j 2
+      - run: cd build && ./foo

neml2-1.3.1/.gitignore

@@ -0,0 +1,40 @@
+CMakeCache.txt
+CMakeFiles
+cmake_install.cmake
+CMakeDoxyfile.in
+detect_cuda*
+*.swp
+Makefile
+*.a
+src/test
+CTestTestfile.cmake
+DartConfiguration.tcl
+Testing
+*.cmake
+tests/*tests
+.cache
+compile_commands.json
+coverage
+doc/class-doc
+*.html
+.vscode
+doc/doctrees
+doc/html
+!cmake/Modules/*
+*.log
+*.so
+*.dylib
+*.pt
+!**/gold/*.pt
+**/syntax.yml
+build
+_deps
+__pycache__
+config.h
+conftest.py
+*.pyi
+neml2.egg-info
+.pytest_cache
+src/neml2/base/config.h
+install
+conftest.py

neml2-1.3.1/.gitmodules

@@ -0,0 +1,13 @@
+[submodule "extern/Catch2"]
+	path = extern/Catch2
+    url = https://github.com/catchorg/Catch2.git
+    ignore = dirty
+[submodule "extern/doxygen-awesome-css"]
+	path = extern/doxygen-awesome-css
+	url = https://github.com/jothepro/doxygen-awesome-css.git
+[submodule "extern/hit/hit"]
+	path = extern/hit/hit
+	url = https://github.com/idaholab/hit.git
+[submodule "extern/gperftools"]
+	path = extern/gperftools
+	url = https://github.com/gperftools/gperftools.git

neml2-1.3.1/CMakeLists.txt

@@ -0,0 +1,94 @@
+cmake_minimum_required(VERSION 3.23)
+
+project(NEML2 LANGUAGES CXX)
+
+# Setup modules
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${NEML2_SOURCE_DIR}/cmake/Modules/")
+
+# Ninja only: limit number of jobs in a CI build
+set_property(GLOBAL PROPERTY JOB_POOLS CI=6)
+
+# FindPython should return the first matching Python
+if(POLICY CMP0094)
+      cmake_policy(SET CMP0094 NEW)
+endif()
+
+# Suppress the warning related to the new policy on fetch content's timestamp
+if(POLICY CMP0135)
+      cmake_policy(SET CMP0135 NEW)
+endif()
+
+# Suppress the warning related to the new policy on FindPythonXXX
+if(POLICY CMP0148)
+      cmake_policy(SET CMP0148 NEW)
+endif()
+
+# Accept Release, Debug, and RelWithDebInfo, add Coverage build types
+set(CMAKE_CXX_FLAGS_COVERAGE
+      "-O0 -fprofile-arcs -ftest-coverage"
+      CACHE STRING "Flags used by C++ compiler during coverage builds."
+      FORCE)
+
+# Set the default build type
+if(NOT CMAKE_BUILD_TYPE)
+      set(CMAKE_BUILD_TYPE "Debug" CACHE
+            STRING "Choose the type of build." FORCE)
+
+      # Set the possible values of build type for cmake-gui
+      set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+            "Debug" "Release" "MinSizeRel" "RelWithDebInfo" "Coverage")
+endif()
+
+# Add the unity option to the cache
+option(CMAKE_UNITY_BUILD "Use a unity build" OFF)
+
+# c++ 17 support
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(Torch)
+
+# Install rpath, important for a relocatable install
+option(NEML2_WHEELS "Customize the build for Python wheels" OFF)
+
+if(NEML2_WHEELS)
+      if(UNIX)
+            if(APPLE)
+                  set(CMAKE_INSTALL_RPATH "@loader_path;@loader_path/lib;@loader_path/../torch/lib;@loader_path/../../torch/lib")
+            else()
+                  set(CMAKE_INSTALL_RPATH "$ORIGIN;$ORIGIN/lib;$ORIGIN/../torch/lib;$ORIGIN/../../torch/lib")
+            endif()
+      endif()
+else()
+      if(UNIX)
+            if(APPLE)
+                  set(CMAKE_INSTALL_RPATH "@loader_path;@loader_path/lib;${Torch_LINK_DIRECTORIES}")
+            else()
+                  set(CMAKE_INSTALL_RPATH "$ORIGIN;$ORIGIN/lib;${Torch_LINK_DIRECTORIES}")
+            endif()
+      endif()
+endif()
+
+# base library
+add_subdirectory(src/neml2)
+
+# testing
+option(NEML2_TESTS "Build NEML2 tests" ON)
+
+if(NEML2_TESTS)
+      add_subdirectory(tests)
+endif()
+
+# Doxygen
+option(NEML2_DOC "Build NEML2 documentation: doxygen" OFF)
+
+if(NEML2_DOC)
+      add_subdirectory(doc)
+endif()
+
+# Python binding
+option(NEML2_PYBIND "Build NEML2 Python binding" OFF)
+
+if(NEML2_PYBIND)
+      add_subdirectory(python)
+endif()

neml2-1.3.1/LICENSE

@@ -0,0 +1,23 @@
+Copyright 2023, UChicago Argonne, LLC
+All Rights Reserved
+Software Name: NEML2 -- the New Engineering material Model Library, version 2
+By: Argonne National Laboratory
+OPEN SOURCE LICENSE (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the "Software"), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+THE SOFTWARE.

neml2-1.3.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: neml2
+Version: 1.3.1
+Summary: GPU-enabled vectorized material modeling library
+Author-Email: Mark Messner <messner@anl.gov>, Gary Hu <thu@anl.gov>
+Requires-Python: >=3.8
+Requires-Dist: torch==2.2.1
+Description-Content-Type: text/markdown
+
+# Overview
+
+[![Documentation](https://github.com/reverendbedford/neml2/actions/workflows/build_docs.yml/badge.svg?branch=main)](https://reverendbedford.github.io/neml2/) [![tests](https://github.com/reverendbedford/neml2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/reverendbedford/neml2/actions/workflows/tests.yml)
+
+### The New Engineering Material model Library, version 2
+
+NEML2 is an offshoot of [NEML](https://github.com/Argonne-National-Laboratory/neml), an earlier constitutive modeling code developed at Argonne National Laboratory.
+Like NEML, NEML2 provides a flexible, modular way to build constitutive models from smaller blocks.
+Unlike NEML, NEML2 vectorizes the constitutive update to efficiently run on GPUs.  NEML2 is built on top of [PyTorch](https://pytorch.org/cppdocs/)
+to provide GPU support, but this also means that NEML2 models have all the features of a PyTorch module.  So, for example, users can take derivatives of the model with respect to parameters using automatic differentiation.
+
+NEML2 is provided as open source software under a MIT [license](https://raw.githubusercontent.com/reverendbedford/neml2/main/LICENSE).
+
+### Build and installation
+
+Building should be as easy as cloning the repository, configuring with CMake, building with `make`, and testing with `make test`.
+
+By default NEML2 will download the current CPU-only version of torch.  To instead use a system torch set CMake options `-DLIBTORCH_DIR=/path/to/your/torch`.  If you use the default build you will get a CPU-only version of torch and performance might suffer compared to a CUDA version.
+
+### NEML2 features and design philosophy
+
+- **Modular constitutive models**: NEML2 material models are modular – they are built up from smaller pieces into a complete model. For example, a model might piece together a temperature-dependent elasticity model, a yield surface, a flow rule, and several hardening rules. Each of these submodels is independent of the other objects so that, for example, switching from conventional J2 plasticity to a non J2 theory requires only a one line change in an input file, if the model is already implemented, or a relatively small amount of coding to add the new yield surface if it has not been implemented. All of these objects are interchangeable. For example, the damage, viscoplastic, and rate-independent plasticity models all use the same yield (flow) surfaces, hardening rules, elasticity models, and so on.
+- **Extensible constitutive models**: The library is structured so that adding a new feature to an existing material model should be as simple as possible and require as little code as possible. As part of this philosophy, the library only requires new components provide a few partial derivatives and NEML uses this information to assemble the Jacobian needed to do a fully implement, backward Euler integration of the ordinary differential equations comprising the model form and to provide the algorithmic tangent needed to integrate the model into an implicit finite element framework.  Moreover, in NEML2 implementations can forgo providing these partial derivatives and NEML2 will calculate them with automatic differentiation -- albeit at a significant performance cost.
+- **Friendly user interfaces**: There are two general ways to create and interface with NEML2 material models: the python bindings and the compiled library with [HIT](https://github.com/idaholab/moose/tree/next/framework/contrib/hit) input. The python bindings are generally used for creating, fitting, and debugging new material models. In python, a material model is built up object-by-object and assembled into a complete mathematical constitutive relation. NEML2 provides several python drivers for exercising these material models in simple loading configurations. These drivers include common test types, like uniaxial tension tests and strain-controlled cyclic fatigue tests along with more esoteric drivers supporting simplified models of high temperature pressure vessels, like n-bar models and generalized plane-strain axisymmetry. NEML2 provides a full Abaqus UMAT interface and examples of how to link the compiled library into C, C++, or Fortran codes. These interfaces can be used to call NEML2 models from finite element codes. When using the compiled library, NEML2 models can be created and archived using a hierarchical HIT format.
+- **Strict quality assurance**: NEML2 is developed under a strict quality assurance program. Because the NEML2 distribution does not provide full, parameterized models for any actual materials, ensuring the quality of the library is a verification problem – testing to make sure that NEML2 is correctly implementing the mathematical models – rather than a validation problem of comparing the results of a model to an actual test. This verification is done with extensive unit testing. This unit testing verifies every mathematical function and every derivative in the library is correctly implemented.
+- **CPU/GPU Vectorization**: NEML2 models can be vectorized, meaning that a large batch of constitutive models can be evaluated simultaneously. The vectorized model can be evaluated both on CPU and on GPU, with a unified, intuitive user interface.
+- **Flexible model composition**: NEML2 offers a more flexible way of composing models. Each individual model only defines the forward operator (and optionally its derivative) with a given set of inputs and outputs, without knowing anything a priori about how it is going to be used. When a set of models are *composed* together to form a composite model, dependencies among different models are automatically detected, registered, and resolved. The user has *complete control* over how NEML2 evaluates a set of models.
+- **Faster evaluation of chained models**: As a result the dependency resolution mentioned above, an optimal order of evaluating the composed model is used to perform the forward operation -- every model in the dependency graph is evaluated once and only once, avoiding any redundant calculations.
+- **General implicit update**: NEML2 offers a general interface for defining implicit models, unlike NEML which requires the implicit function to be in the form of an ODE.
+
+### Disclaimer
+
+NEML2 does not provide a database of models for any particular class of materials. There are many example materials contained in the library release. These models are included entirely for illustrative purposes and do not represent the response of any actual material.  Right now these models are solid mechanics constitutive models, providing the stress/strain response of materials.  However, NEML2 is general enough to build models of any type.

neml2-1.3.1/README.md

@@ -0,0 +1,33 @@
+# Overview
+
+[![Documentation](https://github.com/reverendbedford/neml2/actions/workflows/build_docs.yml/badge.svg?branch=main)](https://reverendbedford.github.io/neml2/) [![tests](https://github.com/reverendbedford/neml2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/reverendbedford/neml2/actions/workflows/tests.yml)
+
+### The New Engineering Material model Library, version 2
+
+NEML2 is an offshoot of [NEML](https://github.com/Argonne-National-Laboratory/neml), an earlier constitutive modeling code developed at Argonne National Laboratory.
+Like NEML, NEML2 provides a flexible, modular way to build constitutive models from smaller blocks.
+Unlike NEML, NEML2 vectorizes the constitutive update to efficiently run on GPUs.  NEML2 is built on top of [PyTorch](https://pytorch.org/cppdocs/)
+to provide GPU support, but this also means that NEML2 models have all the features of a PyTorch module.  So, for example, users can take derivatives of the model with respect to parameters using automatic differentiation.
+
+NEML2 is provided as open source software under a MIT [license](https://raw.githubusercontent.com/reverendbedford/neml2/main/LICENSE).
+
+### Build and installation
+
+Building should be as easy as cloning the repository, configuring with CMake, building with `make`, and testing with `make test`.
+
+By default NEML2 will download the current CPU-only version of torch.  To instead use a system torch set CMake options `-DLIBTORCH_DIR=/path/to/your/torch`.  If you use the default build you will get a CPU-only version of torch and performance might suffer compared to a CUDA version.
+
+### NEML2 features and design philosophy
+
+- **Modular constitutive models**: NEML2 material models are modular – they are built up from smaller pieces into a complete model. For example, a model might piece together a temperature-dependent elasticity model, a yield surface, a flow rule, and several hardening rules. Each of these submodels is independent of the other objects so that, for example, switching from conventional J2 plasticity to a non J2 theory requires only a one line change in an input file, if the model is already implemented, or a relatively small amount of coding to add the new yield surface if it has not been implemented. All of these objects are interchangeable. For example, the damage, viscoplastic, and rate-independent plasticity models all use the same yield (flow) surfaces, hardening rules, elasticity models, and so on.
+- **Extensible constitutive models**: The library is structured so that adding a new feature to an existing material model should be as simple as possible and require as little code as possible. As part of this philosophy, the library only requires new components provide a few partial derivatives and NEML uses this information to assemble the Jacobian needed to do a fully implement, backward Euler integration of the ordinary differential equations comprising the model form and to provide the algorithmic tangent needed to integrate the model into an implicit finite element framework.  Moreover, in NEML2 implementations can forgo providing these partial derivatives and NEML2 will calculate them with automatic differentiation -- albeit at a significant performance cost.
+- **Friendly user interfaces**: There are two general ways to create and interface with NEML2 material models: the python bindings and the compiled library with [HIT](https://github.com/idaholab/moose/tree/next/framework/contrib/hit) input. The python bindings are generally used for creating, fitting, and debugging new material models. In python, a material model is built up object-by-object and assembled into a complete mathematical constitutive relation. NEML2 provides several python drivers for exercising these material models in simple loading configurations. These drivers include common test types, like uniaxial tension tests and strain-controlled cyclic fatigue tests along with more esoteric drivers supporting simplified models of high temperature pressure vessels, like n-bar models and generalized plane-strain axisymmetry. NEML2 provides a full Abaqus UMAT interface and examples of how to link the compiled library into C, C++, or Fortran codes. These interfaces can be used to call NEML2 models from finite element codes. When using the compiled library, NEML2 models can be created and archived using a hierarchical HIT format.
+- **Strict quality assurance**: NEML2 is developed under a strict quality assurance program. Because the NEML2 distribution does not provide full, parameterized models for any actual materials, ensuring the quality of the library is a verification problem – testing to make sure that NEML2 is correctly implementing the mathematical models – rather than a validation problem of comparing the results of a model to an actual test. This verification is done with extensive unit testing. This unit testing verifies every mathematical function and every derivative in the library is correctly implemented.
+- **CPU/GPU Vectorization**: NEML2 models can be vectorized, meaning that a large batch of constitutive models can be evaluated simultaneously. The vectorized model can be evaluated both on CPU and on GPU, with a unified, intuitive user interface.
+- **Flexible model composition**: NEML2 offers a more flexible way of composing models. Each individual model only defines the forward operator (and optionally its derivative) with a given set of inputs and outputs, without knowing anything a priori about how it is going to be used. When a set of models are *composed* together to form a composite model, dependencies among different models are automatically detected, registered, and resolved. The user has *complete control* over how NEML2 evaluates a set of models.
+- **Faster evaluation of chained models**: As a result the dependency resolution mentioned above, an optimal order of evaluating the composed model is used to perform the forward operation -- every model in the dependency graph is evaluated once and only once, avoiding any redundant calculations.
+- **General implicit update**: NEML2 offers a general interface for defining implicit models, unlike NEML which requires the implicit function to be in the form of an ODE.
+
+### Disclaimer
+
+NEML2 does not provide a database of models for any particular class of materials. There are many example materials contained in the library release. These models are included entirely for illustrative purposes and do not represent the response of any actual material.  Right now these models are solid mechanics constitutive models, providing the stress/strain response of materials.  However, NEML2 is general enough to build models of any type.