DAMASK_EICMD/src/phase_mechanical_plastic_ki...

!--------------------------------------------------------------------------------------------------
!> @author Philip Eisenlohr, Michigan State University
!> @author Zhuowen Zhao, Michigan State University
!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH
!> @brief  Phenomenological crystal plasticity using a power-law formulation for the shear rates
!! and a Voce-type kinematic hardening rule.
!--------------------------------------------------------------------------------------------------
submodule(phase:plastic) kinehardening

  type :: tParameters
    real(pREAL),              allocatable, dimension(:) :: &
      dot_gamma_0, &                                                                                !< reference shear strain rate for slip
      n, &                                                                                          !< stress exponent for slip
      h_0_xi, &                                                                                     !< initial hardening rate of forest stress per slip family
                                                                                                    !! θ_0,for
      h_0_chi, &                                                                                    !< initial hardening rate of back stress per slip family
                                                                                                    !! θ_0,bs
      h_inf_xi, &                                                                                   !< asymptotic hardening rate of forest stress per slip family
                                                                                                    !! θ_1,for
      h_inf_chi, &                                                                                  !< asymptotic hardening rate of back stress per slip family
                                                                                                    !! θ_1,bs
      xi_inf, &                                                                                     !< back-extrapolated forest stress from terminal linear hardening
      chi_inf                                                                                       !< back-extrapolated back stress from terminal linear hardening
    real(pREAL),              allocatable, dimension(:,:) :: &
      h_sl_sl                                                                                       !< slip resistance change per slip activity
    real(pREAL),              allocatable, dimension(:,:,:) :: &
      P, &
      P_nS_pos, &
      P_nS_neg
    integer :: &
      sum_N_sl
    character(len=pSTRLEN), allocatable, dimension(:) :: &
      output
    character(len=:),       allocatable, dimension(:) :: &
      systems_sl
  end type tParameters

  type :: tIndexDotState
    integer, dimension(2) :: &
      xi, &
      chi, &
      gamma
  end type tIndexDotState

  type :: tKinehardeningState
    real(pREAL), pointer, dimension(:,:) :: &
      xi, &                                                                                         !< forest stress
                                                                                                    !! τ_for
      chi, &                                                                                        !< back stress
                                                                                                    !! τ_bs
      chi_flip, &                                                                                   !< back stress at last reversal of stress sense
                                                                                                    !! χ_0
      gamma, &                                                                                      !< accumulated (absolute) shear
      gamma_flip, &                                                                                 !< accumulated shear at last reversal of stress sense
                                                                                                    !! γ_0
      sgn_gamma                                                                                     !< sense of acting shear stress (-1 or +1)
  end type tKinehardeningState

!--------------------------------------------------------------------------------------------------
! containers for parameters and state
  type(tParameters),         allocatable, dimension(:) :: param
  type(tIndexDotState),      allocatable, dimension(:) :: indexDotState
  type(tKinehardeningState), allocatable, dimension(:) :: state, deltaState

contains


!--------------------------------------------------------------------------------------------------
!> @brief Perform module initialization.
!> @details reads in material parameters, allocates arrays, and does sanity checks
!--------------------------------------------------------------------------------------------------
module function plastic_kinehardening_init() result(myPlasticity)

  logical, dimension(:), allocatable :: myPlasticity
  integer :: &
    ph, o,  &
    N_fam, &
    Nmembers, &
    sizeState, sizeDeltaState, sizeDotState, &
    startIndex, endIndex
  integer,     dimension(:), allocatable :: &
    N_sl
  real(pREAL), dimension(:), allocatable :: &
    xi_0                                                                                            !< initial forest stress
                                                                                                    !! τ_for,0
  real(pREAL), dimension(:,:), allocatable :: &
    a_nS                                                                                            !< non-Schmid coefficients
  character(len=:), allocatable :: &
    refs, &
    extmsg
  type(tDict), pointer :: &
    phases, &
    phase, &
    mech, &
    pl


  myPlasticity = plastic_active('kinehardening')
  if (count(myPlasticity) == 0) return

  print'(/,1x,a)', '<<<+-  phase:mechanical:plastic:kinehardening init  -+>>>'

  print'(/,1x,a)', 'J.A. Wollmershauser et al., International Journal of Fatigue 36:181–193, 2012'
  print'(  1x,a)', 'https://doi.org/10.1016/j.ijfatigue.2011.07.008'

  print'(/,1x,a,1x,i0)', '# phases:',count(myPlasticity); flush(IO_STDOUT)

  phases => config_material%get_dict('phase')
  allocate(param(phases%length))
  allocate(indexDotState(phases%length))
  allocate(state(phases%length))
  allocate(deltaState(phases%length))
  extmsg = ''

  do ph = 1, phases%length
    if (.not. myPlasticity(ph)) cycle

    associate(prm => param(ph), &
              stt => state(ph), dlt => deltaState(ph), &
              idx_dot => indexDotState(ph))

    phase => phases%get_dict(ph)
    mech => phase%get_dict('mechanical')
    pl => mech%get_dict('plastic')

    print'(/,1x,a,1x,i0,a)', 'phase',ph,': '//phases%key(ph)
    refs = config_listReferences(pl,indent=3)
    if (len(refs) > 0) print'(/,1x,a)', refs

#if defined (__GFORTRAN__)
    prm%output = output_as1dStr(pl)
#else
    prm%output = pl%get_as1dStr('output',defaultVal=emptyStrArray)
#endif

!--------------------------------------------------------------------------------------------------
! slip related parameters
    N_sl         = pl%get_as1dInt('N_sl',defaultVal=emptyIntArray)
    prm%sum_N_sl = sum(abs(N_sl))
    slipActive: if (prm%sum_N_sl > 0) then
      N_fam = size(N_sl)
      prm%systems_sl = crystal_labels_slip(N_sl,phase_lattice(ph))
      prm%P = crystal_SchmidMatrix_slip(N_sl,phase_lattice(ph),phase_cOverA(ph))

      if (phase_lattice(ph) == 'cI') then
        allocate(a_nS(3,size(pl%get_as1dReal('a_nonSchmid_110',defaultVal=emptyRealArray))),source=0.0_pREAL)
        a_nS(1,:) = pl%get_as1dReal('a_nonSchmid_110',defaultVal=emptyRealArray)
        prm%P_nS_pos = crystal_SchmidMatrix_slip(N_sl,phase_lattice(ph),phase_cOverA(ph),nonSchmidCoefficients=a_nS,sense=+1)
        prm%P_nS_neg = crystal_SchmidMatrix_slip(N_sl,phase_lattice(ph),phase_cOverA(ph),nonSchmidCoefficients=a_nS,sense=-1)
      else
        prm%P_nS_pos = +prm%P
        prm%P_nS_neg = -prm%P
      end if

      prm%h_sl_sl = crystal_interaction_SlipBySlip(N_sl,pl%get_as1dReal('h_sl-sl'), &
                                                   phase_lattice(ph))

      xi_0            = math_expand(pl%get_as1dReal('xi_0',        requiredSize=N_fam),N_sl)
      prm%dot_gamma_0 = math_expand(pl%get_as1dReal('dot_gamma_0', requiredSize=N_fam),N_sl)
      prm%n           = math_expand(pl%get_as1dReal('n',           requiredSize=N_fam),N_sl)
      prm%xi_inf      = math_expand(pl%get_as1dReal('xi_inf',      requiredSize=N_fam),N_sl)
      prm%chi_inf     = math_expand(pl%get_as1dReal('chi_inf',     requiredSize=N_fam),N_sl)
      prm%h_0_xi      = math_expand(pl%get_as1dReal('h_0_xi',      requiredSize=N_fam),N_sl)
      prm%h_0_chi     = math_expand(pl%get_as1dReal('h_0_chi',     requiredSize=N_fam),N_sl)
      prm%h_inf_xi    = math_expand(pl%get_as1dReal('h_inf_xi',    requiredSize=N_fam),N_sl)
      prm%h_inf_chi   = math_expand(pl%get_as1dReal('h_inf_chi',   requiredSize=N_fam),N_sl)

