Add the code for ALE large-deformation thermoplasticity

ALE_Finite_Strain_Plasticity/.gitignore

@@ -0,0 +1 @@
+build/

ALE_Finite_Strain_Plasticity/CMakeLists.txt

@@ -0,0 +1,60 @@
+##
+#  CMake script for the PlasticityLab project:
+##
+
+# Set the name of the project and target:
+SET(TARGET "PlasticityLab")
+
+# Declare all source files the target consists of. Here, this is only
+# the one step-X.cc file, but as you expand your project you may wish
+# to add other source files as well. If your project becomes much larger,
+# you may want to either replace the following statement by something like
+#  FILE(GLOB_RECURSE TARGET_SRC  "source/*.cc")
+#  FILE(GLOB_RECURSE TARGET_INC  "include/*.h")
+#  SET(TARGET_SRC ${TARGET_SRC}  ${TARGET_INC})
+# or switch altogether to the large project CMakeLists.txt file discussed
+# in the "CMake in user projects" page accessible from the "User info"
+# page of the documentation.
+FILE(GLOB_RECURSE TARGET_SRC  "./src/*.cpp")
+FILE(GLOB_RECURSE TARGET_INC  "./src/*.h")
+SET(TARGET_SRC ${TARGET_SRC}  ${TARGET_INC})
+
+# Define the output that should be cleaned:
+set(CLEAN_UP_FILES *.vtu *.pvtu *.visit)
+
+# Usually, you will not need to modify anything beyond this point...
+
+cmake_minimum_required(VERSION 3.13.4)
+
+find_package(deal.II 9.7.0
+  HINTS ${deal.II_DIR} ${DEAL_II_DIR} ../ ../../ $ENV{DEAL_II_DIR}
+  )
+if(NOT ${deal.II_FOUND})
+  message(FATAL_ERROR "\n"
+    "*** Could not locate a (sufficiently recent) version of deal.II. ***\n\n"
+    "You may want to either pass a flag -DDEAL_II_DIR=/path/to/deal.II to cmake\n"
+    "or set an environment variable \"DEAL_II_DIR\" that contains this path."
+    )
+endif()
+
+#
+# Are all dependencies fulfilled?
+#
+if(NOT DEAL_II_WITH_MPI OR NOT DEAL_II_WITH_P4EST OR NOT DEAL_II_WITH_TRILINOS)
+  message(FATAL_ERROR "
+Error! This project requires a deal.II library that was configured with the following options:
+    DEAL_II_WITH_MPI = ON
+    DEAL_II_WITH_P4EST = ON
+    DEAL_II_WITH_TRILINOS = ON
+However, the deal.II library found at ${DEAL_II_PATH} was configured with these options:
+    DEAL_II_WITH_MPI = ${DEAL_II_WITH_MPI}
+    DEAL_II_WITH_P4EST = ${DEAL_II_WITH_P4EST}
+    DEAL_II_WITH_TRILINOS = ${DEAL_II_WITH_TRILINOS}
+This conflicts with the requirements."
+    )
+endif()
+
+deal_ii_initialize_cached_variables()
+project(${TARGET} CXX)
+
+deal_ii_invoke_autopilot()

ALE_Finite_Strain_Plasticity/README.md

