kinematics_cleavage_opening.f90

Go to the documentation of this file.

# 1 "/home/damask_user/GitLabCI_Pipeline_4301/DAMASK/src/kinematics_cleavage_opening.f90"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/home/damask_user/GitLabCI_Pipeline_4301/DAMASK/src/kinematics_cleavage_opening.f90"
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
module kinematics_cleavage_opening
  use prec
  use io
  use config
  use debug
  use math
  use lattice
  use material
 
  implicit none
  private
 
  integer, dimension(:), allocatable :: kinematics_cleavage_opening_instance
 
  type :: tparameters                                                                               
    integer :: &
      sum_n_cl
    real(preal) :: &
      sdot0, &
      n
    real(preal),   dimension(:),   allocatable :: &
      critload
    real(preal), dimension(:,:,:,:), allocatable :: &
      cleavage_systems
  end type tparameters
 
  type(tparameters), dimension(:), allocatable :: param
 
  public :: &
    kinematics_cleavage_opening_init, &
    kinematics_cleavage_opening_lianditstangent
 
contains
 
 
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
subroutine kinematics_cleavage_opening_init
 
  integer :: ninstance,p
  integer, dimension(:), allocatable :: n_cl
  character(len=pStringLen) :: extmsg = ''
 
  write(6,'(/,a)') ' <<<+-  kinematics_'//kinematics_cleavage_opening_label//' init  -+>>>'; flush(6)
 
  ninstance = count(phase_kinematics == kinematics_cleavage_opening_id)
  if (iand(debug_level(debug_constitutive),debug_levelbasic) /= 0) &
    write(6,'(a16,1x,i5,/)') '# instances:',ninstance
 
  allocate(kinematics_cleavage_opening_instance(size(config_phase)), source=0)
  allocate(param(ninstance))
 
  do p = 1, size(config_phase)
    kinematics_cleavage_opening_instance(p) = count(phase_kinematics(:,1:p) == kinematics_cleavage_opening_id)
    if (all(phase_kinematics(:,p) /= kinematics_cleavage_opening_id)) cycle
 
    associate(prm => param(kinematics_cleavage_opening_instance(p)), &
              config => config_phase(p))
 
    n_cl = config%getInts('ncleavage')
    prm%sum_N_cl = sum(abs(n_cl))
 
    prm%n         = config%getFloat('anisobrittle_ratesensitivity')
    prm%sdot0     = config%getFloat('anisobrittle_sdot0')
 
    prm%critLoad  = config%getFloats('anisobrittle_criticalload',requiredsize=size(n_cl))
 
    prm%cleavage_systems  = lattice_schmidmatrix_cleavage(n_cl,config%getString('lattice_structure'),&
                                                          config%getFloat('c/a',defaultval=0.0_preal))
 
    ! expand: family => system
    prm%critLoad = math_expand(prm%critLoad,n_cl)
 
    ! sanity checks
    if (prm%n            <= 0.0_preal)  extmsg = trim(extmsg)//' anisobrittle_n'
    if (prm%sdot0        <= 0.0_preal)  extmsg = trim(extmsg)//' anisobrittle_sdot0'
    if (any(prm%critLoad <  0.0_preal)) extmsg = trim(extmsg)//' anisobrittle_critLoad'
 
!--------------------------------------------------------------------------------------------------
!  exit if any parameter is out of range
    if (extmsg /= '') call io_error(211,ext_msg=trim(extmsg)//'('//kinematics_cleavage_opening_label//')')
 
    end associate
  enddo
 
end subroutine kinematics_cleavage_opening_init
 
 
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
subroutine kinematics_cleavage_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 :: &
    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
 
  homog = material_homogenizationat(el)
  damageoffset = damagemapping(homog)%p(ip,el)
 
  ld = 0.0_preal
  dld_dtstar = 0.0_preal
  associate(prm => param(kinematics_cleavage_opening_instance(material_phaseat(ipc,el))))
  do i = 1,prm%sum_N_cl
    traction_crit = prm%critLoad(i)* damage(homog)%p(damageoffset)**2.0_preal
 
    traction_d = math_tensordot(s,prm%cleavage_systems(1:3,1:3,1,i))
    if (abs(traction_d) > traction_crit + tol_math_check) then
      udotd = sign(1.0_preal,traction_d)* prm%sdot0 * ((abs(traction_d) - traction_crit)/traction_crit)**prm%n
      ld = ld + udotd*prm%cleavage_systems(1:3,1:3,1,i)
      dudotd_dt = sign(1.0_preal,traction_d)*udotd*prm%n / (abs(traction_d) - traction_crit)
      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%cleavage_systems(k,l,1,i) * prm%cleavage_systems(m,n,1,i)
    endif
 
    traction_t = math_tensordot(s,prm%cleavage_systems(1:3,1:3,2,i))
    if (abs(traction_t) > traction_crit + tol_math_check) then
      udott = sign(1.0_preal,traction_t)* prm%sdot0 * ((abs(traction_t) - traction_crit)/traction_crit)**prm%n
      ld = ld + udott*prm%cleavage_systems(1:3,1:3,2,i)
      dudott_dt = sign(1.0_preal,traction_t)*udott*prm%n / (abs(traction_t) - traction_crit)
      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) &
                            + dudott_dt*prm%cleavage_systems(k,l,2,i) * prm%cleavage_systems(m,n,2,i)
    endif
 
    traction_n = math_tensordot(s,prm%cleavage_systems(1:3,1:3,3,i))
    if (abs(traction_n) > traction_crit + tol_math_check) then
      udotn = sign(1.0_preal,traction_n)* prm%sdot0 * ((abs(traction_n) - traction_crit)/traction_crit)**prm%n
      ld = ld + udotn*prm%cleavage_systems(1:3,1:3,3,i)
      dudotn_dt = sign(1.0_preal,traction_n)*udotn*prm%n / (abs(traction_n) - traction_crit)
      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) &
                            + dudotn_dt*prm%cleavage_systems(k,l,3,i) * prm%cleavage_systems(m,n,3,i)
    endif
  enddo
  end associate
 
end subroutine kinematics_cleavage_opening_lianditstangent
 
end module kinematics_cleavage_opening