!--------------------------------------------------------------------------------------------------
!  sanity checks
      if (any(prm%dot_gamma_0  <= 0.0_pREAL))  extmsg = trim(extmsg)//' dot_gamma_0'
      if (any(prm%n            <= 0.0_pREAL))  extmsg = trim(extmsg)//' n'
      if (any(xi_0             <= 0.0_pREAL))  extmsg = trim(extmsg)//' xi_0'
      if (any(prm%xi_inf       <= 0.0_pREAL))  extmsg = trim(extmsg)//' xi_inf'
      if (any(prm%chi_inf      <= 0.0_pREAL))  extmsg = trim(extmsg)//' chi_inf'

    else slipActive
      xi_0 = emptyRealArray
      allocate(prm%dot_gamma_0, &
               prm%n, &
               prm%xi_inf, &
               prm%chi_inf, &
               prm%h_0_xi, &
               prm%h_0_chi, &
               prm%h_inf_xi, &
               prm%h_inf_chi, &
               source=emptyRealArray)
      allocate(prm%h_sl_sl(0,0))
    end if slipActive

!--------------------------------------------------------------------------------------------------
! allocate state arrays
    Nmembers = count(material_ID_phase == ph)
    sizeDotState   = prm%sum_N_sl * size(['xi   ',&
                                          'chi  ',&
                                          'gamma'])
    sizeDeltaState = prm%sum_N_sl * size(['sgn_gamma ',&
                                          'chi_flip  ',&
                                          'gamma_flip'])
    sizeState = sizeDotState + sizeDeltaState

    call phase_allocateState(plasticState(ph),Nmembers,sizeState,sizeDotState,sizeDeltaState)
    deallocate(plasticState(ph)%dotState) ! ToDo: remove dotState completely

!--------------------------------------------------------------------------------------------------
! state aliases and initialization
    startIndex = 1
    endIndex   = prm%sum_N_sl
    idx_dot%xi = [startIndex,endIndex]
    stt%xi => plasticState(ph)%state(startIndex:endIndex,:)
    stt%xi = spread(xi_0, 2, Nmembers)
    plasticState(ph)%atol(startIndex:endIndex) = pl%get_asReal('atol_xi',defaultVal=1.0_pREAL)
    if (any(plasticState(ph)%atol(startIndex:endIndex) < 0.0_pREAL)) extmsg = trim(extmsg)//' atol_xi'

    startIndex = endIndex + 1
    endIndex   = endIndex + prm%sum_N_sl
    idx_dot%chi = [startIndex,endIndex]
    stt%chi => plasticState(ph)%state(startIndex:endIndex,:)
    plasticState(ph)%atol(startIndex:endIndex) = pl%get_asReal('atol_xi',defaultVal=1.0_pREAL)

    startIndex = endIndex + 1
    endIndex   = endIndex + prm%sum_N_sl
    idx_dot%gamma = [startIndex,endIndex]
    stt%gamma => plasticState(ph)%state(startIndex:endIndex,:)
    plasticState(ph)%atol(startIndex:endIndex) = pl%get_asReal('atol_gamma',defaultVal=1.0e-6_pREAL)
    if (any(plasticState(ph)%atol(startIndex:endIndex) < 0.0_pREAL)) extmsg = trim(extmsg)//' atol_gamma'

    o = plasticState(ph)%offsetDeltaState
    startIndex = endIndex + 1
    endIndex   = endIndex + prm%sum_N_sl
    stt%sgn_gamma => plasticState(ph)%state     (startIndex  :endIndex  ,:)
    dlt%sgn_gamma => plasticState(ph)%deltaState(startIndex-o:endIndex-o,:)

    startIndex = endIndex + 1
    endIndex   = endIndex +  prm%sum_N_sl
    stt%chi_flip => plasticState(ph)%state     (startIndex  :endIndex  ,:)
    dlt%chi_flip => plasticState(ph)%deltaState(startIndex-o:endIndex-o,:)

    startIndex = endIndex + 1
    endIndex   = endIndex +  prm%sum_N_sl
    stt%gamma_flip => plasticState(ph)%state     (startIndex  :endIndex  ,:)
    dlt%gamma_flip => plasticState(ph)%deltaState(startIndex-o:endIndex-o,:)

    end associate

!--------------------------------------------------------------------------------------------------
!  exit if any parameter is out of range
    if (extmsg /= '') call IO_error(211,ext_msg=trim(extmsg))

  end do


end function plastic_kinehardening_init


!--------------------------------------------------------------------------------------------------
!> @brief Calculate plastic velocity gradient and its tangent.
!--------------------------------------------------------------------------------------------------
pure module subroutine kinehardening_LpAndItsTangent(Lp,dLp_dMp, Mp,ph,en)

  real(pREAL), dimension(3,3),     intent(out) :: &
    Lp                                                                                              !< plastic velocity gradient
  real(pREAL), dimension(3,3,3,3), intent(out) :: &
    dLp_dMp                                                                                         !< derivative of Lp with respect to the Mandel stress

  real(pREAL), dimension(3,3),     intent(in) :: &
    Mp                                                                                              !< Mandel stress
  integer,                         intent(in) :: &
    ph, &
    en

  integer :: &
    i,k,l,m,n
  real(pREAL), dimension(param(ph)%sum_N_sl) :: &
    dot_gamma, ddot_gamma_dtau
  real(pREAL), dimension(3,3,param(ph)%sum_N_sl) :: &
    P_nS


  Lp = 0.0_pREAL
  dLp_dMp = 0.0_pREAL

  associate(prm => param(ph))

    call kinetics(Mp,ph,en, dot_gamma,ddot_gamma_dtau)
    P_nS = merge(prm%P_nS_pos,prm%P_nS_neg, spread(spread(dot_gamma,1,3),2,3)>0.0_pREAL)            ! faster than 'merge' in loop
    do i = 1, prm%sum_N_sl
      Lp = Lp + dot_gamma(i)*prm%P(1:3,1:3,i)
      forall (k=1:3,l=1:3,m=1:3,n=1:3) &
        dLp_dMp(k,l,m,n) = dLp_dMp(k,l,m,n) &
                         + ddot_gamma_dtau(i) * prm%P(k,l,i) * P_nS(m,n,i)
    end do

  end associate

end subroutine kinehardening_LpAndItsTangent