@@ -0,0 +1,68 @@
+# PlasticityLab: ALE finite-strain thermoplasticity (axisymmetric)
+## Overview
+
+This code-gallery entry provides a deal.II-based implementation of a large-deformation thermomechanical solver for finite-strain thermoplasticity, developed to support numerical simulation of severe-deformation metal forming processes and related problems involving strong thermomechanical coupling and viscoplastic flow.
+
+The solver implements a finite-strain associative coupled thermoplasticity model.
+
+## Key idea: ALE via incremental reference motion
+
+The solver incorporates an Arbitrary Lagrangian–Eulerian (ALE) formulation for coupled finite-strain thermoplasticity in which the motion of the reference configuration is represented incrementally through a reference velocity field. This avoids the need to explicitly track the deformation from the initial material configuration, either as a deformation field or through storing and updating the full deformation gradient history. 
+
+The method targets regimes where large accumulated strains can cause excessive mesh distortion in purely Lagrangian finite element simulations. The ALE formulation reduces sensitivity to mesh distortion and enables stable simulation without requiring prohibitively small time steps.
+
+## Physics and models
+### Finite-strain thermoplasticity
+
+The constitutive model is a finite-strain, associative, coupled thermoplasticity formulation based on a multiplicative decomposition of the deformation gradient and a J2 (von Mises) flow theory. The implementation supports viscoplastic behavior via rate-dependent flow stress models (including Johnson-Cook). 
+
+### Thermomechanical coupling
+
+The thermal problem is coupled to the mechanical response through plastic dissipation and heat conduction. 
+
+### Discretization and solution strategy (high level)
+
+Mixed finite element formulation to mitigate volumetric locking (Jacobian/pressure treated as additional unknowns).
+
+Newton-Raphson nonlinear solve with consistent tangent moduli (targeting second-order convergence behavior).
+
+Mechanical-thermal operator splitting per time step (mechanical, then thermal, then mechanical sub-step). 
+
+### Axisymmetric reduction and benchmark problems
+
+Although the formulation is derived for general 3D settings, the code uses an axisymmetric approximation for benchmark problems and representative manufacturing-process simulations.
+
+The entry validates and illustrates the approach using benchmark problems including:
+
+thermally triggered necking of a circular bar (thermoplasticity benchmark), 
+
+Taylor anvil impact of a circular bar (dynamic high-rate deformation benchmark),
+
+## To run
+```
+# in a build directory:
+$ cmake -DDEAL_II_DIR=<path-to-deal-ii> <path-to-entry>
+$ make release
+$ make -j 8 &&  mpirun -n 18 ./PlasticityLab
+```
+
+## Notes on configuration
+
+Geometry / triangulation: configured in PlasticityLabProgDrivers.cpp in run().
+
+Material model selection and parameters: configured in main.cpp. 
+
+Time step settings: configured in PlasticityLabProg.h. 
+
+## References
+```
+@article{HamedMcBrideReddy2023_ALE_Thermoplasticity_FrictionWelding,
+  author  = {Hamed, M. M. O. and McBride, A. T. and Reddy, B. D.},
+  title   = {An {ALE} approach for large-deformation thermoplasticity with application to friction welding},
+  journal = {Computational Mechanics},
+  volume  = {72},
+  pages   = {803--826},
+  year    = {2023},
+  doi     = {10.1007/s00466-023-02303-0}
+}
+```

ALE_Finite_Strain_Plasticity/doc/author

@@ -0,0 +1 @@
+Maien Hamed <maieneuro@gmail.com>

ALE_Finite_Strain_Plasticity/doc/build-on

@@ -0,0 +1 @@
+step-42

ALE_Finite_Strain_Plasticity/doc/dependencies

@@ -0,0 +1 @@
+DEAL_II_WITH_MPI DEAL_II_WITH_P4EST DEAL_II_WITH_TRILINOS

ALE_Finite_Strain_Plasticity/doc/entry-name

@@ -0,0 +1 @@
+An ALE approach for large-deformation thermoplasticity

ALE_Finite_Strain_Plasticity/doc/tooltip

@@ -0,0 +1 @@
+An implementation of a large-deformation arbitrary Lagrangian-Eulerian finite-strain thermoplasticity solver

ALE_Finite_Strain_Plasticity/src/BodyForceApplier.h

