223031012
/
DAMASK_EICMD
mirror of https://github.com/achalhp/DAMASK_EICMD.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Twin variant selection works!

This commit is contained in:
achalhp 2023-11-28 22:06:01 +05:30
parent 36b831dfaf
commit 2d27a0635e
1 changed files with 436 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

231
src/phase_mechanical_plastic_phenopowerlaw.f90
View File

@ -6,7 +6,7 @@
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
submodule(phase:plastic) phenopowerlaw submodule(phase:plastic) phenopowerlaw
type :: tParameters type :: tParameters
real(pReal) :: & real(pReal) :: &
dot_gamma_0_sl = 1.0_pReal, & !< reference shear strain rate for slip dot_gamma_0_sl = 1.0_pReal, & !< reference shear strain rate for slip
dot_gamma_0_tw = 1.0_pReal, & !< reference shear strain rate for twin dot_gamma_0_tw = 1.0_pReal, & !< reference shear strain rate for twin
@ -47,30 +47,29 @@ submodule(phase:plastic) phenopowerlaw
character(len=:), allocatable, dimension(:) :: & character(len=:), allocatable, dimension(:) :: &
systems_sl, & systems_sl, &
systems_tw systems_tw
end type tParameters end type tParameters
type :: tIndexDotState type :: tIndexDotState
integer, dimension(2) :: & integer, dimension(2) :: &
xi_sl, & xi_sl, &
xi_tw, & xi_tw, &
gamma_sl, & gamma_sl, &
gamma_tw gamma_tw
end type tIndexDotState end type tIndexDotState
type :: tPhenopowerlawState type :: tPhenopowerlawState
real(pReal), pointer, dimension(:,:) :: & real(pReal), pointer, dimension(:,:) :: &
xi_sl, & xi_sl, &
xi_tw, & xi_tw, &
gamma_sl, & gamma_sl, &
gamma_tw, & gamma_tw
f_twin !Achal end type tPhenopowerlawState
end type tPhenopowerlawState
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! containers for parameters, dot state index, and state ! containers for parameters, dot state index, and state
type(tParameters), allocatable, dimension(:) :: param type(tParameters), allocatable, dimension(:) :: param
type(tIndexDotState), allocatable, dimension(:) :: indexDotState type(tIndexDotState), allocatable, dimension(:) :: indexDotState
type(tPhenopowerlawState), allocatable, dimension(:) :: state, dot_state, deltastate type(tPhenopowerlawState), allocatable, dimension(:) :: state, dot_state, deltastate
contains contains
@ -81,40 +80,40 @@ contains
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
module function plastic_phenopowerlaw_init() result(myPlasticity) module function plastic_phenopowerlaw_init() result(myPlasticity)
logical, dimension(:), allocatable :: myPlasticity logical, dimension(:), allocatable :: myPlasticity
integer :: & integer :: &
ph, i, & ph, i, &
Nmembers, & Nmembers, &
sizeState, sizeDotState, & sizeState, sizeDotState, &
startIndex, endIndex startIndex, endIndex
integer, dimension(:), allocatable :: & integer, dimension(:), allocatable :: &
N_sl, N_tw N_sl, N_tw
real(pReal), dimension(:), allocatable :: & real(pReal), dimension(:), allocatable :: &
xi_0_sl, & !< initial critical shear stress for slip xi_0_sl, & !< initial critical shear stress for slip
xi_0_tw, & !< initial critical shear stress for twin xi_0_tw, & !< initial critical shear stress for twin
a !< non-Schmid coefficients a !< non-Schmid coefficients
character(len=pStringLen) :: & character(len=pStringLen) :: &
extmsg = '' extmsg = ''
class(tNode), pointer :: & class(tNode), pointer :: &
phases, & phases, &
phase, & phase, &
mech, & mech, &
pl pl
myPlasticity = plastic_active('phenopowerlaw') myPlasticity = plastic_active('phenopowerlaw')
if(count(myPlasticity) == 0) return if(count(myPlasticity) == 0) return
print'(/,1x,a)', '<<<+- phase:mechanical:plastic:phenopowerlaw init -+>>>' print'(/,1x,a)', '<<<+- phase:mechanical:plastic:phenopowerlaw init -+>>>'
print'(/,a,i0)', ' # phases: ',count(myPlasticity); flush(IO_STDOUT) print'(/,a,i0)', ' # phases: ',count(myPlasticity); flush(IO_STDOUT)
phases => config_material%get('phase') phases => config_material%get('phase')
allocate(param(phases%length)) allocate(param(phases%length))
allocate(indexDotState(phases%length)) allocate(indexDotState(phases%length))
allocate(state(phases%length)) allocate(state(phases%length))
do ph = 1, phases%length do ph = 1, phases%length
if (.not. myPlasticity(ph)) cycle if (.not. myPlasticity(ph)) cycle
associate(prm => param(ph), stt => state(ph), & associate(prm => param(ph), stt => state(ph), &
@ -269,15 +268,13 @@ module function plastic_phenopowerlaw_init() result(myPlasticity)
stt%gamma_tw => plasticState(ph)%state(startIndex:endIndex,:) stt%gamma_tw => plasticState(ph)%state(startIndex:endIndex,:)
plasticState(ph)%atol(startIndex:endIndex) = pl%get_asFloat('atol_gamma',defaultVal=1.0e-6_pReal) plasticState(ph)%atol(startIndex:endIndex) = pl%get_asFloat('atol_gamma',defaultVal=1.0e-6_pReal)
end associate end associate
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! exit if any parameter is out of range ! exit if any parameter is out of range
if (extmsg /= '') call IO_error(211,ext_msg=trim(extmsg)) if (extmsg /= '') call IO_error(211,ext_msg=trim(extmsg))
end do end do
end function plastic_phenopowerlaw_init end function plastic_phenopowerlaw_init
@ -289,48 +286,49 @@ end function plastic_phenopowerlaw_init
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure module subroutine phenopowerlaw_LpAndItsTangent(Lp,dLp_dMp,Mp,ph,en) pure module subroutine phenopowerlaw_LpAndItsTangent(Lp,dLp_dMp,Mp,ph,en)
real(pReal), dimension(3,3), intent(out) :: & real(pReal), dimension(3,3), intent(out) :: &
Lp !< plastic velocity gradient Lp !< plastic velocity gradient
real(pReal), dimension(3,3,3,3), intent(out) :: & real(pReal), dimension(3,3,3,3), intent(out) :: &
dLp_dMp !< derivative of Lp with respect to the Mandel stress dLp_dMp !< derivative of Lp with respect to the Mandel stress
real(pReal), dimension(3,3), intent(in) :: & real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress Mp !< Mandel stress
integer, intent(in) :: & integer, intent(in) :: &
ph, & ph, &
en en
integer :: & integer :: &
i,k,l,m,n i,k,l,m,n
real(pReal), dimension(param(ph)%sum_N_sl) :: & real(pReal), dimension(param(ph)%sum_N_sl) :: &
dot_gamma_sl_pos,dot_gamma_sl_neg, & dot_gamma_sl_pos,dot_gamma_sl_neg, &
ddot_gamma_dtau_sl_pos,ddot_gamma_dtau_sl_neg ddot_gamma_dtau_sl_pos,ddot_gamma_dtau_sl_neg
real(pReal), dimension(param(ph)%sum_N_tw) :: & real(pReal), dimension(param(ph)%sum_N_tw) :: &
dot_gamma_tw,ddot_gamma_dtau_tw dot_gamma_tw,ddot_gamma_dtau_tw
Lp = 0.0_pReal Lp = 0.0_pReal
dLp_dMp = 0.0_pReal dLp_dMp = 0.0_pReal
associate(prm => param(ph)) associate(prm => param(ph))
call kinetics_sl(Mp,ph,en,dot_gamma_sl_pos,dot_gamma_sl_neg,ddot_gamma_dtau_sl_pos,ddot_gamma_dtau_sl_neg) call kinetics_sl(Mp,ph,en,dot_gamma_sl_pos,dot_gamma_sl_neg,ddot_gamma_dtau_sl_pos,ddot_gamma_dtau_sl_neg)
slipSystems: do i = 1, prm%sum_N_sl slipSystems: do i = 1, prm%sum_N_sl
Lp = Lp + (dot_gamma_sl_pos(i)+dot_gamma_sl_neg(i))*prm%P_sl(1:3,1:3,i) Lp = Lp + (dot_gamma_sl_pos(i)+dot_gamma_sl_neg(i))*prm%P_sl(1:3,1:3,i)
forall (k=1:3,l=1:3,m=1:3,n=1:3) & 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) & dLp_dMp(k,l,m,n) = dLp_dMp(k,l,m,n) &
+ ddot_gamma_dtau_sl_pos(i) * prm%P_sl(k,l,i) * prm%P_nS_pos(m,n,i) & + ddot_gamma_dtau_sl_pos(i) * prm%P_sl(k,l,i) * prm%P_nS_pos(m,n,i) &
+ ddot_gamma_dtau_sl_neg(i) * prm%P_sl(k,l,i) * prm%P_nS_neg(m,n,i) + ddot_gamma_dtau_sl_neg(i) * prm%P_sl(k,l,i) * prm%P_nS_neg(m,n,i)
end do slipSystems end do slipSystems
call kinetics_tw(Mp,ph,en,dot_gamma_tw,ddot_gamma_dtau_tw) call kinetics_tw(Mp,ph,en,dot_gamma_tw,ddot_gamma_dtau_tw)
twinSystems: do i = 1, prm%sum_N_tw
twinSystems: do i = 1, prm%sum_N_tw
Lp = Lp + dot_gamma_tw(i)*prm%P_tw(1:3,1:3,i) Lp = Lp + dot_gamma_tw(i)*prm%P_tw(1:3,1:3,i)
forall (k=1:3,l=1:3,m=1:3,n=1:3) & 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) & dLp_dMp(k,l,m,n) = dLp_dMp(k,l,m,n) &
+ ddot_gamma_dtau_tw(i)*prm%P_tw(k,l,i)*prm%P_tw(m,n,i) + ddot_gamma_dtau_tw(i)*prm%P_tw(k,l,i)*prm%P_tw(m,n,i)
end do twinSystems end do twinSystems
end associate end associate
end subroutine phenopowerlaw_LpAndItsTangent end subroutine phenopowerlaw_LpAndItsTangent
@ -340,24 +338,25 @@ end subroutine phenopowerlaw_LpAndItsTangent
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
module function phenopowerlaw_dotState(Mp,ph,en) result(dotState) module function phenopowerlaw_dotState(Mp,ph,en) result(dotState)
real(pReal), dimension(3,3), intent(in) :: & real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress Mp !< Mandel stress
integer, intent(in) :: & integer, intent(in) :: &
ph, & ph, &
en en
real(pReal), dimension(plasticState(ph)%sizeDotState) :: & real(pReal), dimension(plasticState(ph)%sizeDotState) :: &
dotState dotState
real(pReal) :: & real(pReal) :: &
xi_sl_sat_offset,& xi_sl_sat_offset,&
sumF sumF
real(pReal), dimension(param(ph)%sum_N_sl) :: & real(pReal), dimension(param(ph)%sum_N_sl) :: &
dot_gamma_sl_pos,dot_gamma_sl_neg, & dot_gamma_sl_pos,dot_gamma_sl_neg, &
right_SlipSlip right_SlipSlip
real(pReal), dimension(param(ph)%sum_N_tw) :: &
fdot_twin
associate(prm => param(ph), stt => state(ph), & logical :: twinJump !delete this
real(pReal), dimension(3,3) :: deltaFp !delete this
associate(prm => param(ph), stt => state(ph), &
dot_xi_sl => dotState(indexDotState(ph)%xi_sl(1):indexDotState(ph)%xi_sl(2)), & dot_xi_sl => dotState(indexDotState(ph)%xi_sl(1):indexDotState(ph)%xi_sl(2)), &
dot_xi_tw => dotState(indexDotState(ph)%xi_tw(1):indexDotState(ph)%xi_tw(2)), & dot_xi_tw => dotState(indexDotState(ph)%xi_tw(1):indexDotState(ph)%xi_tw(2)), &
dot_gamma_sl => dotState(indexDotState(ph)%gamma_sl(1):indexDotState(ph)%gamma_sl(2)), & dot_gamma_sl => dotState(indexDotState(ph)%gamma_sl(1):indexDotState(ph)%gamma_sl(2)), &
@ -365,11 +364,9 @@ module function phenopowerlaw_dotState(Mp,ph,en) result(dotState)
call kinetics_sl(Mp,ph,en,dot_gamma_sl_pos,dot_gamma_sl_neg) call kinetics_sl(Mp,ph,en,dot_gamma_sl_pos,dot_gamma_sl_neg)
dot_gamma_sl = abs(dot_gamma_sl_pos+dot_gamma_sl_neg) dot_gamma_sl = abs(dot_gamma_sl_pos+dot_gamma_sl_neg)
call kinetics_tw(Mp,ph,en,dot_gamma_tw,fdot_twin) call kinetics_tw(Mp,ph,en,dot_gamma_tw)
!write(6,*)'fdot_twin',fdot_twin call plastic_kinematic_deltaFp(Mp,ph,en,twinJump,deltaFp) ! delete this
if ( en==6 ) then !write(6,*)'param(ph)%sum_N_sl', param(ph)%sum_N_sl ! delete this
write(6,*)'dot_gamma_tw',dot_gamma_tw
end if
sumF = sum(stt%gamma_tw(:,en)/prm%gamma_char) sumF = sum(stt%gamma_tw(:,en)/prm%gamma_char)
xi_sl_sat_offset = prm%f_sat_sl_tw*sqrt(sumF) xi_sl_sat_offset = prm%f_sat_sl_tw*sqrt(sumF)
@ -384,48 +381,52 @@ module function phenopowerlaw_dotState(Mp,ph,en) result(dotState)
* matmul(prm%h_tw_sl,dot_gamma_sl) & * matmul(prm%h_tw_sl,dot_gamma_sl) &
+ prm%h_0_tw_tw * sumF**prm%c_4 * matmul(prm%h_tw_tw,dot_gamma_tw) + prm%h_0_tw_tw * sumF**prm%c_4 * matmul(prm%h_tw_tw,dot_gamma_tw)
end associate end associate
end function phenopowerlaw_dotState end function phenopowerlaw_dotState
----------------------------------------------------------f_twin_nucl---------------------------------------- !--------------------------------------------------------------------------------------------------
> @brief calculates instantaneous incremental change of kinematics and associated jump state !> @brief calculates instantaneous incremental change of kinematics and associated jump state
-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
module subroutine plastic_kinematic_deltaFp(twinJump,deltaFp,Mp,ph,en) module subroutine plastic_kinematic_deltaFp(Mp,ph,en,twinJump,deltaFp)
use math, only: & use math, only: &
math_I3 math_I3
logical , intent(out) :: & real(pReal), dimension(3,3), intent(in) :: &
twinJump
real(pReal), dimension(3,3), intent(out) :: &
deltaFp
real(pReal), dimension(3,3), intent(in) :: &
Mp Mp
integer, intent(in) :: & integer, intent(in) :: &
ph, & ph, &
en en
real(pReal) :: & logical , intent(out) :: &
twinJump
real(pReal), dimension(3,3), intent(out) :: &
deltaFp
real(pReal) :: &
random random
integer :: & integer :: &
twin_var twin_var
real(pReal), dimension(param(ph)%sum_N_tw) :: & real(pReal), dimension(param(ph)%sum_N_tw) :: &
dot_gamma_tw, fdot_twin fdot_twin
twinJump = .false. real(pReal), dimension(param(ph)%sum_N_tw) :: &
deltaFp = math_I3 tau_tw
call kinetics_tw(Mp,ph,en,dot_gamma_tw,fdot_twin) integer :: i
twinJump = .false.
deltaFp = math_I3
tau_tw = [(math_tensordot(Mp,param(ph)%P_tw(1:3,1:3,i)),i=1,param(ph)%sum_N_tw)]
twin_var = maxloc((0.05_pReal*(abs(tau_tw)/state(ph)%xi_tw(:,en))**param(ph)%n_tw)/param(ph)%gamma_char,dim=1) ! This prints values from 1 to 6
fdot_twin = (0.05_pReal*(abs(tau_tw)/state(ph)%xi_tw(:,en))**param(ph)%n_tw)/param(ph)%gamma_char ! This is sometimes >1
twin_var = maxloc(fdot_twin(:),dim=1) ! Correct this write(6,*) 'twin_var', twin_var
!write(6,*)'fdot_twin',fdot_twin call RANDOM_NUMBER(random)
call RANDOM_NUMBER(random) Success_Growth: if (random <= sum(state(ph)%gamma_tw(:,en)/param(ph)%gamma_char)) then
Success_Growth: if (random <= sum(state(ph)%gamma_tw(:,en)/param(ph)%gamma_char)) then
twinJump = .true. twinJump = .true.
deltaFp = param(ph)%CorrespondanceMatrix(:,:,twin_var) deltaFp = param(ph)%CorrespondanceMatrix(:,:,twin_var)
end if Success_Growth end if Success_Growth
@ -435,7 +436,7 @@ end subroutine plastic_kinematic_deltaFp
!> @brief calculates (instantaneous) incremental change of microstructure !> @brief calculates (instantaneous) incremental change of microstructure
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
subroutine plastic_phenopowerlaw_deltaState(instance,of) subroutine plastic_phenopowerlaw_deltaState(instance,of)
use prec, only: & use prec, only: &
dNeq, & dNeq, &
dEq0 dEq0
! #ifdef DEBUG ! #ifdef DEBUG
@ -446,12 +447,12 @@ subroutine plastic_phenopowerlaw_deltaState(instance,of)
! debug_levelSelective ! debug_levelSelective
! #endif ! #endif
implicit none implicit none
integer, intent(in) :: & integer, intent(in) :: &
instance, & instance, &
of of
associate(prm => param(instance), stt => state(instance), dlt => deltaState(instance)) associate(prm => param(instance), stt => state(instance), dlt => deltaState(instance))
! #ifdef DEBUG ! #ifdef DEBUG
! if (iand(debug_level(debug_constitutive), debug_levelExtensive) /= 0_pInt & ! if (iand(debug_level(debug_constitutive), debug_levelExtensive) /= 0_pInt &
@ -462,7 +463,7 @@ subroutine plastic_phenopowerlaw_deltaState(instance,of)
! endif ! endif
! #endif ! #endif
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!dlt%f_twin_nucl(:,of) = 0.0_pReal !dlt%f_twin_nucl(:,of) = 0.0_pReal
!dlt%f_twin_grow(:,of) = 0.0_pReal !dlt%f_twin_grow(:,of) = 0.0_pReal
!dlt%fmc_twin_nucl(:,of) = 0.0_pReal !dlt%fmc_twin_nucl(:,of) = 0.0_pReal
@ -470,22 +471,22 @@ subroutine plastic_phenopowerlaw_deltaState(instance,of)
!dlt%frozen(of) = 0.0_pReal !dlt%frozen(of) = 0.0_pReal
!dlt%variant_twin(of) = 0.0_pInt !dlt%variant_twin(of) = 0.0_pInt
end associate end associate
end subroutine plastic_phenopowerlaw_deltaState end subroutine plastic_phenopowerlaw_deltaState
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief Write results to HDF5 output file. !> @brief Write results to HDF5 output file.
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
module subroutine plastic_phenopowerlaw_results(ph,group) module subroutine plastic_phenopowerlaw_results(ph,group)
integer, intent(in) :: ph integer, intent(in) :: ph
character(len=*), intent(in) :: group character(len=*), intent(in) :: group
integer :: ou integer :: ou
associate(prm => param(ph), stt => state(ph)) associate(prm => param(ph), stt => state(ph))
do ou = 1,size(prm%output) do ou = 1,size(prm%output)
@ -509,7 +510,7 @@ module subroutine plastic_phenopowerlaw_results(ph,group)
end do end do
end associate end associate
end subroutine plastic_phenopowerlaw_results end subroutine plastic_phenopowerlaw_results
@ -524,25 +525,25 @@ end subroutine plastic_phenopowerlaw_results
pure subroutine kinetics_sl(Mp,ph,en, & pure subroutine kinetics_sl(Mp,ph,en, &
dot_gamma_sl_pos,dot_gamma_sl_neg,ddot_gamma_dtau_sl_pos,ddot_gamma_dtau_sl_neg) dot_gamma_sl_pos,dot_gamma_sl_neg,ddot_gamma_dtau_sl_pos,ddot_gamma_dtau_sl_neg)
real(pReal), dimension(3,3), intent(in) :: & real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress Mp !< Mandel stress
integer, intent(in) :: & integer, intent(in) :: &
ph, & ph, &
en en
real(pReal), intent(out), dimension(param(ph)%sum_N_sl) :: & real(pReal), intent(out), dimension(param(ph)%sum_N_sl) :: &
dot_gamma_sl_pos, & dot_gamma_sl_pos, &
dot_gamma_sl_neg dot_gamma_sl_neg
real(pReal), intent(out), optional, dimension(param(ph)%sum_N_sl) :: & real(pReal), intent(out), optional, dimension(param(ph)%sum_N_sl) :: &
ddot_gamma_dtau_sl_pos, & ddot_gamma_dtau_sl_pos, &
ddot_gamma_dtau_sl_neg ddot_gamma_dtau_sl_neg
real(pReal), dimension(param(ph)%sum_N_sl) :: & real(pReal), dimension(param(ph)%sum_N_sl) :: &
tau_sl_pos, & tau_sl_pos, &
tau_sl_neg tau_sl_neg
integer :: i integer :: i
associate(prm => param(ph), stt => state(ph)) associate(prm => param(ph), stt => state(ph))
do i = 1, prm%sum_N_sl do i = 1, prm%sum_N_sl
tau_sl_pos(i) = math_tensordot(Mp,prm%P_nS_pos(1:3,1:3,i)) tau_sl_pos(i) = math_tensordot(Mp,prm%P_nS_pos(1:3,1:3,i))
@ -579,7 +580,7 @@ pure subroutine kinetics_sl(Mp,ph,en, &
end where end where
end if end if
end associate end associate
end subroutine kinetics_sl end subroutine kinetics_sl
@ -592,35 +593,33 @@ end subroutine kinetics_sl
! have the optional arguments at the end. ! have the optional arguments at the end.
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure subroutine kinetics_tw(Mp,ph,en,& pure subroutine kinetics_tw(Mp,ph,en,&
dot_gamma_tw,fdot_twin,ddot_gamma_dtau_tw) dot_gamma_tw,ddot_gamma_dtau_tw)
real(pReal), dimension(3,3), intent(in) :: & real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress Mp !< Mandel stress
integer, intent(in) :: & integer, intent(in) :: &
ph, & ph, &
en en
real(pReal), dimension(param(ph)%sum_N_tw), intent(out) :: & real(pReal), dimension(param(ph)%sum_N_tw), intent(out) :: &
dot_gamma_tw, fdot_twin dot_gamma_tw
real(pReal), dimension(param(ph)%sum_N_tw), intent(out), optional :: & real(pReal), dimension(param(ph)%sum_N_tw), intent(out), optional :: &
ddot_gamma_dtau_tw ddot_gamma_dtau_tw
real(pReal), dimension(param(ph)%sum_N_tw) :: & real(pReal), dimension(param(ph)%sum_N_tw) :: &
tau_tw tau_tw
integer :: i integer :: i
associate(prm => param(ph), stt => state(ph)) associate(prm => param(ph), stt => state(ph))
tau_tw = [(math_tensordot(Mp,prm%P_tw(1:3,1:3,i)),i=1,prm%sum_N_tw)] tau_tw = [(math_tensordot(Mp,prm%P_tw(1:3,1:3,i)),i=1,prm%sum_N_tw)]
where(tau_tw > 0.0_pReal) where(tau_tw > 0.0_pReal)
dot_gamma_tw = (1.0_pReal-sum(stt%gamma_tw(:,en)/prm%gamma_char)) & ! only twin in untwinned volume fraction dot_gamma_tw = (1.0_pReal-sum(stt%gamma_tw(:,en)/prm%gamma_char)) & ! only twin in untwinned volume fraction
* prm%dot_gamma_0_tw*(abs(tau_tw)/stt%xi_tw(:,en))**prm%n_tw * prm%dot_gamma_0_tw*(abs(tau_tw)/stt%xi_tw(:,en))**prm%n_tw
fdot_twin = (prm%dot_gamma_0_tw*(abs(tau_tw)/stt%xi_tw(:,en))**prm%n_tw)/prm%gamma_char
else where else where
dot_gamma_tw = 0.0_pReal dot_gamma_tw = 0.0_pReal
fdot_twin = 0.0_pReal
end where end where
if (present(ddot_gamma_dtau_tw)) then if (present(ddot_gamma_dtau_tw)) then
@ -631,7 +630,7 @@ pure subroutine kinetics_tw(Mp,ph,en,&
end where end where
end if end if
end associate end associate
end subroutine kinetics_tw end subroutine kinetics_tw