!--------------------------------------------------------------------------------------------------
!> @brief Calculate the rate of change of microstructure.
!--------------------------------------------------------------------------------------------------
module function plastic_kinehardening_dotState(Mp,ph,en) result(dotState)

  real(pREAL), dimension(3,3),  intent(in) :: &
    Mp                                                                                              !< Mandel stress
  integer,                      intent(in) :: &
    ph, &
    en
  real(pREAL), dimension(plasticState(ph)%sizeDotState) :: &
    dotState

  real(pREAL) :: &
    sumGamma


  associate(prm => param(ph), stt => state(ph), &
            dot_xi => dotState(IndexDotState(ph)%xi(1):IndexDotState(ph)%xi(2)),&
            dot_chi => dotState(IndexDotState(ph)%chi(1):IndexDotState(ph)%chi(2)),&
            dot_gamma => dotState(IndexDotState(ph)%gamma(1):IndexDotState(ph)%gamma(2)))

    call kinetics(Mp,ph,en, dot_gamma)
    sumGamma = sum(stt%gamma(:,en))
    dot_gamma = abs(dot_gamma)


    dot_xi = matmul(prm%h_sl_sl,dot_gamma) &
           * ( prm%h_inf_xi &
               + ( prm%h_0_xi  &
                 - prm%h_inf_xi * (1_pREAL -sumGamma*prm%h_0_xi/prm%xi_inf) ) &
               *                       exp(-sumGamma*prm%h_0_xi/prm%xi_inf) &
             )

    dot_chi = stt%sgn_gamma(:,en)*dot_gamma &
            * ( prm%h_inf_chi &
               + ( prm%h_0_chi &
                 - prm%h_inf_chi*(1_pREAL -(stt%gamma(:,en)-stt%gamma_flip(:,en))*prm%h_0_chi/(prm%chi_inf+stt%chi_flip(:,en))) ) &
               *                      exp(-(stt%gamma(:,en)-stt%gamma_flip(:,en))*prm%h_0_chi/(prm%chi_inf+stt%chi_flip(:,en))) &
              )

  end associate

end function plastic_kinehardening_dotState


!--------------------------------------------------------------------------------------------------
!> @brief Calculate (instantaneous) incremental change of microstructure.
!--------------------------------------------------------------------------------------------------
module subroutine plastic_kinehardening_deltaState(Mp,ph,en)

  real(pREAL), dimension(3,3),  intent(in) :: &
    Mp                                                                                              !< Mandel stress
  integer,                      intent(in) :: &
    ph, &
    en

  real(pREAL), dimension(param(ph)%sum_N_sl) :: &
    dot_gamma, &
    sgn_gamma


  associate(prm => param(ph), stt => state(ph), dlt => deltaState(ph))

    call kinetics(Mp,ph,en, dot_gamma)
    sgn_gamma = merge(state(ph)%sgn_gamma(:,en), &
                      sign(1.0_pREAL,dot_gamma), &
                      dEq0(dot_gamma,1e-10_pREAL))

    where(dNeq(sgn_gamma,stt%sgn_gamma(:,en),0.1_pREAL)) ! ToDo sgn_gamma*stt%sgn_gamma(:,en)<0
      dlt%sgn_gamma (:,en) = sgn_gamma            - stt%sgn_gamma (:,en)
      dlt%chi_flip  (:,en) = abs(stt%chi  (:,en)) - stt%chi_flip  (:,en)
      dlt%gamma_flip(:,en) =     stt%gamma(:,en)  - stt%gamma_flip(:,en)
    else where
      dlt%sgn_gamma (:,en) = 0.0_pREAL
      dlt%chi_flip  (:,en) = 0.0_pREAL
      dlt%gamma_flip(:,en) = 0.0_pREAL
    end where

  end associate

end subroutine plastic_kinehardening_deltaState


!--------------------------------------------------------------------------------------------------
!> @brief Write results to HDF5 output file.
!--------------------------------------------------------------------------------------------------
module subroutine plastic_kinehardening_result(ph,group)

  integer,          intent(in) :: ph
  character(len=*), intent(in) :: group

  integer :: ou


  associate(prm => param(ph), stt => state(ph))

    do ou = 1,size(prm%output)

      select case(trim(prm%output(ou)))

        case ('xi')
          call result_writeDataset(stt%xi,group,trim(prm%output(ou)), &
                                   'forest stress','Pa',prm%systems_sl)
        case ('chi')
          call result_writeDataset(stt%chi,group,trim(prm%output(ou)), &
                                   'back stress','Pa',prm%systems_sl)
        case ('sgn(gamma)')
          call result_writeDataset(int(stt%sgn_gamma),group,trim(prm%output(ou)), &
                                   'sense of shear','1',prm%systems_sl)
        case ('chi_flip')
          call result_writeDataset(stt%chi_flip,group,trim(prm%output(ou)), &
                                   'back stress at last reversal of stress sense','Pa',prm%systems_sl)
        case ('gamma_flip')
          call result_writeDataset(stt%gamma_flip,group,trim(prm%output(ou)), &
                                   'plastic shear at last reversal of stress sense','1',prm%systems_sl)
        case ('gamma')
          call result_writeDataset(stt%gamma,group,trim(prm%output(ou)), &
                                   'plastic shear','1',prm%systems_sl)
      end select

    end do

  end associate

end subroutine plastic_kinehardening_result


!--------------------------------------------------------------------------------------------------
!> @brief Calculate shear rates on slip systems and their derivatives with respect to resolved
!         stress.
!> @details: Derivatives are calculated only optionally.
! NOTE: Contrary to common convention, here the result (i.e. intent(out)) variables have to be put
! at the end since some of them are optional.
!--------------------------------------------------------------------------------------------------
pure subroutine kinetics(Mp,ph,en, &
                         dot_gamma,ddot_gamma_dtau)

  real(pREAL), dimension(3,3),                           intent(in) :: &
    Mp                                                                                              !< Mandel stress
  integer,                                               intent(in) :: &
    ph, &
    en

  real(pREAL), dimension(param(ph)%sum_N_sl),           intent(out) :: &
    dot_gamma
  real(pREAL), dimension(param(ph)%sum_N_sl), optional, intent(out) :: &
    ddot_gamma_dtau

  real(pREAL), dimension(param(ph)%sum_N_sl) :: &
    tau_pos, &
    tau_neg
  integer :: i


  associate(prm => param(ph), stt => state(ph))

    tau_pos = [(math_tensordot(Mp,prm%P_nS_pos(1:3,1:3,i)) - stt%chi(i,en),i=1,prm%sum_N_sl)]
    tau_neg = [(math_tensordot(Mp,prm%P_nS_neg(1:3,1:3,i)) + stt%chi(i,en),i=1,prm%sum_N_sl)]

    dot_gamma = merge(+1.0_pREAL,-1.0_pREAL, tau_pos>tau_neg) &
              * prm%dot_gamma_0  &
              * (max(tau_pos,tau_neg)/stt%xi(:,en))**prm%n

    if (present(ddot_gamma_dtau)) then
      where(dNeq0(dot_gamma))
        ddot_gamma_dtau = dot_gamma*prm%n/max(tau_pos,tau_neg)
      else where
        ddot_gamma_dtau = 0.0_pREAL
      end where
    end if

  end associate

end subroutine kinetics

end submodule kinehardening
-fixed backstress rate of change based on its own slip system evolution and its sense 
											
										
										
											2017-11-14 22:55:55 +05:30
+								!--------------------------------------------------------------------------------------------------
-												Fixed a physics issue: sense change with respect to difference between resolved stress and backstress

											
										
										
											2018-02-15 08:43:10 +05:30
+								!> @author Philip Eisenlohr, Michigan State University
-fixed backstress rate of change based on its own slip system evolution and its sense 
											
										
										
											2017-11-14 22:55:55 +05:30
+								!> @author Zhuowen Zhao, Michigan State University
-												polishing

											
										
										
											2018-11-25 15:44:09 +05:30
