Add Modular UMAT integration #61
Open
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Include 'simcoon.modular' in the conda.recipe/meta.yaml test.imports list so the conda build/test verifies the modular subpackage can be imported. This ensures the modular component is packaged and available during CI or conda package validation.
Introduce a new DamageMechanism implementing isotropic scalar continuum damage mechanics. Adds header and implementation files that integrate with StrainMechanism and InternalVariableCollection, register history variables (D, Y_max), compute the energy-based driving force Y = 0.5 * sigma : S : sigma, and evaluate damage via linear, exponential, power-law, and Weibull evolution laws. Includes damaged stiffness/tangent contributions, Jacobian/work computations, parameter configuration and basic validation, and caching of the compliance tensor.
Introduce PlasticityMechanism class (header + implementation) to provide a rate-independent plasticity strain mechanism for the modular UMAT. The new files combine a yield criterion, isotropic hardening and kinematic hardening (via factory-created hardening objects), register internal variables (p, EP and backstresses), and implement core routines: configure, register_variables, compute_constraints, compute_flow_directions, compute_jacobian_contribution, inelastic_strain, update, tangent_contribution and compute_work. The implementation caches flow direction and related quantities for Jacobian/tangent calculations, supports multiple yield/hardening types, and uses Armadillo vectors/matrices and the existing InternalVariableCollection API.
Introduce ElasticityModule (header + implementation) to encapsulate linear elastic behavior for the modular UMAT. Supports isotropic, cubic (EnuG or Cii conventions), transversely isotropic, and orthotropic configurations via configure_* helpers and a configure(type, props, offset) convenience. Stores 6x6 stiffness (L) and compliance (M) matrices, 6-component CTE vector (alpha), and provides derived helpers damaged_L(d) and thermal_strain(DT). Uses Armadillo types and existing constitutive functions (L_iso/M_iso, L_cubic/M_cubic, L_isotrans/M_isotrans, L_ortho/M_ortho). Adds basic validation (configured_ flag) and a constexpr props_count helper.
Introduce modular hardening framework: new header and implementation for isotropic and kinematic hardening models. Implements No/Linear/Power-law/Voce/Combined-Voce isotropic models and No/Prager/Armstrong–Frederick/Chaboche kinematic models, with factory create() functions, property parsing (configure), evaluation (R, dR/dp), internal-variable registration, backstress accumulation, flow rules and update routines. Uses Armadillo and InternalVariableCollection for vector storage and exposes props_count helpers to consume material property arrays.
Add a type-safe InternalVariable class to support constitutive-model state storage. New files include/include/simcoon/Continuum_mechanics/Umat/Modular/internal_variable.hpp and src/Continuum_mechanics/Umat/Modular/internal_variable.cpp implement scalar, 6-component Voigt vector, and 6x6 matrix types with start/current state tracking, delta computation, rotation/objectivity (uses rotate_strain / rotateL), and pack/unpack serialization to a flat statev array with configurable offset. Uses Armadillo, performs input validation, and throws on type mismatches. Intended for use in UMAT modular constitutive implementations.
Introduce InternalVariableCollection (header and implementation) to manage multiple InternalVariable instances for modular UMAT models. Provides named registration (scalar/6-vector/6x6-matrix), automatic statev offset computation, pack/unpack, rotation, start/reset helpers, iteration, and utility functions (names, clear). Uses unique_ptr storage (non-copyable, moveable), throws on invalid access/duplicate names, and depends on Armadillo.
Introduce a composable ModularUMAT class and standalone umat_modular function to orchestrate elasticity and multiple strain mechanisms (plasticity, viscoelasticity, damage). Adds public configuration APIs (set_elasticity, add_plasticity/add_viscoelasticity/add_damage, configure_from_props), initialization and state handling (internal variable collection), the main run() entry that performs elastic prediction, return mapping (Newton + Fischer–Burmeister), consistent tangent computation, and work calculations. Implements compute_tangent and return_mapping, and integrates with existing mechanism classes and numeric solver utilities. Files added: include/.../modular_umat.hpp and src/.../modular_umat.cpp (GPL header included).
Introduce a new header defining the StrainMechanism abstract base class for modular UMATs. Adds MechanismType enum and a comprehensive interface for pluggable strain mechanisms (configuration, variable registration, constraint evaluation, flow directions, Jacobian contributions, inelastic strain, internal variable updates, tangent contributions, and work decomposition). Uses Armadillo and InternalVariableCollection and includes GPL license header; intended to standardize integration of plasticity, viscoelasticity, damage, etc.
Introduce ViscoelasticMechanism implementing a generalized Maxwell (Prony series) viscoelastic branch model. Adds header and source with configuration, internal-variable registration, constraint evaluation, flow directions, Jacobian contribution, inelastic strain accumulation, update routine, tangent modification and work computation. Supports N Prony terms, registers one viscous strain vector per branch, reads g_i and tau_i from property vector, and uses an optional reference stiffness (L_0) / compliance for branch targets. Includes basic runtime checks (positive tau) and a simple algorithmic tangent and update/constraint approximations (implicit exponential integration and norm-based constraints). Files use Armadillo and include GPL license headers.
Introduce YieldCriterion class (header and implementation) to provide a modular wrapper around existing Eq_stress/dEq_stress criterion functions for UMAT. Adds YieldType enum (VON_MISES, TRESCA, DRUCKER, HILL, DFA, ANISOTROPIC), configuration helpers (including configure from a props vector with offset), parameter storage via arma::vec, and public APIs to compute equivalent_stress, flow_direction and plastic_flow (with optional backstress shift). Includes a constexpr props_count utility and runtime checks that the criterion is configured; integration relies on simcoon/Continuum_mechanics/Functions/criteria.hpp.
Introduce a new simcoon.modular module implementing a composable UMAT material system. Adds enums and dataclasses for elasticity (isotropic, cubic, transverse isotropic, orthotropic), yield criteria (VonMises, Tresca, Drucker, Hill, DFA, anisotropic), isotropic and kinematic hardening laws (linear, power-law, Voce, combined Voce, Prager, Armstrong-Frederick, Chaboche), and mechanisms (Plasticity, Viscoelasticity with Prony series, Damage). Implements ModularMaterial to assemble a flat props array (for the C++ "MODUL" UMAT), compute nprops/nstatev, provide human-readable summaries, and includes convenience factory functions (elastic_model, elastoplastic_model, viscoelastic_model).
Add an explicit `from simcoon import modular` to simcoon.__init__ so the `simcoon.modular` submodule is available to consumers when importing the package. This makes the modular API accessible without requiring an extra import.
Delete generated test output files from testBin/Umats/UMEXT/results: results_job_global-0.txt and results_job_local-0.txt. These are result artifacts (deleted mode 100755) and are not intended to be tracked in source control.
Add comprehensive GTest unit tests for the Modular UMAT implementation (test/Libraries/Umat/Modular/Tmodular_umat.cpp) and register the new test in test/CMakeLists.txt. The tests cover InternalVariable and InternalVariableCollection, ElasticityModule (isotropic/cubic/CTE), YieldCriterion (von Mises), Isotropic and Kinematic hardening models, PlasticityMechanism behavior, ModularUMAT initialization/run behavior, and an integration test for uniaxial tension. This provides broad verification of elastic/plastic responses, packing/unpacking of state variables, hardening laws, and consistency of tangents and stresses.
Integrate the new modular UMAT into the project: add modular_umat includes to the Python wrapper and smart UMAT selector, register the "MODUL" UMAT id in both mappings (30 for Python wrapper, 200 for smart selector), and add case branches to call umat_modular accordingly. Update CMakeLists to include the Modular UMAT source files (internal_variable, elasticity_module, yield_criterion, hardening, plasticity_mechanism, viscoelastic_mechanism, damage_mechanism, and modular_umat) so the modular implementation is built. This wires the composable constitutive model into the build, runtime selection, and Python bindings.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.