@@ -0,0 +1,51 @@
+/*
+ * BodyForceApplier.h
+ *
+ *  Created on: 14 Jan 2015
+ *      Author: maien
+ */
+
+#ifndef BODYFORCEAPPLIER_H_
+#define BODYFORCEAPPLIER_H_
+
+namespace PlasticityLab {
+
+  template <int dim, typename Number = double>
+  class BodyForceApplier {
+   public:
+    BodyForceApplier();
+    BodyForceApplier(int direction, Number bodyForceMagnitude = 0);
+    virtual ~BodyForceApplier();
+    inline Number apply(const unsigned int direction,
+                        const Number shapeFunctionValue,
+                        const Number JxW) const;
+   private:
+    const unsigned int direction;
+    const Number bodyForceMagnitude;
+  };
+
+
+  template <int dim, typename Number>
+  BodyForceApplier<dim, Number>::
+  BodyForceApplier(int direction, Number bodyForceMagnitude)
+    : direction(direction), bodyForceMagnitude(bodyForceMagnitude) {
+  }
+
+
+  template <int dim, typename Number>
+  BodyForceApplier<dim, Number>::~BodyForceApplier() {
+  }
+
+  template <int dim, typename Number>
+  Number BodyForceApplier<dim, Number>::
+  apply(const unsigned int direction,
+        const Number shapeFunctionValue,
+        const Number JxW) const {
+    if (this->direction == direction)
+      return -shapeFunctionValue * this->bodyForceMagnitude * JxW;
+    return 0.0;
+  }
+
+} /* namespace PlasticityLab */
+
+#endif /* BODYFORCEAPPLIER_H_ */

ALE_Finite_Strain_Plasticity/src/BoundaryUnidirectionalPenaltySpec.h

@@ -0,0 +1,40 @@
+/*
+ * BoundaryUnidirectionalPenaltySpec.h
+ *
+ *  Created on: 04 May 2021
+ *      Author: maien
+ */
+
+#ifndef BOUNDARYUNIDIRECTIONALPENALTYSPEC_H_
+#define BOUNDARYUNIDIRECTIONALPENALTYSPEC_H_
+
+namespace PlasticityLab {
+
+  template<typename Number = double>
+  class BoundaryUnidirectionalPenaltySpec {
+  public:
+    BoundaryUnidirectionalPenaltySpec(
+      unsigned int boundary_id,
+      Number reference_displacement_increment,
+      Number residual_force,
+      Number quadratic_spring_factor) :
+        boundary_id(boundary_id),
+        reference_displacement_increment(reference_displacement_increment),
+        residual_force(residual_force),
+        quadratic_spring_factor(quadratic_spring_factor) {}
+
+    unsigned int get_boundary_id() const { return boundary_id; }
+    Number get_reference_displacement_increment() const { return reference_displacement_increment; }
+    Number get_residual_force() const { return residual_force; }
+    Number get_quadratic_spring_factor() const { return quadratic_spring_factor; }
+
+  private:
+    const unsigned int boundary_id;
+    const Number quadratic_spring_factor;
+    const Number reference_displacement_increment;
+    const Number residual_force;
+  };
+
+} /* namespace PlasticityLab */
+
+#endif /* BOUNDARYUNIDIRECTIONALPENALTYSPEC_H_ */

ALE_Finite_Strain_Plasticity/src/Constants.h