+								!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								!> @brief  Phenomenological crystal plasticity using a power-law formulation for the shear rates
 								!! and a Voce-type kinematic hardening rule.
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
+								!--------------------------------------------------------------------------------------------------
-												[skip sc] more systematic naming

module name 'damagee' gets extra e for the moment to avoid conflict with
global variable 'damage'

											
										
										
											2021-01-27 01:22:48 +05:30
+								submodule(phase:plastic) kinehardening
-												don't clutter the code with useless stuff

we only need to be more strict about prefixing
functions/subroutines/variables to see in which module they reside

											
										
										
											2019-05-17 02:26:48 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  type :: tParameters
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    real(pREAL),              allocatable, dimension(:) :: &
-												per-family parameters for kinehardening

											
										
										
											2023-08-11 20:06:03 +05:30
+								      dot_gamma_0, &                                                                                !< reference shear strain rate for slip
 								      n, &                                                                                          !< stress exponent for slip
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								      h_0_xi, &                                                                                     !< initial hardening rate of forest stress per slip family
 								                                                                                                    !! θ_0,for
 								      h_0_chi, &                                                                                    !< initial hardening rate of back stress per slip family
 								                                                                                                    !! θ_0,bs
 								      h_inf_xi, &                                                                                   !< asymptotic hardening rate of forest stress per slip family
 								                                                                                                    !! θ_1,for
 								      h_inf_chi, &                                                                                  !< asymptotic hardening rate of back stress per slip family
 								                                                                                                    !! θ_1,bs
 								      xi_inf, &                                                                                     !< back-extrapolated forest stress from terminal linear hardening
 								      chi_inf                                                                                       !< back-extrapolated back stress from terminal linear hardening
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    real(pREAL),              allocatable, dimension(:,:) :: &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								      h_sl_sl                                                                                       !< slip resistance change per slip activity
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    real(pREAL),              allocatable, dimension(:,:,:) :: &
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								      P, &
-												following paper

											
										
										
											2021-07-21 19:59:57 +05:30
+								      P_nS_pos, &
 								      P_nS_neg
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    integer :: &
-												consistent name 'ph' and cleaning

											
										
										
											2021-02-16 20:36:09 +05:30
+								      sum_N_sl
-												consistent and short

											
										
										
											2023-06-04 10:47:38 +05:30
+								    character(len=pSTRLEN), allocatable, dimension(:) :: &
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								      output
-												consistent and short

											
										
										
											2023-06-04 10:47:38 +05:30
+								    character(len=:),       allocatable, dimension(:) :: &
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
+								      systems_sl
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  end type tParameters
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								  type :: tIndexDotState
 								    integer, dimension(2) :: &
 								      xi, &
 								      chi, &
 								      gamma
 								  end type tIndexDotState
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  type :: tKinehardeningState
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    real(pREAL), pointer, dimension(:,:) :: &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								      xi, &                                                                                         !< forest stress
 								                                                                                                    !! τ_for
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								      chi, &                                                                                        !< back stress
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								                                                                                                    !! τ_bs
 								      chi_flip, &                                                                                   !< back stress at last reversal of stress sense
 								                                                                                                    !! χ_0
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								      gamma, &                                                                                      !< accumulated (absolute) shear
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								      gamma_flip, &                                                                                 !< accumulated shear at last reversal of stress sense
 								                                                                                                    !! γ_0
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								      sgn_gamma                                                                                     !< sense of acting shear stress (-1 or +1)
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  end type tKinehardeningState
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												make similarity of state/param structure clear

											
										
										
											2019-01-13 21:33:49 +05:30
+								!--------------------------------------------------------------------------------------------------
 								! containers for parameters and state
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  type(tParameters),         allocatable, dimension(:) :: param
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								  type(tIndexDotState),      allocatable, dimension(:) :: indexDotState
 								  type(tKinehardeningState), allocatable, dimension(:) :: state, deltaState
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
 								contains
 								!--------------------------------------------------------------------------------------------------
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								!> @brief Perform module initialization.
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
+								!> @details reads in material parameters, allocates arrays, and does sanity checks
 								!--------------------------------------------------------------------------------------------------
-												better print then write

- shorter, always writes to STDOUT

also, report only details (paper) of active models

											
										
										
											2020-09-14 00:30:34 +05:30
+								module function plastic_kinehardening_init() result(myPlasticity)
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								  logical, dimension(:), allocatable :: myPlasticity
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  integer :: &
-												consistent name 'ph' and cleaning

											
										
										
											2021-02-16 20:36:09 +05:30
+								    ph, o,  &
-												per-family parameters for kinehardening

											
										
										
											2023-08-11 20:06:03 +05:30
+								    N_fam, &
-												rename Nconstituents --> Nmembers

											
										
										
											2021-03-05 01:46:36 +05:30
+								    Nmembers, &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    sizeState, sizeDeltaState, sizeDotState, &
-												further simplification

											
										
										
											2020-07-02 00:52:05 +05:30
+								    startIndex, endIndex
-												works if Nslip=[0]

											
										
										
											2020-03-16 23:26:54 +05:30
+								  integer,     dimension(:), allocatable :: &
-												no need to store # sytems/family

											
										
										
											2020-03-16 03:37:23 +05:30
+								    N_sl
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(:), allocatable :: &
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    xi_0                                                                                            !< initial forest stress
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								                                                                                                    !! τ_for,0
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								  real(pREAL), dimension(:,:), allocatable :: &
 								    a_nS                                                                                            !< non-Schmid coefficients
-												rename to wrapLines; additional formatting options; whitespace trimming

											
										
										
											2023-03-01 01:27:44 +05:30
+								  character(len=:), allocatable :: &
 								    refs, &
 								    extmsg
-												Re-written YAML types
Strict typing for YAML

New access pattern requires to specify the expected type, i.e. 'scalar', 'list', or 'dict'. This ensures that the node offers the expected functionality instead of polluting 'tNode' with dummy functions which throw error messages if not overwritten.

The restructuring of the code allows to hierarchically construct methods without much code duplication.

Some aspects of the error messaging system have been improved.

											
										
										
											2022-10-25 21:39:36 +05:30
+								  type(tDict), pointer :: &
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								    phases, &
 								    phase, &
-												under mech dictionary

											
										
										
											2020-11-03 03:16:46 +05:30
+								    mech, &
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								    pl
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												report origin of configuration if given

											
										
										
											2023-02-25 17:13:10 +05:30
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								  myPlasticity = plastic_active('kinehardening')
-												Fortran style adjustments

											
										
										
											2022-12-07 22:59:03 +05:30
+								  if (count(myPlasticity) == 0) return
-												further simplification

											
										
										
											2020-07-02 00:52:05 +05:30
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								  print'(/,1x,a)', '<<<+-  phase:mechanical:plastic:kinehardening init  -+>>>'
-												less verbose reporting

											
										
										
											2021-02-13 17:37:35 +05:30
-												added literature reference for constitutive law

											
										
										
											2022-01-06 20:24:33 +05:30
+								  print'(/,1x,a)', 'J.A. Wollmershauser et al., International Journal of Fatigue 36:181–193, 2012'
 								  print'(  1x,a)', 'https://doi.org/10.1016/j.ijfatigue.2011.07.008'
-												less verbose reporting

											
										
										
											2021-02-13 17:37:35 +05:30
-												reverse order of printing

											
										
										
											2023-08-29 07:11:48 +05:30
