kinematics_slipplane_opening.f90

Go to the documentation of this file.

# 1 "/home/damask_user/GitLabCI_Pipeline_4301/DAMASK/src/kinematics_slipplane_opening.f90"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/home/damask_user/GitLabCI_Pipeline_4301/DAMASK/src/kinematics_slipplane_opening.f90"
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
module kinematics_slipplane_opening
  use prec
  use config
  use io
  use debug
  use math
  use lattice
  use material
 
  implicit none
  private
 
  integer, dimension(:), allocatable :: kinematics_slipplane_opening_instance
 
  type :: tparameters                                                                               
    integer :: &
      sum_n_sl
    real(preal) :: &
      sdot0, &
      n
    real(preal), dimension(:),   allocatable :: &
      critload
    real(preal), dimension(:,:,:), allocatable     :: &
      p_d, &
      p_t, &
      p_n
  end type tparameters
 
  type(tparameters), dimension(:), allocatable :: param
 
  public :: &
    kinematics_slipplane_opening_init, &
    kinematics_slipplane_opening_lianditstangent
 
contains
 
 
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
subroutine kinematics_slipplane_opening_init
 
  integer :: ninstance,p,i
  character(len=pStringLen) :: extmsg = ''
  integer,     dimension(:),   allocatable :: n_sl
  real(preal), dimension(:,:), allocatable :: d,n,t
 
  write(6,'(/,a)') ' <<<+-  kinematics_'//kinematics_slipplane_opening_label//' init  -+>>>'; flush(6)
 
  ninstance = count(phase_kinematics == kinematics_slipplane_opening_id)
  if (iand(debug_level(debug_constitutive),debug_levelbasic) /= 0) &
    write(6,'(a16,1x,i5,/)') '# instances:',ninstance
 
  allocate(kinematics_slipplane_opening_instance(size(config_phase)), source=0)
  allocate(param(ninstance))
 
  do p = 1, size(config_phase)
    kinematics_slipplane_opening_instance(p) = count(phase_kinematics(:,1:p) == kinematics_slipplane_opening_id)
    if (all(phase_kinematics(:,p) /= kinematics_slipplane_opening_id)) cycle
    associate(prm => param(kinematics_slipplane_opening_instance(p)), &
             config => config_phase(p))
 
    prm%sdot0    = config%getFloat('anisoductile_sdot0')
    prm%n        = config%getFloat('anisoductile_ratesensitivity')
    n_sl         = config%getInts('nslip')
    prm%sum_N_sl = sum(abs(n_sl))
 
    d = lattice_slip_direction(n_sl,config%getString('lattice_structure'),&
                                config%getFloat('c/a',defaultval=0.0_preal))
    t = lattice_slip_transverse(n_sl,config%getString('lattice_structure'),&
                                config%getFloat('c/a',defaultval=0.0_preal))
    n = lattice_slip_normal(n_sl,config%getString('lattice_structure'),&
                                config%getFloat('c/a',defaultval=0.0_preal))
    allocate(prm%P_d(3,3,size(d,2)),prm%P_t(3,3,size(t,2)),prm%P_n(3,3,size(n,2)))
 
    do i=1, size(n,2)
      prm%P_d(1:3,1:3,i) = math_outer(d(1:3,i), n(1:3,i))
      prm%P_t(1:3,1:3,i) = math_outer(t(1:3,i), n(1:3,i))
      prm%P_n(1:3,1:3,i) = math_outer(n(1:3,i), n(1:3,i))
    enddo
 
    prm%critLoad = config%getFloats('anisoductile_criticalload',requiredsize=size(n_sl))
 
    ! expand: family => system
    prm%critLoad = math_expand(prm%critLoad,n_sl)
 
    ! sanity checks
    if (prm%n            <= 0.0_preal)  extmsg = trim(extmsg)//' anisoDuctile_n'
    if (prm%sdot0        <= 0.0_preal)  extmsg = trim(extmsg)//' anisoDuctile_sdot0'
    if (any(prm%critLoad <  0.0_preal)) extmsg = trim(extmsg)//' anisoDuctile_critLoad'
 