@@ -0,0 +1,73 @@
+/*
+ * Constants.h
+ *
+ *  Created on: 10 Feb 2015
+ *      Author: maien
+ */
+
+#ifndef CONSTANTS_H_
+#define CONSTANTS_H_
+
+namespace PlasticityLab {
+
+
+  template <int dim, typename Number>
+  class Constants {
+   public:
+    inline static const Number one_third() {
+      return static_cast<Number>(0.33333333333333333333333333333333333333333333333333);
+    }
+
+    inline static const Number sqrt2thirds() {
+      return static_cast<Number>(0.81649658092772603273242802490196379732198249355222);
+    }
+
+    inline static const Number two_thirds() {
+      return static_cast<Number>(0.66666666666666666666666666666666666666666666666666);
+    }
+
+    inline static const Number sqrt_half() {
+      return static_cast<Number>(0.70710678118654752440084436210484903928483593768847);
+    }
+
+    inline static const Number sqrt_2() {
+      return static_cast<Number>(1.41421356237309504880168872420969807856967187537694);
+    }
+
+
+    inline static const Number one_over_dim() {
+      if(3==dim)
+        return static_cast<Number>(0.33333333333333333333333333333333333333333333333333);
+      else if (2==dim)
+        return static_cast<Number>(0.5);
+      else
+        return static_cast<Number>(1./static_cast<Number>(dim));
+    }
+
+    inline static const Number two_over_dim() {
+      if(3==dim)
+        return static_cast<Number>(0.66666666666666666666666666666666666666666666666666);
+      else if (2==dim)
+        return static_cast<Number>(1.0);
+      else
+        return static_cast<Number>(2./static_cast<Number>(dim));
+    }
+
+  };
+
+  inline void get_generalized_alpha_method_params(
+        double *alpha_m,
+        double *alpha_f,
+        double *gamma,
+        double *beta,
+        double rho_infty
+      ) {
+    *alpha_m = (2. * rho_infty - 1.)/(rho_infty + 1.);
+    *alpha_f = rho_infty / (rho_infty + 1.);
+    *gamma = 0.5 - *alpha_m + *alpha_f;
+    *beta = 0.25 * (1. - *alpha_m + *alpha_f) * (1. - *alpha_m + *alpha_f);
+  }
+
+} /* namespace PlasticityLab */
+
+#endif /* CONSTANTS_H_ */

ALE_Finite_Strain_Plasticity/src/ConstitModelUpdateFlags.h

@@ -0,0 +1,64 @@
+/*
+ * ConstitModelUpdateFlags.h
+ *
+ *  Created on: 04 Jan 2015
+ *      Author: maien
+ */
+
+#ifndef CONSTITMODELUPDATEFLAGS_H_
+#define CONSTITMODELUPDATEFLAGS_H_
+
+namespace PlasticityLab {
+
+  enum ConstitutiveModelUpdateFlags {
+    update_default = 0x0000,
+    update_pressure = 0x0001,
+    update_pressure_tangent = 0x0002,
+    update_stress_deviator = 0x0004,
+    update_stress_deviator_tangent = 0x0008,
+    update_heat_flux = 0x0010,
+    update_heat_flux_tangent = 0x0020,
+    update_elastic_entropy = 0x0040,
+    update_elastic_entropy_tangent = 0x0080,
+    update_mechanical_dissipation = 0x0100,
+    update_mechanical_dissipation_tangent = 0x0200,
+    update_thermoelastic_heating = 0x0400,
+    update_thermoelastic_heating_tangent = 0x0800,
+    update_stored_heat = 0x1000,
+    update_stored_heat_tangent = 0x2000,
+    update_material_point_history = 0x4000
+  };
+
+  inline
+  ConstitutiveModelUpdateFlags
+  operator | (ConstitutiveModelUpdateFlags f1, ConstitutiveModelUpdateFlags f2) {
+    return static_cast<ConstitutiveModelUpdateFlags> (
+             static_cast<unsigned int> (f1) |
+             static_cast<unsigned int> (f2));
+  }
+
+  inline
+  const ConstitutiveModelUpdateFlags &
+  operator |= (ConstitutiveModelUpdateFlags &f1, ConstitutiveModelUpdateFlags f2) {
+    f1 = f1 | f2;
+    return f1;
+  }
+
+  inline
+  ConstitutiveModelUpdateFlags
+  operator & (ConstitutiveModelUpdateFlags f1, ConstitutiveModelUpdateFlags f2) {
+    return static_cast<ConstitutiveModelUpdateFlags> (
+             static_cast<unsigned int> (f1) &
+             static_cast<unsigned int> (f2));
+  }
+
+  inline
+  const ConstitutiveModelUpdateFlags &
+  operator &= (ConstitutiveModelUpdateFlags &f1, ConstitutiveModelUpdateFlags f2) {
+    f1 = f1 & f2;
+    return f1;
+  }
+
+} /* namespace PlasticityLab */
+
+#endif /*CONSTITMODELUPDATEFLAGS_H_*/