+								  print'(/,1x,a,1x,i0)', '# phases:',count(myPlasticity); flush(IO_STDOUT)
-												white space and style adjustments

											
										
										
											2023-01-18 23:20:01 +05:30
-												Re-written YAML types
Strict typing for YAML

New access pattern requires to specify the expected type, i.e. 'scalar', 'list', or 'dict'. This ensures that the node offers the expected functionality instead of polluting 'tNode' with dummy functions which throw error messages if not overwritten.

The restructuring of the code allows to hierarchically construct methods without much code duplication.

Some aspects of the error messaging system have been improved.

											
										
										
											2022-10-25 21:39:36 +05:30
+								  phases => config_material%get_dict('phase')
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								  allocate(param(phases%length))
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								  allocate(indexDotState(phases%length))
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								  allocate(state(phases%length))
 								  allocate(deltaState(phases%length))
-												string length is not know, avoid overflow

											
										
										
											2023-01-10 16:24:13 +05:30
+								  extmsg = ''
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
-												consistent name 'ph' and cleaning

											
										
										
											2021-02-16 20:36:09 +05:30
+								  do ph = 1, phases%length
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								    if (.not. myPlasticity(ph)) cycle
-												consistent name 'ph' and cleaning

											
										
										
											2021-02-16 20:36:09 +05:30
-												inline math_expand for other constitutive laws

											
										
										
											2023-06-23 00:13:55 +05:30
+								    associate(prm => param(ph), &
 								              stt => state(ph), dlt => deltaState(ph), &
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								              idx_dot => indexDotState(ph))
-												consistent name 'ph' and cleaning

											
										
										
											2021-02-16 20:36:09 +05:30
-												Re-written YAML types
Strict typing for YAML

New access pattern requires to specify the expected type, i.e. 'scalar', 'list', or 'dict'. This ensures that the node offers the expected functionality instead of polluting 'tNode' with dummy functions which throw error messages if not overwritten.

The restructuring of the code allows to hierarchically construct methods without much code duplication.

Some aspects of the error messaging system have been improved.

											
										
										
											2022-10-25 21:39:36 +05:30
+								    phase => phases%get_dict(ph)
 								    mech => phase%get_dict('mechanical')
 								    pl => mech%get_dict('plastic')
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
-												inline math_expand for other constitutive laws

											
										
										
											2023-06-23 00:13:55 +05:30
+								    print'(/,1x,a,1x,i0,a)', 'phase',ph,': '//phases%key(ph)
-												rename to wrapLines; additional formatting options; whitespace trimming

											
										
										
											2023-03-01 01:27:44 +05:30
+								    refs = config_listReferences(pl,indent=3)
 								    if (len(refs) > 0) print'(/,1x,a)', refs
-												report origin of configuration if given

											
										
										
											2023-02-25 17:13:10 +05:30
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								#if defined (__GFORTRAN__)
-												consistent and short

											
										
										
											2023-06-04 10:47:38 +05:30
+								    prm%output = output_as1dStr(pl)
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								#else
-												consistent and short

											
										
										
											2023-06-04 10:47:38 +05:30
+								    prm%output = pl%get_as1dStr('output',defaultVal=emptyStrArray)
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								#endif
-												no need to store atol

											
										
										
											2020-03-15 00:33:57 +05:30
-												starting to introduce parallel structure for new style parameter reading

											
										
										
											2018-11-26 00:07:46 +05:30
+								!--------------------------------------------------------------------------------------------------
 								! slip related parameters
-												get_asXXs --> get_as1dXX

											
										
										
											2021-03-11 22:30:07 +05:30
+								    N_sl         = pl%get_as1dInt('N_sl',defaultVal=emptyIntArray)
-												works if Nslip=[0]

											
										
										
											2020-03-16 23:26:54 +05:30
+								    prm%sum_N_sl = sum(abs(N_sl))
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    slipActive: if (prm%sum_N_sl > 0) then
-												per-family parameters for kinehardening

											
										
										
											2023-08-11 20:06:03 +05:30
+								      N_fam = size(N_sl)
-												consistent naming with Python module

											
										
										
											2023-07-15 23:58:57 +05:30
+								      prm%systems_sl = crystal_labels_slip(N_sl,phase_lattice(ph))
 								      prm%P = crystal_SchmidMatrix_slip(N_sl,phase_lattice(ph),phase_cOverA(ph))
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												using central values

											
										
										
											2021-07-21 19:16:38 +05:30
+								      if (phase_lattice(ph) == 'cI') then
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								        allocate(a_nS(3,size(pl%get_as1dReal('a_nonSchmid_110',defaultVal=emptyRealArray))),source=0.0_pREAL)
 								        a_nS(1,:) = pl%get_as1dReal('a_nonSchmid_110',defaultVal=emptyRealArray)
 								        prm%P_nS_pos = crystal_SchmidMatrix_slip(N_sl,phase_lattice(ph),phase_cOverA(ph),nonSchmidCoefficients=a_nS,sense=+1)
 								        prm%P_nS_neg = crystal_SchmidMatrix_slip(N_sl,phase_lattice(ph),phase_cOverA(ph),nonSchmidCoefficients=a_nS,sense=-1)
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								      else
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								        prm%P_nS_pos = +prm%P
 								        prm%P_nS_neg = -prm%P
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								      end if
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												consistent naming with Python module

											
										
										
											2023-07-15 23:58:57 +05:30
+								      prm%h_sl_sl = crystal_interaction_SlipBySlip(N_sl,pl%get_as1dReal('h_sl-sl'), &
-												inline math_expand for other constitutive laws

											
										
										
											2023-06-23 00:13:55 +05:30
+								                                                   phase_lattice(ph))
-												per-family parameters for kinehardening

											
										
										
											2023-08-11 20:06:03 +05:30
+								      xi_0            = math_expand(pl%get_as1dReal('xi_0',        requiredSize=N_fam),N_sl)
 								      prm%dot_gamma_0 = math_expand(pl%get_as1dReal('dot_gamma_0', requiredSize=N_fam),N_sl)
 								      prm%n           = math_expand(pl%get_as1dReal('n',           requiredSize=N_fam),N_sl)
 								      prm%xi_inf      = math_expand(pl%get_as1dReal('xi_inf',      requiredSize=N_fam),N_sl)
 								      prm%chi_inf     = math_expand(pl%get_as1dReal('chi_inf',     requiredSize=N_fam),N_sl)
 								      prm%h_0_xi      = math_expand(pl%get_as1dReal('h_0_xi',      requiredSize=N_fam),N_sl)
 								      prm%h_0_chi     = math_expand(pl%get_as1dReal('h_0_chi',     requiredSize=N_fam),N_sl)
 								      prm%h_inf_xi    = math_expand(pl%get_as1dReal('h_inf_xi',    requiredSize=N_fam),N_sl)
 								      prm%h_inf_chi   = math_expand(pl%get_as1dReal('h_inf_chi',   requiredSize=N_fam),N_sl)
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												following best practise from phenopowerlaw

											
										
										
											2019-01-07 01:48:35 +05:30
+								!--------------------------------------------------------------------------------------------------
 								!  sanity checks
-												per-family parameters for kinehardening

											
										
										
											2023-08-11 20:06:03 +05:30