!--------------------------------------------------------------------------------------------------
!  exit if any parameter is out of range
    if (extmsg /= '') call io_error(211,ext_msg=trim(extmsg)//'('//kinematics_slipplane_opening_label//')')
 
    end associate
  enddo
 
end subroutine kinematics_slipplane_opening_init
 
 
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
subroutine kinematics_slipplane_opening_lianditstangent(Ld, dLd_dTstar, S, ipc, ip, el)
 
  integer, intent(in) :: &
    ipc, &                                                                                          !< grain number
    ip, &                                                                                           !< integration point number
    el
  real(preal),   intent(in),  dimension(3,3) :: &
    s
  real(preal),   intent(out), dimension(3,3) :: &
    ld
  real(preal),   intent(out), dimension(3,3,3,3) :: &
    dld_dtstar
 
  integer :: &
    instance, phase, &
    homog, damageoffset, &
    i, k, l, m, n
  real(preal) :: &
    traction_d, traction_t, traction_n, traction_crit, &
    udotd, dudotd_dt, udott, dudott_dt, udotn, dudotn_dt
 
  phase = material_phaseat(ipc,el)
  instance = kinematics_slipplane_opening_instance(phase)
  homog = material_homogenizationat(el)
  damageoffset = damagemapping(homog)%p(ip,el)
 
  associate(prm => param(instance))
  ld = 0.0_preal
  dld_dtstar = 0.0_preal
  do i = 1, prm%sum_N_sl
 
    traction_d = math_tensordot(s,prm%P_d(1:3,1:3,i))
    traction_t = math_tensordot(s,prm%P_t(1:3,1:3,i))
    traction_n = math_tensordot(s,prm%P_n(1:3,1:3,i))
 
    traction_crit = prm%critLoad(i)* damage(homog)%p(damageoffset)                                  ! degrading critical load carrying capacity by damage
 
    udotd = sign(1.0_preal,traction_d)* prm%sdot0* (  abs(traction_d)/traction_crit &
                                                    - abs(traction_d)/prm%critLoad(i))**prm%n
    udott = sign(1.0_preal,traction_t)* prm%sdot0* (  abs(traction_t)/traction_crit &
                                                    - abs(traction_t)/prm%critLoad(i))**prm%n
    udotn = prm%sdot0* (  max(0.0_preal,traction_n)/traction_crit &
                        - max(0.0_preal,traction_n)/prm%critLoad(i))**prm%n
 
    if (dneq0(traction_d)) then
      dudotd_dt = udotd*prm%n/traction_d
    else
      dudotd_dt = 0.0_preal
    endif
    if (dneq0(traction_t)) then
      dudott_dt = udott*prm%n/traction_t
    else
      dudott_dt = 0.0_preal
    endif
    if (dneq0(traction_n)) then
      dudotn_dt = udotn*prm%n/traction_n
    else
      dudotn_dt = 0.0_preal
    endif
 
    forall (k=1:3,l=1:3,m=1:3,n=1:3) &
      dld_dtstar(k,l,m,n) = dld_dtstar(k,l,m,n) &
                          + dudotd_dt*prm%P_d(k,l,i)*prm%P_d(m,n,i) &
                          + dudott_dt*prm%P_t(k,l,i)*prm%P_t(m,n,i) &
                          + dudotn_dt*prm%P_n(k,l,i)*prm%P_n(m,n,i)
 
    ld = ld &
       + udotd*prm%P_d(1:3,1:3,i) &
       + udott*prm%P_t(1:3,1:3,i) &
       + udotn*prm%P_n(1:3,1:3,i)
  enddo
 
  end associate
 
end subroutine kinematics_slipplane_opening_lianditstangent
 
end module kinematics_slipplane_opening