+								      if (any(prm%dot_gamma_0  <= 0.0_pREAL))  extmsg = trim(extmsg)//' dot_gamma_0'
 								      if (any(prm%n            <= 0.0_pREAL))  extmsg = trim(extmsg)//' n'
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								      if (any(xi_0             <= 0.0_pREAL))  extmsg = trim(extmsg)//' xi_0'
 								      if (any(prm%xi_inf       <= 0.0_pREAL))  extmsg = trim(extmsg)//' xi_inf'
 								      if (any(prm%chi_inf      <= 0.0_pREAL))  extmsg = trim(extmsg)//' chi_inf'
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												works if Nslip=[0]

											
										
										
											2020-03-16 23:26:54 +05:30
+								    else slipActive
 								      xi_0 = emptyRealArray
-												per-family parameters for kinehardening

											
										
										
											2023-08-11 20:06:03 +05:30
+								      allocate(prm%dot_gamma_0, &
 								               prm%n, &
 								               prm%xi_inf, &
-												inline math_expand for other constitutive laws

											
										
										
											2023-06-23 00:13:55 +05:30
+								               prm%chi_inf, &
 								               prm%h_0_xi, &
 								               prm%h_0_chi, &
 								               prm%h_inf_xi, &
 								               prm%h_inf_chi, &
 								               source=emptyRealArray)
-												notation as in paper

											
										
										
											2021-07-21 18:33:28 +05:30
+								      allocate(prm%h_sl_sl(0,0))
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								    end if slipActive
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												adopting argument parsing to Phenopowerlaw

											
										
										
											2018-11-26 04:44:27 +05:30
+								!--------------------------------------------------------------------------------------------------
 								! allocate state arrays
-												more systematic name

											
										
										
											2023-01-23 13:01:59 +05:30
+								    Nmembers = count(material_ID_phase == ph)
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								    sizeDotState   = prm%sum_N_sl * size(['xi   ',&
 								                                          'chi  ',&
 								                                          'gamma'])
 								    sizeDeltaState = prm%sum_N_sl * size(['sgn_gamma ',&
 								                                          'chi_flip  ',&
 								                                          'gamma_flip'])
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    sizeState = sizeDotState + sizeDeltaState
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												rename Nconstituents --> Nmembers

											
										
										
											2021-03-05 01:46:36 +05:30
+								    call phase_allocateState(plasticState(ph),Nmembers,sizeState,sizeDotState,sizeDeltaState)
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    deallocate(plasticState(ph)%dotState) ! ToDo: remove dotState completely
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												following best practise from phenopowerlaw

											
										
										
											2019-01-07 01:48:35 +05:30
+								!--------------------------------------------------------------------------------------------------
-												no need to store # sytems/family

											
										
										
											2020-03-16 03:37:23 +05:30
+								! state aliases and initialization
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    startIndex = 1
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    endIndex   = prm%sum_N_sl
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    idx_dot%xi = [startIndex,endIndex]
 								    stt%xi => plasticState(ph)%state(startIndex:endIndex,:)
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    stt%xi = spread(xi_0, 2, Nmembers)
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    plasticState(ph)%atol(startIndex:endIndex) = pl%get_asReal('atol_xi',defaultVal=1.0_pREAL)
 								    if (any(plasticState(ph)%atol(startIndex:endIndex) < 0.0_pREAL)) extmsg = trim(extmsg)//' atol_xi'
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    startIndex = endIndex + 1
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    endIndex   = endIndex + prm%sum_N_sl
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    idx_dot%chi = [startIndex,endIndex]
 								    stt%chi => plasticState(ph)%state(startIndex:endIndex,:)
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    plasticState(ph)%atol(startIndex:endIndex) = pl%get_asReal('atol_xi',defaultVal=1.0_pREAL)
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    startIndex = endIndex + 1
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    endIndex   = endIndex + prm%sum_N_sl
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    idx_dot%gamma = [startIndex,endIndex]
 								    stt%gamma => plasticState(ph)%state(startIndex:endIndex,:)
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    plasticState(ph)%atol(startIndex:endIndex) = pl%get_asReal('atol_gamma',defaultVal=1.0e-6_pREAL)
 								    if (any(plasticState(ph)%atol(startIndex:endIndex) < 0.0_pREAL)) extmsg = trim(extmsg)//' atol_gamma'
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												consistent name 'ph' and cleaning

											
										
										
											2021-02-16 20:36:09 +05:30
+								    o = plasticState(ph)%offsetDeltaState
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    startIndex = endIndex + 1
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    endIndex   = endIndex + prm%sum_N_sl
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    stt%sgn_gamma => plasticState(ph)%state     (startIndex  :endIndex  ,:)
 								    dlt%sgn_gamma => plasticState(ph)%deltaState(startIndex-o:endIndex-o,:)
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    startIndex = endIndex + 1
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    endIndex   = endIndex +  prm%sum_N_sl
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								    stt%chi_flip => plasticState(ph)%state     (startIndex  :endIndex  ,:)
 								    dlt%chi_flip => plasticState(ph)%deltaState(startIndex-o:endIndex-o,:)
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    startIndex = endIndex + 1
-												notation from DAMASK paper

											
										
										
											2020-03-16 01:46:28 +05:30
+								    endIndex   = endIndex +  prm%sum_N_sl
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								    stt%gamma_flip => plasticState(ph)%state     (startIndex  :endIndex  ,:)
 								    dlt%gamma_flip => plasticState(ph)%deltaState(startIndex-o:endIndex-o,:)
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    end associate
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												no need to store atol

											
										
										
											2020-03-15 00:33:57 +05:30
+								!--------------------------------------------------------------------------------------------------
 								!  exit if any parameter is out of range
-												not needed

error occurs in <phase ... init>

											
										
										
											2022-05-27 03:54:40 +05:30
+								    if (extmsg /= '') call IO_error(211,ext_msg=trim(extmsg))
-												no need to store atol

											
										
										
											2020-03-15 00:33:57 +05:30
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								  end do
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
-												no need to store atol

											
										
										
											2020-03-15 00:33:57 +05:30
-												Restructuring for material.yaml

											
										
										
											2020-08-15 19:32:10 +05:30
+								end function plastic_kinehardening_init
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
 								!--------------------------------------------------------------------------------------------------
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								!> @brief Calculate plastic velocity gradient and its tangent.
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
+								!--------------------------------------------------------------------------------------------------
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								pure module subroutine kinehardening_LpAndItsTangent(Lp,dLp_dMp, Mp,ph,en)
-												following best practise from phenopowerlaw

											
										
										
											2019-01-07 01:48:35 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(3,3),     intent(out) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    Lp                                                                                              !< plastic velocity gradient
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(3,3,3,3), intent(out) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    dLp_dMp                                                                                         !< derivative of Lp with respect to the Mandel stress
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								  real(pREAL), dimension(3,3),     intent(in) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    Mp                                                                                              !< Mandel stress
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								  integer,                         intent(in) :: &
-												[skip sc] default access for phase: (ph,me)

											
										
										
											2021-01-27 03:11:41 +05:30
+								    ph, &
-												consistent with new naming scheme

											
										
										
											2021-04-25 11:36:52 +05:30
+								    en
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  integer :: &
 								    i,k,l,m,n
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(param(ph)%sum_N_sl) :: &
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    dot_gamma, ddot_gamma_dtau
-												no merge in hot loop

results in measureable run time decrease for Intel and GNU compilers

											
										
										
											2023-10-05 01:29:20 +05:30
+								  real(pREAL), dimension(3,3,param(ph)%sum_N_sl) :: &
 								    P_nS
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												polishing

											
										
										
											2023-09-22 10:40:08 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  Lp = 0.0_pREAL
 								  dLp_dMp = 0.0_pREAL
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								  associate(prm => param(ph))
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												polishing

											
										
										
											2023-09-22 10:40:08 +05:30
+								    call kinetics(Mp,ph,en, dot_gamma,ddot_gamma_dtau)
-												no merge in hot loop

results in measureable run time decrease for Intel and GNU compilers

											
										
										
											2023-10-05 01:29:20 +05:30
+								    P_nS = merge(prm%P_nS_pos,prm%P_nS_neg, spread(spread(dot_gamma,1,3),2,3)>0.0_pREAL)            ! faster than 'merge' in loop
-												polishing

											
										
										
											2023-09-22 10:40:08 +05:30
+								    do i = 1, prm%sum_N_sl
 								      Lp = Lp + dot_gamma(i)*prm%P(1:3,1:3,i)
 								      forall (k=1:3,l=1:3,m=1:3,n=1:3) &
 								        dLp_dMp(k,l,m,n) = dLp_dMp(k,l,m,n) &
-												no merge in hot loop

results in measureable run time decrease for Intel and GNU compilers

											
										
										
											2023-10-05 01:29:20 +05:30
+								                         + ddot_gamma_dtau(i) * prm%P(k,l,i) * P_nS(m,n,i)
-												polishing

											
										
										
											2023-09-22 10:40:08 +05:30
+								    end do
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  end associate
-fixed backstress rate of change based on its own slip system evolution and its sense 
											
										
										
											2017-11-14 22:55:55 +05:30
-												hierarchical naming

											
										
										
											2021-01-26 12:03:04 +05:30
+								end subroutine kinehardening_LpAndItsTangent
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
-												private functions at the end

											
										
										
											2018-12-22 03:11:39 +05:30
-												have dotState after Lp/Li

											
										
										
											2019-01-07 12:06:11 +05:30
+								!--------------------------------------------------------------------------------------------------
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								!> @brief Calculate the rate of change of microstructure.
-												have dotState after Lp/Li

											
										
										
											2019-01-07 12:06:11 +05:30
+								!--------------------------------------------------------------------------------------------------
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								module function plastic_kinehardening_dotState(Mp,ph,en) result(dotState)
-												have dotState after Lp/Li

											
										
										
											2019-01-07 12:06:11 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(3,3),  intent(in) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    Mp                                                                                              !< Mandel stress
 								  integer,                      intent(in) :: &
-												[skip sc] default access for phase: (ph,me)

											
										
										
											2021-01-27 03:11:41 +05:30
+								    ph, &
-												consistent with new naming scheme

											
										
										
											2021-04-25 11:36:52 +05:30
+								    en
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(plasticState(ph)%sizeDotState) :: &
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    dotState
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    sumGamma
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								  associate(prm => param(ph), stt => state(ph), &
 								            dot_xi => dotState(IndexDotState(ph)%xi(1):IndexDotState(ph)%xi(2)),&
 								            dot_chi => dotState(IndexDotState(ph)%chi(1):IndexDotState(ph)%chi(2)),&
 								            dot_gamma => dotState(IndexDotState(ph)%gamma(1):IndexDotState(ph)%gamma(2)))
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    call kinetics(Mp,ph,en, dot_gamma)
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    sumGamma = sum(stt%gamma(:,en))
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    dot_gamma = abs(dot_gamma)
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    dot_xi = matmul(prm%h_sl_sl,dot_gamma) &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								           * ( prm%h_inf_xi &
 								               + ( prm%h_0_xi  &
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								                 - prm%h_inf_xi * (1_pREAL -sumGamma*prm%h_0_xi/prm%xi_inf) ) &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								               *                       exp(-sumGamma*prm%h_0_xi/prm%xi_inf) &
 								             )
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								    dot_chi = stt%sgn_gamma(:,en)*dot_gamma &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								            * ( prm%h_inf_chi &
 								               + ( prm%h_0_chi &
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								                 - prm%h_inf_chi*(1_pREAL -(stt%gamma(:,en)-stt%gamma_flip(:,en))*prm%h_0_chi/(prm%chi_inf+stt%chi_flip(:,en))) ) &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								               *                      exp(-(stt%gamma(:,en)-stt%gamma_flip(:,en))*prm%h_0_chi/(prm%chi_inf+stt%chi_flip(:,en))) &
 								              )
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  end associate
-												have dotState after Lp/Li

											
										
										
											2019-01-07 12:06:11 +05:30
-												no need to store dot state

saves memory and flow is easier to understand

											
										
										
											2022-02-04 04:10:25 +05:30
+								end function plastic_kinehardening_dotState
-												have dotState after Lp/Li

											
										
										
											2019-01-07 12:06:11 +05:30
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
+								!--------------------------------------------------------------------------------------------------
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								!> @brief Calculate (instantaneous) incremental change of microstructure.
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
+								!--------------------------------------------------------------------------------------------------
-												consistent with new naming scheme

											
										
										
											2021-04-25 11:36:52 +05:30
+								module subroutine plastic_kinehardening_deltaState(Mp,ph,en)
-												re-enabled debug

											
										
										
											2018-12-30 20:09:48 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(3,3),  intent(in) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    Mp                                                                                              !< Mandel stress
 								  integer,                      intent(in) :: &
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								    ph, &
-												consistent with new naming scheme

											
										
										
											2021-04-25 11:36:52 +05:30
+								    en
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(param(ph)%sum_N_sl) :: &
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    dot_gamma, &
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    sgn_gamma
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								  associate(prm => param(ph), stt => state(ph), dlt => deltaState(ph))
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    call kinetics(Mp,ph,en, dot_gamma)
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    sgn_gamma = merge(state(ph)%sgn_gamma(:,en), &
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								                      sign(1.0_pREAL,dot_gamma), &
 								                      dEq0(dot_gamma,1e-10_pREAL))
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								    where(dNeq(sgn_gamma,stt%sgn_gamma(:,en),0.1_pREAL)) ! ToDo sgn_gamma*stt%sgn_gamma(:,en)<0
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								      dlt%sgn_gamma (:,en) = sgn_gamma            - stt%sgn_gamma (:,en)
 								      dlt%chi_flip  (:,en) = abs(stt%chi  (:,en)) - stt%chi_flip  (:,en)
 								      dlt%gamma_flip(:,en) =     stt%gamma(:,en)  - stt%gamma_flip(:,en)
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    else where
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								      dlt%sgn_gamma (:,en) = 0.0_pREAL
 								      dlt%chi_flip  (:,en) = 0.0_pREAL
 								      dlt%gamma_flip(:,en) = 0.0_pREAL
-												consistent variable names

											
										
										
											2021-07-23 10:39:54 +05:30
+								    end where
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  end associate
-												first shot at kinematic hardening constitutive law


											
										
										
											2017-09-30 04:06:28 +05:30
 								end subroutine plastic_kinehardening_deltaState
-												dummy HDF5 output for all plasticity laws

											
										
										
											2019-03-10 01:13:31 +05:30
+								!--------------------------------------------------------------------------------------------------
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								!> @brief Write results to HDF5 output file.
-												dummy HDF5 output for all plasticity laws

											
										
										
											2019-03-10 01:13:31 +05:30
+								!--------------------------------------------------------------------------------------------------
-												Resolve "naming for classes"

											
										
										
											2023-01-19 22:07:45 +05:30
+								module subroutine plastic_kinehardening_result(ph,group)
-												dummy HDF5 output for all plasticity laws

											
										
										
											2019-03-10 01:13:31 +05:30
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								  integer,          intent(in) :: ph
-												file names reflect hierarchical structure

											
										
										
											2019-12-03 02:08:41 +05:30
+								  character(len=*), intent(in) :: group
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
+								  integer :: ou
-												dummy HDF5 output for all plasticity laws

											
										
										
											2019-03-10 01:13:31 +05:30
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								  associate(prm => param(ph), stt => state(ph))
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
 								    do ou = 1,size(prm%output)
 								      select case(trim(prm%output(ou)))
 								        case ('xi')
-												Resolve "naming for classes"

											
										
										
											2023-01-19 22:07:45 +05:30
+								          call result_writeDataset(stt%xi,group,trim(prm%output(ou)), &
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								                                   'forest stress','Pa',prm%systems_sl)
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
+								        case ('chi')
-												Resolve "naming for classes"

											
										
										
											2023-01-19 22:07:45 +05:30
+								          call result_writeDataset(stt%chi,group,trim(prm%output(ou)), &
 								                                   'back stress','Pa',prm%systems_sl)
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
+								        case ('sgn(gamma)')
-												Resolve "naming for classes"

											
										
										
											2023-01-19 22:07:45 +05:30
+								          call result_writeDataset(int(stt%sgn_gamma),group,trim(prm%output(ou)), &
 								                                   'sense of shear','1',prm%systems_sl)
-												adjusting to original publication

Our implementation is using synonymous names for parameters compared to the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

'xi_inf' and 'chi_inf' are not strictly "asymptotic values", but stresses that correspond to the back-extrapolation from the terminal linear hardening stage (characterized by 'h_inf_xi/chi').

All parameters are referenced back to their counterparts in the paper by J.A. Wollmershauser, B. Clausen, and S.R. Agnew.

											
										
										
											2023-03-31 23:24:25 +05:30
+								        case ('chi_flip')
 								          call result_writeDataset(stt%chi_flip,group,trim(prm%output(ou)), &
 								                                   'back stress at last reversal of stress sense','Pa',prm%systems_sl)
 								        case ('gamma_flip')
 								          call result_writeDataset(stt%gamma_flip,group,trim(prm%output(ou)), &
 								                                   'plastic shear at last reversal of stress sense','1',prm%systems_sl)
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
+								        case ('gamma')
-												Resolve "naming for classes"

											
										
										
											2023-01-19 22:07:45 +05:30
+								          call result_writeDataset(stt%gamma,group,trim(prm%output(ou)), &
 								                                   'plastic shear','1',prm%systems_sl)
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
+								      end select
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								    end do
-												save information on slip systems for reproducibility

											
										
										
											2021-07-27 18:35:27 +05:30
-												dummy HDF5 output for all plasticity laws

											
										
										
											2019-03-10 01:13:31 +05:30
+								  end associate
-												Resolve "naming for classes"

											
										
										
											2023-01-19 22:07:45 +05:30
+								end subroutine plastic_kinehardening_result
-												dummy HDF5 output for all plasticity laws

											
										
										
											2019-03-10 01:13:31 +05:30
-												copied from phenopowerlaw

											
										
										
											2018-11-26 11:40:43 +05:30
+								!--------------------------------------------------------------------------------------------------
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
+								!> @brief Calculate shear rates on slip systems and their derivatives with respect to resolved
 								!         stress.
 								!> @details: Derivatives are calculated only optionally.
-												minor orthography adjustments

											
										
										
											2023-02-11 20:00:12 +05:30
+								! NOTE: Contrary to common convention, here the result (i.e. intent(out)) variables have to be put
 								! at the end since some of them are optional.
-												copied from phenopowerlaw

											
										
										
											2018-11-26 11:40:43 +05:30
+								!--------------------------------------------------------------------------------------------------
-												consistent with new naming scheme

											
										
										
											2021-04-25 11:36:52 +05:30
+								pure subroutine kinetics(Mp,ph,en, &
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								                         dot_gamma,ddot_gamma_dtau)
-												copied from phenopowerlaw

											
										
										
											2018-11-26 11:40:43 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								  real(pREAL), dimension(3,3),                           intent(in) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    Mp                                                                                              !< Mandel stress
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								  integer,                                               intent(in) :: &
-												easier to read without instance

											
										
										
											2021-02-14 05:20:42 +05:30
+								    ph, &
-												consistent with new naming scheme

											
										
										
											2021-04-25 11:36:52 +05:30
+								    en
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								  real(pREAL), dimension(param(ph)%sum_N_sl),           intent(out) :: &
 								    dot_gamma
 								  real(pREAL), dimension(param(ph)%sum_N_sl), optional, intent(out) :: &
 								    ddot_gamma_dtau
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												parameters should be spelled in capitals

											
										
										
											2023-06-04 10:52:25 +05:30
+								  real(pREAL), dimension(param(ph)%sum_N_sl) :: &
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								    tau_pos, &
 								    tau_neg
 								  integer :: i
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												polishing

											
										
										
											2023-09-22 10:40:08 +05:30
-												whitespace adjustments

											
										
										
											2021-07-23 03:39:51 +05:30
+								  associate(prm => param(ph), stt => state(ph))
-												no need for outputID

just adds overhead, one string comparison per output and increment is
computationally not an issue

also unified to PEP recommendation of function description

											
										
										
											2020-02-14 11:47:30 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    tau_pos = [(math_tensordot(Mp,prm%P_nS_pos(1:3,1:3,i)) - stt%chi(i,en),i=1,prm%sum_N_sl)]
 								    tau_neg = [(math_tensordot(Mp,prm%P_nS_neg(1:3,1:3,i)) + stt%chi(i,en),i=1,prm%sum_N_sl)]
-												whitespace adjustments

											
										
										
											2021-07-23 03:39:51 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    dot_gamma = merge(+1.0_pREAL,-1.0_pREAL, tau_pos>tau_neg) &
 								              * prm%dot_gamma_0  &
-												easier to understand

											
										
										
											2023-09-22 02:02:38 +05:30
+								              * (max(tau_pos,tau_neg)/stt%xi(:,en))**prm%n
-												whitespace adjustments

											
										
										
											2021-07-23 03:39:51 +05:30
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								    if (present(ddot_gamma_dtau)) then
 								      where(dNeq0(dot_gamma))
-												easier to understand

											
										
										
											2023-09-22 02:02:38 +05:30
+								        ddot_gamma_dtau = dot_gamma*prm%n/max(tau_pos,tau_neg)
-												whitespace adjustments

											
										
										
											2021-07-23 03:39:51 +05:30
+								      else where
-												adapted kinehardening

											
										
										
											2023-09-15 20:43:58 +05:30
+								        ddot_gamma_dtau = 0.0_pREAL
-												whitespace adjustments

											
										
										
											2021-07-23 03:39:51 +05:30
+								      end where
-												consistent indentation and line-spacings in reporting

											
										
										
											2021-11-15 23:05:44 +05:30
+								    end if
-												whitespace adjustments

											
										
										
											2021-07-23 03:39:51 +05:30
-												fixing indentation

always 2 spaces, not 1 for the first level

											
										
										
											2020-02-01 02:07:18 +05:30
+								  end associate
-												copied from phenopowerlaw

											
										
										
											2018-11-26 11:40:43 +05:30
 								end subroutine kinetics
-												modularizing

											
										
										
											2021-01-26 05:41:32 +05:30
+								end submodule kinehardening