2015-04-21 20:46:13 +05:30
!--------------------------------------------------------------------------------------------------
2014-11-06 00:41:09 +05:30
!> @author Franz Roters, Max-Planck-Institut für Eisenforschung GmbH
!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH
!> @author David Cereceda, Lawrence Livermore National Laboratory
!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH
!> @brief material subroutine incoprorating dislocation and twinning physics
!> @details to be done
!--------------------------------------------------------------------------------------------------
2015-01-21 20:44:00 +05:30
module plastic_disloUCLA
2014-11-06 00:41:09 +05:30
use prec , only : &
pReal , &
pInt
implicit none
private
integer ( pInt ) , dimension ( : ) , allocatable , public , protected :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_sizePostResults !< cumulative size of post results
2014-11-06 00:41:09 +05:30
integer ( pInt ) , dimension ( : , : ) , allocatable , target , public :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_sizePostResult !< size of each post result output
2014-11-06 00:41:09 +05:30
character ( len = 64 ) , dimension ( : , : ) , allocatable , target , public :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_output !< name of each post result output
2014-11-06 00:41:09 +05:30
real ( pReal ) , parameter , private :: &
2016-04-25 02:06:35 +05:30
kB = 1.38e-23_pReal !< Boltzmann constant in J/Kelvin
2014-11-06 00:41:09 +05:30
integer ( pInt ) , dimension ( : ) , allocatable , target , public :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_Noutput !< number of outputs per instance of this plasticity
2014-11-06 00:41:09 +05:30
2016-01-16 12:36:34 +05:30
integer ( pInt ) , dimension ( : ) , allocatable , private :: &
2016-04-25 02:06:35 +05:30
plastic_disloUCLA_totalNslip !< total number of active slip systems for each instance
2014-11-06 00:41:09 +05:30
integer ( pInt ) , dimension ( : , : ) , allocatable , private :: &
2016-04-25 02:06:35 +05:30
plastic_disloUCLA_Nslip !< number of active slip systems for each family and instance
2014-11-06 00:41:09 +05:30
real ( pReal ) , dimension ( : ) , allocatable , private :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_CAtomicVolume , & !< atomic volume in Bugers vector unit
plastic_disloUCLA_D0 , & !< prefactor for self-diffusion coefficient
plastic_disloUCLA_Qsd , & !< activation energy for dislocation climb
plastic_disloUCLA_GrainSize , & !< grain size
plastic_disloUCLA_CEdgeDipMinDistance , & !<
plastic_disloUCLA_SolidSolutionStrength , & !< Strength due to elements in solid solution
plastic_disloUCLA_dipoleFormationFactor , & !< scaling factor for dipole formation: 0: off, 1: on. other values not useful
2016-04-25 02:06:35 +05:30
plastic_disloUCLA_aTolRho !< absolute tolerance for integration of dislocation density
2014-11-06 00:41:09 +05:30
real ( pReal ) , dimension ( : , : ) , allocatable , private :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_rhoEdge0 , & !< initial edge dislocation density per slip system for each family and instance
plastic_disloUCLA_rhoEdgeDip0 , & !< initial edge dipole density per slip system for each family and instance
plastic_disloUCLA_burgersPerSlipFamily , & !< absolute length of burgers vector [m] for each slip family and instance
plastic_disloUCLA_burgersPerSlipSystem , & !< absolute length of burgers vector [m] for each slip system and instance
plastic_disloUCLA_QedgePerSlipFamily , & !< activation energy for glide [J] for each slip family and instance
plastic_disloUCLA_QedgePerSlipSystem , & !< activation energy for glide [J] for each slip system and instance
plastic_disloUCLA_v0PerSlipFamily , & !< dislocation velocity prefactor [m/s] for each family and instance
plastic_disloUCLA_v0PerSlipSystem , & !< dislocation velocity prefactor [m/s] for each slip system and instance
plastic_disloUCLA_tau_peierlsPerSlipFamily , & !< Peierls stress [Pa] for each family and instance
plastic_disloUCLA_CLambdaSlipPerSlipFamily , & !< Adj. parameter for distance between 2 forest dislocations for each slip family and instance
plastic_disloUCLA_CLambdaSlipPerSlipSystem , & !< Adj. parameter for distance between 2 forest dislocations for each slip system and instance
plastic_disloUCLA_interaction_SlipSlip , & !< coefficients for slip-slip interaction for each interaction type and instance
plastic_disloUCLA_pPerSlipFamily , & !< p-exponent in glide velocity
plastic_disloUCLA_qPerSlipFamily , & !< q-exponent in glide velocity
2015-01-15 16:26:15 +05:30
!* mobility law parameters
2016-04-25 02:06:35 +05:30
plastic_disloUCLA_kinkheight , & !< height of the kink pair
plastic_disloUCLA_omega , & !< attempt frequency for kink pair nucleation
2018-11-28 21:42:06 +05:30
plastic_disloUCLA_kinkwidth , & !< width of the kink pair
2016-04-25 02:06:35 +05:30
plastic_disloUCLA_friction , & !< friction coeff. B (kMC)
2015-01-15 16:26:15 +05:30
!*
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_nonSchmidCoeff !< non-Schmid coefficients (bcc)
2014-11-06 00:41:09 +05:30
real ( pReal ) , dimension ( : , : , : ) , allocatable , private :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_interactionMatrix_SlipSlip , & !< interaction matrix of the different slip systems for each instance
plastic_disloUCLA_forestProjectionEdge !< matrix of forest projections of edge dislocations for each instance
2014-11-06 00:41:09 +05:30
enum , bind ( c )
enumerator :: undefined_ID , &
2018-11-28 10:29:03 +05:30
rho_ID , &
rhoDip_ID , &
shearrate_ID , &
accumulatedshear_ID , &
mfp_ID , &
resolvedstress_ID , &
thresholdstress_ID , &
dipoledistance_ID , &
stressexponent_ID
2014-11-06 00:41:09 +05:30
end enum
2018-11-28 00:30:45 +05:30
type , private :: tParameters
real ( pReal ) , allocatable , dimension ( : ) :: &
2018-11-28 10:29:03 +05:30
rho0 , & !< initial edge dislocation density per slip system for each family and instance
rhoDip0 , & !< initial edge dipole density per slip system for each family and instance
burgers , & !< absolute length of burgers vector [m] for each slip system and instance
H0kp , & !< activation energy for glide [J] for each slip system and instance
v0 , & !< dislocation velocity prefactor [m/s] for each family and instance
CLambda , & !< Adj. parameter for distance between 2 forest dislocations for each slip system and instance
p , & !< p-exponent in glide velocity
q , & !< q-exponent in glide velocity
!* mobility law parameters
kinkheight , & !< height of the kink pair
nu0 , & !< attempt frequency for kink pair nucleation
kinkwidth , & !< width of the kink pair
!dislolength, & !< dislocation length (lamda)
viscosity , & !< friction coeff. B (kMC)
!*
tauPeierls , &
2018-11-28 00:30:45 +05:30
nonSchmidCoeff
real ( pReal ) , allocatable , dimension ( : , : ) :: &
interaction_SlipSlip !< slip resistance from slip activity
real ( pReal ) , allocatable , dimension ( : , : , : ) :: &
Schmid_slip , &
Schmid_twin , &
nonSchmid_pos , &
nonSchmid_neg
integer ( pInt ) :: &
totalNslip !< total number of active slip system
integer ( pInt ) , allocatable , dimension ( : ) :: &
Nslip !< number of active slip systems for each family
integer ( kind ( undefined_ID ) ) , allocatable , dimension ( : ) :: &
outputID !< ID of each post result output
end type !< container type for internal constitutive parameters
type ( tParameters ) , dimension ( : ) , allocatable , private :: param !< containers of constitutive parameters (len Ninstance)
2014-11-06 00:41:09 +05:30
integer ( kind ( undefined_ID ) ) , dimension ( : , : ) , allocatable , private :: &
2016-01-16 12:36:34 +05:30
plastic_disloUCLA_outputID !< ID of each post result output
2016-01-15 20:56:24 +05:30
type , private :: tDisloUCLAState
real ( pReal ) , pointer , dimension ( : , : ) :: &
rhoEdge , &
rhoEdgeDip , &
accshear_slip , &
invLambdaSlip , &
mfp_slip , &
2016-04-25 02:06:35 +05:30
threshold_stress_slip
2016-01-15 20:56:24 +05:30
end type
type ( tDisloUCLAState ) , allocatable , dimension ( : ) , private :: &
state , &
state0 , &
dotState
2014-11-06 00:41:09 +05:30
public :: &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_init , &
plastic_disloUCLA_microstructure , &
plastic_disloUCLA_LpAndItsTangent , &
plastic_disloUCLA_dotState , &
plastic_disloUCLA_postResults
2014-11-06 00:41:09 +05:30
private :: &
2018-11-28 21:42:06 +05:30
plastic_disloUCLA_stateInit
2014-11-06 00:41:09 +05:30
contains
!--------------------------------------------------------------------------------------------------
!> @brief module initialization
!> @details reads in material parameters, allocates arrays, and does sanity checks
!--------------------------------------------------------------------------------------------------
2015-01-21 20:44:00 +05:30
subroutine plastic_disloUCLA_init ( fileUnit )
2018-02-02 17:06:09 +05:30
#if defined(__GFORTRAN__) || __INTEL_COMPILER >= 1800
2017-10-05 20:05:34 +05:30
use , intrinsic :: iso_fortran_env , only : &
compiler_version , &
compiler_options
#endif
2014-11-06 00:41:09 +05:30
use debug , only : &
debug_level , &
debug_constitutive , &
debug_levelBasic
use math , only : &
math_Mandel3333to66 , &
math_Voigt66to3333 , &
math_mul3x3
use IO , only : &
IO_read , &
IO_lc , &
IO_getTag , &
IO_isBlank , &
IO_stringPos , &
IO_stringValue , &
IO_floatValue , &
IO_intValue , &
IO_warning , &
IO_error , &
IO_timeStamp , &
IO_EOF
use material , only : &
phase_plasticity , &
phase_plasticityInstance , &
phase_Noutput , &
2015-01-15 16:26:15 +05:30
PLASTICITY_DISLOUCLA_label , &
PLASTICITY_DISLOUCLA_ID , &
2018-06-10 21:31:52 +05:30
material_phase , &
2018-11-27 23:58:00 +05:30
plasticState , &
material_allocatePlasticState
2018-06-14 10:09:49 +05:30
use config , only : &
2018-11-28 00:30:45 +05:30
MATERIAL_partPhase , &
config_phase
2014-11-06 00:41:09 +05:30
use lattice
implicit none
integer ( pInt ) , intent ( in ) :: fileUnit
2015-08-28 13:08:48 +05:30
integer ( pInt ) , allocatable , dimension ( : ) :: chunkPos
2016-04-25 02:06:35 +05:30
integer ( pInt ) :: maxNinstance , mySize = 0_pInt , phase , maxTotalNslip , &
2018-11-28 10:29:03 +05:30
f , instance , j , k , o , ns , i , &
2018-11-28 21:15:45 +05:30
Nchunks_SlipSlip = 0_pInt , outputSize , &
2016-04-25 02:06:35 +05:30
Nchunks_SlipFamilies = 0_pInt , Nchunks_nonSchmid = 0_pInt , &
2016-01-15 20:56:24 +05:30
offset_slip , index_myFamily , index_otherFamily , &
2018-11-28 00:30:45 +05:30
startIndex , endIndex , p
2015-06-01 21:32:27 +05:30
integer ( pInt ) :: sizeState , sizeDotState , sizeDeltaState
2014-11-06 00:41:09 +05:30
integer ( pInt ) :: NofMyPhase
character ( len = 65536 ) :: &
2018-11-28 00:30:45 +05:30
structure = '' , &
2014-11-06 00:41:09 +05:30
tag = '' , &
line = ''
2016-04-25 02:06:35 +05:30
real ( pReal ) , dimension ( : ) , allocatable :: tempPerSlip
2018-11-28 10:29:03 +05:30
character ( len = 65536 ) , dimension ( : ) , allocatable :: outputs
integer ( kind ( undefined_ID ) ) :: outputID
2018-11-28 00:30:45 +05:30
integer ( pInt ) , dimension ( 0 ) , parameter :: emptyIntArray = [ integer ( pInt ) :: ]
real ( pReal ) , dimension ( 0 ) , parameter :: emptyRealArray = [ real ( pReal ) :: ]
character ( len = 65536 ) , dimension ( 0 ) , parameter :: emptyStringArray = [ character ( len = 65536 ) :: ]
2014-11-06 00:41:09 +05:30
2016-07-25 23:42:00 +05:30
write ( 6 , '(/,a)' ) ' <<<+- constitutive_' / / PLASTICITY_DISLOUCLA_label / / ' init -+>>>'
2018-04-22 13:37:49 +05:30
write ( 6 , '(/,a)' ) ' Cereceda et al., International Journal of Plasticity 78, 2016, 242-256'
2018-04-09 18:34:37 +05:30
write ( 6 , '(/,a)' ) ' http://dx.doi.org/10.1016/j.ijplas.2015.09.002'
2016-07-25 23:42:00 +05:30
write ( 6 , '(a15,a)' ) ' Current time: ' , IO_timeStamp ( )
2014-11-06 00:41:09 +05:30
#include "compilation_info.f90"
2015-01-15 16:26:15 +05:30
maxNinstance = int ( count ( phase_plasticity == PLASTICITY_DISLOUCLA_ID ) , pInt )
2014-11-06 00:41:09 +05:30
if ( maxNinstance == 0_pInt ) return
if ( iand ( debug_level ( debug_constitutive ) , debug_levelBasic ) / = 0_pInt ) &
write ( 6 , '(a16,1x,i5,/)' ) '# instances:' , maxNinstance
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_sizePostResults ( maxNinstance ) , source = 0_pInt )
allocate ( plastic_disloUCLA_sizePostResult ( maxval ( phase_Noutput ) , maxNinstance ) , source = 0_pInt )
allocate ( plastic_disloUCLA_output ( maxval ( phase_Noutput ) , maxNinstance ) )
plastic_disloUCLA_output = ''
allocate ( plastic_disloUCLA_outputID ( maxval ( phase_Noutput ) , maxNinstance ) , source = undefined_ID )
allocate ( plastic_disloUCLA_Noutput ( maxNinstance ) , source = 0_pInt )
allocate ( plastic_disloUCLA_Nslip ( lattice_maxNslipFamily , maxNinstance ) , source = 0_pInt )
allocate ( plastic_disloUCLA_totalNslip ( maxNinstance ) , source = 0_pInt )
allocate ( plastic_disloUCLA_CAtomicVolume ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_D0 ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_Qsd ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_GrainSize ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_CEdgeDipMinDistance ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_SolidSolutionStrength ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_aTolRho ( maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_dipoleFormationFactor ( maxNinstance ) , source = 1.0_pReal ) !should be on by default
allocate ( plastic_disloUCLA_rhoEdge0 ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_rhoEdgeDip0 ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_burgersPerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
2015-01-23 18:38:25 +05:30
allocate ( plastic_disloUCLA_kinkheight ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_omega ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_kinkwidth ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_friction ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_QedgePerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_v0PerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_tau_peierlsPerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , &
2014-12-11 20:34:16 +05:30
source = 0.0_pReal )
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_pPerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_qPerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , source = 0.0_pReal )
2016-04-25 02:06:35 +05:30
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_CLambdaSlipPerSlipFamily ( lattice_maxNslipFamily , maxNinstance ) , &
2014-12-11 20:34:16 +05:30
source = 0.0_pReal )
2016-04-25 02:06:35 +05:30
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_interaction_SlipSlip ( lattice_maxNinteraction , maxNinstance ) , source = 0.0_pReal )
2016-04-25 02:06:35 +05:30
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_nonSchmidCoeff ( lattice_maxNnonSchmid , maxNinstance ) , source = 0.0_pReal )
2014-11-06 00:41:09 +05:30
2018-11-28 00:30:45 +05:30
allocate ( param ( maxNinstance ) )
allocate ( state ( maxNinstance ) )
allocate ( state0 ( maxNinstance ) )
allocate ( dotState ( maxNinstance ) )
do p = 1_pInt , size ( phase_plasticityInstance )
if ( phase_plasticity ( p ) / = PLASTICITY_DISLOUCLA_ID ) cycle
associate ( prm = > param ( phase_plasticityInstance ( p ) ) , &
dot = > dotState ( phase_plasticityInstance ( p ) ) , &
stt = > state ( phase_plasticityInstance ( p ) ) )
structure = config_phase ( p ) % getString ( 'lattice_structure' )
!--------------------------------------------------------------------------------------------------
! slip related parameters
prm % Nslip = config_phase ( p ) % getInts ( 'nslip' , defaultVal = emptyIntArray )
prm % totalNslip = sum ( prm % Nslip )
slipActive : if ( prm % totalNslip > 0_pInt ) then
prm % Schmid_slip = lattice_SchmidMatrix_slip ( prm % Nslip , structure ( 1 : 3 ) , &
config_phase ( p ) % getFloat ( 'c/a' , defaultVal = 0.0_pReal ) )
if ( structure == 'bcc' ) then
prm % nonSchmidCoeff = config_phase ( p ) % getFloats ( 'nonschmid_coefficients' , &
defaultVal = emptyRealArray )
prm % nonSchmid_pos = lattice_nonSchmidMatrix ( prm % Nslip , prm % nonSchmidCoeff , + 1_pInt )
prm % nonSchmid_neg = lattice_nonSchmidMatrix ( prm % Nslip , prm % nonSchmidCoeff , - 1_pInt )
else
prm % nonSchmid_pos = prm % Schmid_slip
prm % nonSchmid_neg = prm % Schmid_slip
endif
prm % interaction_SlipSlip = lattice_interaction_SlipSlip ( prm % Nslip , &
config_phase ( p ) % getFloats ( 'interaction_slipslip' ) , &
structure ( 1 : 3 ) )
2018-11-28 10:29:03 +05:30
!prm%rho0 = config_phase(p)%getFloats('rho0')
!prm%rhoDip0 = config_phase(p)%getFloats('dipole_rho0')
!prm%burgers = config_phase(p)%getFloats('burgers')
!prm%H0kp = config_phase(p)%getFloats('h0')
!prm%v0 = config_phase(p)%getFloats('v0')
!prm%clambda = config_phase(p)%getFloats('clambda')
!prm%tauPeierls = config_phase(p)%getFloats('peierls_stress')
!prm%p = config_phase(p)%getFloats('pexponent',defaultVal=[(1.0_pReal,i=1_pInt,size(prm%Nslip))])
!prm%q = config_phase(p)%getFloats('qexponent',defaultVal=[(1.0_pReal,i=1_pInt,size(prm%Nslip))])
!prm%kinkHeight = config_phase(p)%getFloats('kink_height')
!prm%kinkWidth = config_phase(p)%getFloats('kink_width')
!prm%nu0 = config_phase(p)%getFloats('attemptfrequency')
!prm%dislolength = config_phase(p)%getFloats('dislolength') ! what is this used for?
!prm%viscosity = config_phase(p)%getFloats('viscosity')
2018-11-28 00:30:45 +05:30
endif slipActive
2018-11-28 10:29:03 +05:30
!--------------------------------------------------------------------------------------------------
! phase outputs
#if defined(__GFORTRAN__)
outputs = [ 'GfortranBug86277' ]
outputs = config_phase ( p ) % getStrings ( '(output)' , defaultVal = outputs )
if ( outputs ( 1 ) == 'GfortranBug86277' ) outputs = emptyStringArray
#else
outputs = config_phase ( p ) % getStrings ( '(output)' , defaultVal = emptyStringArray )
#endif
allocate ( prm % outputID ( 0 ) )
do i = 1_pInt , size ( outputs )
outputID = undefined_ID
outputSize = prm % totalNslip
select case ( trim ( outputs ( i ) ) )
case ( 'edge_density' )
2018-11-28 21:15:45 +05:30
outputID = merge ( rho_ID , undefined_ID , prm % totalNslip > 0_pInt )
2018-11-28 10:29:03 +05:30
case ( 'dipole_density' )
2018-11-28 21:15:45 +05:30
outputID = merge ( rhoDip_ID , undefined_ID , prm % totalNslip > 0_pInt )
case ( 'shear_rate' , 'shearrate' , 'shear_rate_slip' , 'shearrate_slip' )
outputID = merge ( shearrate_ID , undefined_ID , prm % totalNslip > 0_pInt )
case ( 'accumulated_shear' , 'accumulatedshear' , 'accumulated_shear_slip' )
outputID = merge ( accumulatedshear_ID , undefined_ID , prm % totalNslip > 0_pInt )
case ( 'mfp' , 'mfp_slip' )
outputID = merge ( mfp_ID , undefined_ID , prm % totalNslip > 0_pInt )
case ( 'resolved_stress' , 'resolved_stress_slip' )
outputID = merge ( resolvedstress_ID , undefined_ID , prm % totalNslip > 0_pInt )
case ( 'threshold_stress' , 'threshold_stress_slip' )
outputID = merge ( thresholdstress_ID , undefined_ID , prm % totalNslip > 0_pInt )
2018-11-28 10:29:03 +05:30
case ( 'edge_dipole_distance' )
2018-11-28 21:15:45 +05:30
outputID = merge ( dipoleDistance_ID , undefined_ID , prm % totalNslip > 0_pInt )
2018-11-28 10:29:03 +05:30
case ( 'stress_exponent' )
2018-11-28 21:15:45 +05:30
outputID = merge ( stressexponent_ID , undefined_ID , prm % totalNslip > 0_pInt )
2018-11-28 10:29:03 +05:30
end select
2018-11-28 21:15:45 +05:30
if ( outputID / = undefined_ID ) then
plastic_disloUCLA_output ( i , phase_plasticityInstance ( p ) ) = outputs ( i )
plastic_disloUCLA_sizePostResult ( i , phase_plasticityInstance ( p ) ) = outputSize
prm % outputID = [ prm % outputID , outputID ]
plastic_disloUCLA_outputID ( i , phase_plasticityInstance ( p ) ) = outputID
plastic_disloUCLA_sizePostResults ( phase_plasticityInstance ( p ) ) = &
plastic_disloUCLA_sizePostResults ( phase_plasticityInstance ( p ) ) + outputSize
plastic_disloUCLA_Noutput ( phase_plasticityInstance ( p ) ) = plastic_disloUCLA_Noutput ( phase_plasticityInstance ( p ) ) + 1_pInt
endif
2018-11-28 10:29:03 +05:30
enddo
2018-11-28 00:30:45 +05:30
end associate
enddo
2018-11-28 21:42:06 +05:30
2014-11-06 00:41:09 +05:30
rewind ( fileUnit )
phase = 0_pInt
do while ( trim ( line ) / = IO_EOF . and . IO_lc ( IO_getTag ( line , '<' , '>' ) ) / = MATERIAL_partPhase ) ! wind forward to <phase>
line = IO_read ( fileUnit )
enddo
parsingFile : do while ( trim ( line ) / = IO_EOF ) ! read through sections of phase part
line = IO_read ( fileUnit )
if ( IO_isBlank ( line ) ) cycle ! skip empty lines
if ( IO_getTag ( line , '<' , '>' ) / = '' ) then ! stop at next part
line = IO_read ( fileUnit , . true . ) ! reset IO_read
exit
endif
if ( IO_getTag ( line , '[' , ']' ) / = '' ) then ! next phase section
phase = phase + 1_pInt ! advance phase section counter
2015-01-15 16:26:15 +05:30
if ( phase_plasticity ( phase ) == PLASTICITY_DISLOUCLA_ID ) then
2014-11-06 00:41:09 +05:30
Nchunks_SlipFamilies = count ( lattice_NslipSystem ( : , phase ) > 0_pInt )
Nchunks_SlipSlip = maxval ( lattice_interactionSlipSlip ( : , : , phase ) )
Nchunks_nonSchmid = lattice_NnonSchmid ( phase )
if ( allocated ( tempPerSlip ) ) deallocate ( tempPerSlip )
allocate ( tempPerSlip ( Nchunks_SlipFamilies ) )
endif
cycle ! skip to next line
endif
2015-01-15 16:26:15 +05:30
if ( phase > 0_pInt ) then ; if ( phase_plasticity ( phase ) == PLASTICITY_DISLOUCLA_ID ) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
2014-11-06 00:41:09 +05:30
instance = phase_plasticityInstance ( phase ) ! which instance of my plasticity is present phase
2015-08-28 13:08:48 +05:30
chunkPos = IO_stringPos ( line )
tag = IO_lc ( IO_stringValue ( line , chunkPos , 1_pInt ) ) ! extract key
2014-11-06 00:41:09 +05:30
select case ( tag )
!--------------------------------------------------------------------------------------------------
! parameters depending on number of slip system families
case ( 'nslip' )
2015-08-28 13:08:48 +05:30
if ( chunkPos ( 1 ) < Nchunks_SlipFamilies + 1_pInt ) &
2015-01-15 16:26:15 +05:30
call IO_warning ( 50_pInt , ext_msg = trim ( tag ) / / ' (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-08-28 13:08:48 +05:30
if ( chunkPos ( 1 ) > Nchunks_SlipFamilies + 1_pInt ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 150_pInt , ext_msg = trim ( tag ) / / ' (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-08-28 13:08:48 +05:30
Nchunks_SlipFamilies = chunkPos ( 1 ) - 1_pInt
2014-11-06 00:41:09 +05:30
do j = 1_pInt , Nchunks_SlipFamilies
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_Nslip ( j , instance ) = IO_intValue ( line , chunkPos , 1_pInt + j )
2014-11-06 00:41:09 +05:30
enddo
case ( 'rhoedge0' , 'rhoedgedip0' , 'slipburgers' , 'qedge' , 'v0' , 'clambdaslip' , 'tau_peierls' , 'p_slip' , 'q_slip' , &
2015-01-21 20:44:00 +05:30
'kink_height' , 'omega' , 'kink_width' , 'dislolength' , 'friction_coeff' )
2014-11-06 00:41:09 +05:30
do j = 1_pInt , Nchunks_SlipFamilies
2015-08-28 13:08:48 +05:30
tempPerSlip ( j ) = IO_floatValue ( line , chunkPos , 1_pInt + j )
2014-11-06 00:41:09 +05:30
enddo
select case ( tag )
case ( 'rhoedge0' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_rhoEdge0 ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'rhoedgedip0' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_rhoEdgeDip0 ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'slipburgers' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_burgersPerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'qedge' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_QedgePerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'v0' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_v0PerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'clambdaslip' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_CLambdaSlipPerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'tau_peierls' )
if ( lattice_structure ( phase ) / = LATTICE_bcc_ID ) &
2015-01-15 16:26:15 +05:30
call IO_warning ( 42_pInt , ext_msg = trim ( tag ) / / ' for non-bcc (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_tau_peierlsPerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'p_slip' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_pPerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
case ( 'q_slip' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_qPerSlipFamily ( 1 : Nchunks_SlipFamilies , instance ) = tempPerSlip ( 1 : Nchunks_SlipFamilies )
2015-01-15 16:26:15 +05:30
case ( 'kink_height' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_kinkheight ( 1 : Nchunks_SlipFamilies , instance ) = &
2015-01-16 04:10:17 +05:30
tempPerSlip ( 1 : Nchunks_SlipFamilies )
2015-01-15 16:26:15 +05:30
case ( 'omega' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_omega ( 1 : Nchunks_SlipFamilies , instance ) = &
2015-01-16 04:10:17 +05:30
tempPerSlip ( 1 : Nchunks_SlipFamilies )
2015-01-15 16:26:15 +05:30
case ( 'kink_width' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_kinkwidth ( 1 : Nchunks_SlipFamilies , instance ) = &
2015-01-16 04:10:17 +05:30
tempPerSlip ( 1 : Nchunks_SlipFamilies )
case ( 'friction_coeff' )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_friction ( 1 : Nchunks_SlipFamilies , instance ) = &
2015-01-16 04:10:17 +05:30
tempPerSlip ( 1 : Nchunks_SlipFamilies )
2014-11-06 00:41:09 +05:30
end select
2016-04-25 00:35:05 +05:30
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
! parameters depending on number of interactions
case ( 'interaction_slipslip' , 'interactionslipslip' )
2015-08-28 13:08:48 +05:30
if ( chunkPos ( 1 ) < 1_pInt + Nchunks_SlipSlip ) &
2015-01-15 16:26:15 +05:30
call IO_warning ( 52_pInt , ext_msg = trim ( tag ) / / ' (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2014-11-06 00:41:09 +05:30
do j = 1_pInt , Nchunks_SlipSlip
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_interaction_SlipSlip ( j , instance ) = IO_floatValue ( line , chunkPos , 1_pInt + j )
2014-11-06 00:41:09 +05:30
enddo
case ( 'nonschmid_coefficients' )
2015-08-28 13:08:48 +05:30
if ( chunkPos ( 1 ) < 1_pInt + Nchunks_nonSchmid ) &
2015-01-15 16:26:15 +05:30
call IO_warning ( 52_pInt , ext_msg = trim ( tag ) / / ' (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2014-11-06 00:41:09 +05:30
do j = 1_pInt , Nchunks_nonSchmid
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_nonSchmidCoeff ( j , instance ) = IO_floatValue ( line , chunkPos , 1_pInt + j )
2014-11-06 00:41:09 +05:30
enddo
!--------------------------------------------------------------------------------------------------
2016-04-25 02:06:35 +05:30
! parameters independent of number of slip systems
2014-11-06 00:41:09 +05:30
case ( 'grainsize' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_GrainSize ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'd0' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_D0 ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'qsd' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_Qsd ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'atol_rho' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_aTolRho ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'solidsolutionstrength' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_SolidSolutionStrength ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'cedgedipmindistance' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_CEdgeDipMinDistance ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'catomicvolume' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_CAtomicVolume ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
case ( 'dipoleformationfactor' )
2015-08-28 13:08:48 +05:30
plastic_disloUCLA_dipoleFormationFactor ( instance ) = IO_floatValue ( line , chunkPos , 2_pInt )
2014-11-06 00:41:09 +05:30
end select
endif ; endif
enddo parsingFile
sanityChecks : do phase = 1_pInt , size ( phase_plasticity )
2015-01-21 20:44:00 +05:30
myPhase : if ( phase_plasticity ( phase ) == PLASTICITY_disloUCLA_ID ) then
2014-11-06 00:41:09 +05:30
instance = phase_plasticityInstance ( phase )
2015-01-21 20:44:00 +05:30
if ( sum ( plastic_disloUCLA_Nslip ( : , instance ) ) < 0_pInt ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'Nslip (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2014-11-06 00:41:09 +05:30
do f = 1_pInt , lattice_maxNslipFamily
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_Nslip ( f , instance ) > 0_pInt ) then
if ( plastic_disloUCLA_rhoEdge0 ( f , instance ) < 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'rhoEdge0 (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_rhoEdgeDip0 ( f , instance ) < 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'rhoEdgeDip0 (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) < = 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'slipBurgers (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_v0PerSlipFamily ( f , instance ) < = 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'v0 (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) < 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'tau_peierls (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2014-11-06 00:41:09 +05:30
endif
enddo
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_CAtomicVolume ( instance ) < = 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'cAtomicVolume (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_D0 ( instance ) < = 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'D0 (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2015-01-21 20:44:00 +05:30
if ( plastic_disloUCLA_Qsd ( instance ) < = 0.0_pReal ) &
2015-01-15 16:26:15 +05:30
call IO_error ( 211_pInt , el = instance , ext_msg = 'Qsd (' / / PLASTICITY_DISLOUCLA_label / / ')' )
2016-04-25 02:06:35 +05:30
! if (plastic_disloUCLA_aTolRho(instance) <= 0.0_pReal) &
! call IO_error(211_pInt,el=instance,ext_msg='aTolRho ('//PLASTICITY_DISLOUCLA_label//')')
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
2016-04-25 02:06:35 +05:30
! Determine total number of active slip systems
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_Nslip ( : , instance ) = min ( lattice_NslipSystem ( : , phase ) , plastic_disloUCLA_Nslip ( : , instance ) )
plastic_disloUCLA_totalNslip ( instance ) = sum ( plastic_disloUCLA_Nslip ( : , instance ) )
2014-11-06 00:41:09 +05:30
endif myPhase
enddo sanityChecks
!--------------------------------------------------------------------------------------------------
! allocation of variables whose size depends on the total number of active slip systems
2015-01-21 20:44:00 +05:30
maxTotalNslip = maxval ( plastic_disloUCLA_totalNslip )
allocate ( plastic_disloUCLA_burgersPerSlipSystem ( maxTotalNslip , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_QedgePerSlipSystem ( maxTotalNslip , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_v0PerSlipSystem ( maxTotalNslip , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_CLambdaSlipPerSlipSystem ( maxTotalNslip , maxNinstance ) , source = 0.0_pReal )
allocate ( plastic_disloUCLA_interactionMatrix_SlipSlip ( maxval ( plastic_disloUCLA_totalNslip ) , & ! slip resistance from slip activity
maxval ( plastic_disloUCLA_totalNslip ) , &
2014-11-06 00:41:09 +05:30
maxNinstance ) , source = 0.0_pReal )
2015-01-21 20:44:00 +05:30
allocate ( plastic_disloUCLA_forestProjectionEdge ( maxTotalNslip , maxTotalNslip , maxNinstance ) , &
2014-11-06 00:41:09 +05:30
source = 0.0_pReal )
2018-11-28 00:30:45 +05:30
2014-11-06 00:41:09 +05:30
initializeInstances : do phase = 1_pInt , size ( phase_plasticity )
2016-04-25 02:06:35 +05:30
myPhase2 : if ( phase_plasticity ( phase ) == PLASTICITY_disloUCLA_ID ) then
2018-11-28 21:42:06 +05:30
p = phase
2014-11-06 00:41:09 +05:30
NofMyPhase = count ( material_phase == phase )
instance = phase_plasticityInstance ( phase )
2015-01-21 20:44:00 +05:30
ns = plastic_disloUCLA_totalNslip ( instance )
2014-11-06 00:41:09 +05:30
2016-01-16 12:36:34 +05:30
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
! allocate state arrays
2016-01-16 12:36:34 +05:30
2016-04-25 02:06:35 +05:30
sizeDotState = int ( size ( [ 'rhoEdge ' , 'rhoEdgeDip ' , 'accshearslip' ] ) , pInt ) * ns
2016-01-16 12:36:34 +05:30
sizeDeltaState = 0_pInt
sizeState = sizeDotState &
2016-04-25 02:06:35 +05:30
+ int ( size ( [ 'invLambdaSlip ' , &
'meanFreePathSlip ' , 'tauSlipThreshold ' ] ) , pInt ) * ns
2016-01-16 12:36:34 +05:30
2018-11-27 23:58:00 +05:30
call material_allocatePlasticState ( phase , NofMyPhase , sizeState , sizeDotState , 0_pInt , &
ns , 0_pInt , 0_pInt )
2018-11-28 21:15:45 +05:30
plasticState ( phase ) % sizePostResults = plastic_disloUCLA_sizePostResults ( instance )
2014-11-06 00:41:09 +05:30
2015-01-23 18:38:25 +05:30
offset_slip = 2_pInt * plasticState ( phase ) % nSlip
plasticState ( phase ) % slipRate = > &
plasticState ( phase ) % dotState ( offset_slip + 1 : offset_slip + plasticState ( phase ) % nSlip , 1 : NofMyPhase )
plasticState ( phase ) % accumulatedSlip = > &
plasticState ( phase ) % state ( offset_slip + 1 : offset_slip + plasticState ( phase ) % nSlip , 1 : NofMyPhase )
2014-11-06 00:41:09 +05:30
!* Process slip related parameters ------------------------------------------------
mySlipFamilies : do f = 1_pInt , lattice_maxNslipFamily
2015-01-21 20:44:00 +05:30
index_myFamily = sum ( plastic_disloUCLA_Nslip ( 1 : f - 1_pInt , instance ) ) ! index in truncated slip system list
mySlipSystems : do j = 1_pInt , plastic_disloUCLA_Nslip ( f , instance )
2014-11-06 00:41:09 +05:30
!* Burgers vector,
! dislocation velocity prefactor,
! mean free path prefactor,
! and minimum dipole distance
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_burgersPerSlipSystem ( index_myFamily + j , instance ) = &
plastic_disloUCLA_burgersPerSlipFamily ( f , instance )
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_QedgePerSlipSystem ( index_myFamily + j , instance ) = &
plastic_disloUCLA_QedgePerSlipFamily ( f , instance )
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_v0PerSlipSystem ( index_myFamily + j , instance ) = &
plastic_disloUCLA_v0PerSlipFamily ( f , instance )
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_CLambdaSlipPerSlipSystem ( index_myFamily + j , instance ) = &
plastic_disloUCLA_CLambdaSlipPerSlipFamily ( f , instance )
2014-11-06 00:41:09 +05:30
!* Calculation of forest projections for edge dislocations
!* Interaction matrices
otherSlipFamilies : do o = 1_pInt , lattice_maxNslipFamily
2015-01-21 20:44:00 +05:30
index_otherFamily = sum ( plastic_disloUCLA_Nslip ( 1 : o - 1_pInt , instance ) )
otherSlipSystems : do k = 1_pInt , plastic_disloUCLA_Nslip ( o , instance )
plastic_disloUCLA_forestProjectionEdge ( index_myFamily + j , index_otherFamily + k , instance ) = &
2014-11-06 00:41:09 +05:30
abs ( math_mul3x3 ( lattice_sn ( : , sum ( lattice_NslipSystem ( 1 : f - 1 , phase ) ) + j , phase ) , &
lattice_st ( : , sum ( lattice_NslipSystem ( 1 : o - 1 , phase ) ) + k , phase ) ) )
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_interactionMatrix_SlipSlip ( index_myFamily + j , index_otherFamily + k , instance ) = &
plastic_disloUCLA_interaction_SlipSlip ( lattice_interactionSlipSlip ( &
2014-11-06 00:41:09 +05:30
sum ( lattice_NslipSystem ( 1 : f - 1 , phase ) ) + j , &
sum ( lattice_NslipSystem ( 1 : o - 1 , phase ) ) + k , &
phase ) , instance )
enddo otherSlipSystems ; enddo otherSlipFamilies
2016-04-25 02:06:35 +05:30
2014-11-06 00:41:09 +05:30
enddo mySlipSystems
enddo mySlipFamilies
2016-04-25 02:06:35 +05:30
startIndex = 1_pInt
endIndex = ns
state ( instance ) % rhoEdge = > plasticState ( phase ) % state ( startIndex : endIndex , : )
2018-11-28 21:42:06 +05:30
dotState ( instance ) % rhoEdge = > plasticState ( phase ) % dotState ( startIndex : endIndex , : )
plasticState ( p ) % aTolState ( startIndex : endIndex ) = plastic_disloUCLA_aTolRho ( instance )
2016-04-25 02:06:35 +05:30
startIndex = endIndex + 1_pInt
endIndex = endIndex + ns
state ( instance ) % rhoEdgeDip = > plasticState ( phase ) % state ( startIndex : endIndex , : )
dotState ( instance ) % rhoEdgeDip = > plasticState ( phase ) % dotState ( startIndex : endIndex , : )
2018-11-28 21:42:06 +05:30
plasticState ( p ) % aTolState ( startIndex : endIndex ) = plastic_disloUCLA_aTolRho ( instance )
2016-04-25 02:06:35 +05:30
startIndex = endIndex + 1_pInt
endIndex = endIndex + ns
state ( instance ) % accshear_slip = > plasticState ( phase ) % state ( startIndex : endIndex , : )
dotState ( instance ) % accshear_slip = > plasticState ( phase ) % dotState ( startIndex : endIndex , : )
2018-11-28 21:42:06 +05:30
plasticState ( p ) % aTolState ( startIndex : endIndex ) = 1e6_pReal
2016-04-25 02:06:35 +05:30
startIndex = endIndex + 1_pInt
endIndex = endIndex + ns
state ( instance ) % invLambdaSlip = > plasticState ( phase ) % state ( startIndex : endIndex , : )
startIndex = endIndex + 1_pInt
endIndex = endIndex + ns
state ( instance ) % mfp_slip = > plasticState ( phase ) % state ( startIndex : endIndex , : )
startIndex = endIndex + 1_pInt
endIndex = endIndex + ns
state ( instance ) % threshold_stress_slip = > plasticState ( phase ) % state ( startIndex : endIndex , : )
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
call plastic_disloUCLA_stateInit ( phase , instance )
2018-11-28 21:42:06 +05:30
plasticState ( p ) % state0 = plasticState ( p ) % state ! ToDo: this could be done centrally
2014-11-06 00:41:09 +05:30
endif myPhase2
enddo initializeInstances
2015-01-21 20:44:00 +05:30
end subroutine plastic_disloUCLA_init
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief sets the relevant state values for a given instance of this plasticity
!--------------------------------------------------------------------------------------------------
2015-01-21 20:44:00 +05:30
subroutine plastic_disloUCLA_stateInit ( ph , instance )
2014-11-06 00:41:09 +05:30
use math , only : &
pi
use lattice , only : &
lattice_maxNslipFamily , &
2014-11-06 02:23:25 +05:30
lattice_mu
2014-11-06 00:41:09 +05:30
use material , only : &
plasticState
implicit none
integer ( pInt ) , intent ( in ) :: &
instance , & !< number specifying the instance of the plasticity
ph
real ( pReal ) , dimension ( plasticState ( ph ) % sizeState ) :: tempState
2016-04-25 02:06:35 +05:30
integer ( pInt ) :: i , f , ns , index_myFamily
2015-01-21 20:44:00 +05:30
real ( pReal ) , dimension ( plastic_disloUCLA_totalNslip ( instance ) ) :: &
2014-11-06 00:41:09 +05:30
rhoEdge0 , &
rhoEdgeDip0 , &
invLambdaSlip0 , &
MeanFreePathSlip0 , &
tauSlipThreshold0
tempState = 0.0_pReal
2015-01-21 20:44:00 +05:30
ns = plastic_disloUCLA_totalNslip ( instance )
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
! initialize basic slip state variables
do f = 1_pInt , lattice_maxNslipFamily
2015-01-21 20:44:00 +05:30
index_myFamily = sum ( plastic_disloUCLA_Nslip ( 1 : f - 1_pInt , instance ) ) ! index in truncated slip system list
2014-11-06 00:41:09 +05:30
rhoEdge0 ( index_myFamily + 1_pInt : &
2015-01-21 20:44:00 +05:30
index_myFamily + plastic_disloUCLA_Nslip ( f , instance ) ) = &
plastic_disloUCLA_rhoEdge0 ( f , instance )
2014-11-06 00:41:09 +05:30
rhoEdgeDip0 ( index_myFamily + 1_pInt : &
2015-01-21 20:44:00 +05:30
index_myFamily + plastic_disloUCLA_Nslip ( f , instance ) ) = &
plastic_disloUCLA_rhoEdgeDip0 ( f , instance )
2014-11-06 00:41:09 +05:30
enddo
tempState ( 1_pInt : ns ) = rhoEdge0
tempState ( ns + 1_pInt : 2_pInt * ns ) = rhoEdgeDip0
!--------------------------------------------------------------------------------------------------
! initialize dependent slip microstructural variables
forall ( i = 1_pInt : ns ) &
2015-01-21 20:44:00 +05:30
invLambdaSlip0 ( i ) = sqrt ( dot_product ( ( rhoEdge0 + rhoEdgeDip0 ) , plastic_disloUCLA_forestProjectionEdge ( 1 : ns , i , instance ) ) ) / &
plastic_disloUCLA_CLambdaSlipPerSlipSystem ( i , instance )
2016-04-25 02:06:35 +05:30
tempState ( 3_pInt * ns + 1 : 4_pInt * ns ) = invLambdaSlip0
2014-11-06 00:41:09 +05:30
forall ( i = 1_pInt : ns ) &
MeanFreePathSlip0 ( i ) = &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_GrainSize ( instance ) / ( 1.0_pReal + invLambdaSlip0 ( i ) * plastic_disloUCLA_GrainSize ( instance ) )
2016-04-25 02:06:35 +05:30
tempState ( 4_pInt * ns + 1 : 5_pInt * ns ) = MeanFreePathSlip0
2014-11-06 00:41:09 +05:30
forall ( i = 1_pInt : ns ) &
tauSlipThreshold0 ( i ) = &
2015-01-21 20:44:00 +05:30
lattice_mu ( ph ) * plastic_disloUCLA_burgersPerSlipSystem ( i , instance ) * &
sqrt ( dot_product ( ( rhoEdge0 + rhoEdgeDip0 ) , plastic_disloUCLA_interactionMatrix_SlipSlip ( i , 1 : ns , instance ) ) )
2014-11-06 00:41:09 +05:30
2016-04-25 02:06:35 +05:30
tempState ( 5_pInt * ns + 1 : 6_pInt * ns ) = tauSlipThreshold0
2014-11-06 00:41:09 +05:30
2018-11-28 21:42:06 +05:30
plasticState ( ph ) % state = spread ( tempState , 2 , size ( plasticState ( ph ) % state ( 1 , : ) ) )
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
end subroutine plastic_disloUCLA_stateInit
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief calculates derived quantities from state
!--------------------------------------------------------------------------------------------------
2015-01-21 20:44:00 +05:30
subroutine plastic_disloUCLA_microstructure ( temperature , ipc , ip , el )
2014-11-06 00:41:09 +05:30
use math , only : &
pi
use material , only : &
phase_plasticityInstance , &
2016-01-15 05:49:44 +05:30
phaseAt , phasememberAt
2014-11-06 00:41:09 +05:30
use lattice , only : &
2016-04-25 02:06:35 +05:30
lattice_mu
2014-11-06 00:41:09 +05:30
implicit none
integer ( pInt ) , intent ( in ) :: &
ipc , & !< component-ID of integration point
ip , & !< integration point
el !< element
real ( pReal ) , intent ( in ) :: &
temperature !< temperature at IP
integer ( pInt ) :: &
instance , &
2016-04-25 02:06:35 +05:30
ns , s , &
2014-11-06 00:41:09 +05:30
ph , &
of
!* Shortened notation
2016-01-15 05:49:44 +05:30
of = phasememberAt ( ipc , ip , el )
ph = phaseAt ( ipc , ip , el )
2014-11-06 00:41:09 +05:30
instance = phase_plasticityInstance ( ph )
2015-01-21 20:44:00 +05:30
ns = plastic_disloUCLA_totalNslip ( instance )
2016-04-25 02:06:35 +05:30
2014-11-06 00:41:09 +05:30
!* 1/mean free distance between 2 forest dislocations seen by a moving dislocation
forall ( s = 1_pInt : ns ) &
2016-01-15 20:56:24 +05:30
state ( instance ) % invLambdaSlip ( s , of ) = &
sqrt ( dot_product ( ( state ( instance ) % rhoEdge ( 1_pInt : ns , of ) + state ( instance ) % rhoEdgeDip ( 1_pInt : ns , of ) ) , &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_forestProjectionEdge ( 1 : ns , s , instance ) ) ) / &
plastic_disloUCLA_CLambdaSlipPerSlipSystem ( s , instance )
2014-11-06 00:41:09 +05:30
!* mean free path between 2 obstacles seen by a moving dislocation
do s = 1_pInt , ns
2016-04-25 02:06:35 +05:30
state ( instance ) % mfp_slip ( s , of ) = &
plastic_disloUCLA_GrainSize ( instance ) / &
( 1.0_pReal + plastic_disloUCLA_GrainSize ( instance ) * ( state ( instance ) % invLambdaSlip ( s , of ) ) )
2014-11-06 00:41:09 +05:30
enddo
!* threshold stress for dislocation motion
forall ( s = 1_pInt : ns ) &
2016-01-15 20:56:24 +05:30
state ( instance ) % threshold_stress_slip ( s , of ) = &
2015-01-21 20:44:00 +05:30
lattice_mu ( ph ) * plastic_disloUCLA_burgersPerSlipSystem ( s , instance ) * &
2016-01-15 20:56:24 +05:30
sqrt ( dot_product ( ( state ( instance ) % rhoEdge ( 1_pInt : ns , of ) + state ( instance ) % rhoEdgeDip ( 1_pInt : ns , of ) ) , &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_interactionMatrix_SlipSlip ( s , 1 : ns , instance ) ) )
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
end subroutine plastic_disloUCLA_microstructure
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief calculates plastic velocity gradient and its tangent
!--------------------------------------------------------------------------------------------------
2018-11-28 11:14:32 +05:30
subroutine plastic_disloUCLA_LpAndItsTangent ( Lp , dLp_dMp , Mp , Temperature , ipc , ip , el )
2014-11-06 00:41:09 +05:30
use material , only : &
material_phase , &
phase_plasticityInstance , &
2016-01-15 05:49:44 +05:30
phaseAt , phasememberAt
2014-11-06 00:41:09 +05:30
implicit none
2015-01-29 19:26:09 +05:30
integer ( pInt ) , intent ( in ) :: ipc , ip , el
2014-11-06 00:41:09 +05:30
real ( pReal ) , intent ( in ) :: Temperature
2018-11-28 11:14:32 +05:30
real ( pReal ) , dimension ( 3 , 3 ) , intent ( in ) :: Mp
2014-11-06 00:41:09 +05:30
real ( pReal ) , dimension ( 3 , 3 ) , intent ( out ) :: Lp
2018-11-28 11:14:32 +05:30
real ( pReal ) , dimension ( 3 , 3 , 3 , 3 ) , intent ( out ) :: dLp_dMp
2014-11-06 00:41:09 +05:30
2018-11-29 03:08:14 +05:30
integer ( pInt ) :: instance , ph , of , i , k , l , m , n
2018-11-28 00:19:04 +05:30
2015-01-21 20:44:00 +05:30
real ( pReal ) , dimension ( plastic_disloUCLA_totalNslip ( phase_plasticityInstance ( material_phase ( ipc , ip , el ) ) ) ) :: &
2018-11-27 23:31:55 +05:30
gdot_slip_pos , gdot_slip_neg , tau_slip_pos , tau_slip_neg , dgdot_dtauslip_pos , dgdot_dtauslip_neg
2014-11-06 00:41:09 +05:30
!* Shortened notation
2016-01-15 05:49:44 +05:30
of = phasememberAt ( ipc , ip , el )
ph = phaseAt ( ipc , ip , el )
2014-11-06 00:41:09 +05:30
instance = phase_plasticityInstance ( ph )
2018-11-29 02:52:13 +05:30
associate ( prm = > param ( instance ) , stt = > state ( instance ) )
2014-11-06 00:41:09 +05:30
Lp = 0.0_pReal
2018-11-28 11:14:32 +05:30
dLp_dMp = 0.0_pReal
2014-11-06 00:41:09 +05:30
2018-11-28 11:48:50 +05:30
call kinetics ( Mp , Temperature , ph , instance , of , &
2018-11-27 23:49:36 +05:30
gdot_slip_pos , dgdot_dtauslip_pos , tau_slip_pos , gdot_slip_neg , dgdot_dtauslip_neg , tau_slip_neg )
2018-11-29 03:08:14 +05:30
slipSystems : do i = 1_pInt , prm % totalNslip
Lp = Lp + ( gdot_slip_pos ( i ) + gdot_slip_neg ( i ) ) * prm % Schmid_slip ( 1 : 3 , 1 : 3 , i )
forall ( k = 1_pInt : 3_pInt , l = 1_pInt : 3_pInt , m = 1_pInt : 3_pInt , n = 1_pInt : 3_pInt ) &
dLp_dMp ( k , l , m , n ) = dLp_dMp ( k , l , m , n ) &
+ dgdot_dtauslip_pos ( i ) * prm % Schmid_slip ( k , l , i ) * prm % nonSchmid_pos ( m , n , i ) &
+ dgdot_dtauslip_neg ( i ) * prm % Schmid_slip ( k , l , i ) * prm % nonSchmid_neg ( m , n , i )
enddo slipSystems
2018-11-29 02:52:13 +05:30
end associate
2018-11-29 03:08:14 +05:30
Lp = 0.5_pReal * Lp
dLp_dMp = 0.5_pReal * dLp_dMp
2015-01-21 20:44:00 +05:30
end subroutine plastic_disloUCLA_LpAndItsTangent
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief calculates the rate of change of microstructure
!--------------------------------------------------------------------------------------------------
2018-11-28 11:14:32 +05:30
subroutine plastic_disloUCLA_dotState ( Mp , Temperature , ipc , ip , el )
2014-11-06 00:41:09 +05:30
use prec , only : &
2016-05-29 14:15:03 +05:30
tol_math_check , &
2016-10-29 13:09:08 +05:30
dEq0
2014-11-06 00:41:09 +05:30
use math , only : &
pi
use material , only : &
material_phase , &
phase_plasticityInstance , &
plasticState , &
2016-01-15 05:49:44 +05:30
phaseAt , phasememberAt
2014-11-06 00:41:09 +05:30
use lattice , only : &
lattice_maxNslipFamily , &
lattice_NslipSystem , &
2016-04-25 02:06:35 +05:30
lattice_mu
2014-11-06 00:41:09 +05:30
implicit none
2018-11-28 11:14:32 +05:30
real ( pReal ) , dimension ( 3 , 3 ) , intent ( in ) :: &
Mp !< 2nd Piola Kirchhoff stress tensor in Mandel notation
2014-11-06 00:41:09 +05:30
real ( pReal ) , intent ( in ) :: &
temperature !< temperature at integration point
integer ( pInt ) , intent ( in ) :: &
ipc , & !< component-ID of integration point
ip , & !< integration point
el !< element
2018-11-28 00:19:04 +05:30
integer ( pInt ) :: instance , ns , f , i , j , index_myFamily , &
2014-11-06 00:41:09 +05:30
ph , &
of
real ( pReal ) :: &
EdgeDipMinDistance , &
AtomicVolume , &
VacancyDiffusion , &
DotRhoMultiplication , &
EdgeDipDistance , &
DotRhoEdgeDipAnnihilation , &
DotRhoEdgeEdgeAnnihilation , &
ClimbVelocity , &
DotRhoEdgeDipClimb , &
2018-11-28 00:19:04 +05:30
DotRhoDipFormation
2015-01-21 20:44:00 +05:30
real ( pReal ) , dimension ( plastic_disloUCLA_totalNslip ( phase_plasticityInstance ( material_phase ( ipc , ip , el ) ) ) ) :: &
2018-11-27 23:11:33 +05:30
gdot_slip_pos , gdot_slip_neg , &
tau_slip_pos , &
2018-11-27 23:23:01 +05:30
tau_slip_neg , &
dgdot_dtauslip_neg , dgdot_dtauslip_pos
2014-11-06 00:41:09 +05:30
!* Shortened notation
2016-01-15 05:49:44 +05:30
of = phasememberAt ( ipc , ip , el )
ph = phaseAt ( ipc , ip , el )
2014-11-06 00:41:09 +05:30
instance = phase_plasticityInstance ( ph )
2016-04-25 02:06:35 +05:30
ns = plastic_disloUCLA_totalNslip ( instance )
2014-11-06 00:41:09 +05:30
plasticState ( ph ) % dotState ( : , of ) = 0.0_pReal
!* Dislocation density evolution
2018-11-28 11:48:50 +05:30
call kinetics ( Mp , Temperature , ph , instance , of , &
2018-11-27 23:23:01 +05:30
gdot_slip_pos , dgdot_dtauslip_pos , tau_slip_pos , gdot_slip_neg , dgdot_dtauslip_neg , tau_slip_neg )
2018-11-29 03:08:14 +05:30
dotState ( instance ) % accshear_slip ( : , of ) = ( gdot_slip_pos + gdot_slip_neg ) * 0.5_pReal
2014-11-06 00:41:09 +05:30
j = 0_pInt
slipFamilies : do f = 1_pInt , lattice_maxNslipFamily
index_myFamily = sum ( lattice_NslipSystem ( 1 : f - 1_pInt , ph ) ) ! at which index starts my family
2015-01-21 20:44:00 +05:30
slipSystems : do i = 1_pInt , plastic_disloUCLA_Nslip ( f , instance )
2014-11-06 00:41:09 +05:30
j = j + 1_pInt
2018-11-28 00:19:04 +05:30
2014-11-06 00:41:09 +05:30
!* Multiplication
2018-11-28 00:19:04 +05:30
DotRhoMultiplication = abs ( dotState ( instance ) % accshear_slip ( j , of ) ) / &
2015-01-21 20:44:00 +05:30
( plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) * &
2016-01-15 20:56:24 +05:30
state ( instance ) % mfp_slip ( j , of ) )
2014-11-06 00:41:09 +05:30
!* Dipole formation
EdgeDipMinDistance = &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_CEdgeDipMinDistance ( instance ) * plastic_disloUCLA_burgersPerSlipSystem ( j , instance )
2018-11-27 23:11:33 +05:30
if ( dEq0 ( tau_slip_pos ( j ) ) ) then
2014-11-06 00:41:09 +05:30
DotRhoDipFormation = 0.0_pReal
else
EdgeDipDistance = &
2015-01-21 20:44:00 +05:30
( 3.0_pReal * lattice_mu ( ph ) * plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) ) / &
2018-11-27 23:11:33 +05:30
( 1 6.0_pReal * pi * abs ( tau_slip_pos ( j ) ) )
2016-01-15 20:56:24 +05:30
if ( EdgeDipDistance > state ( instance ) % mfp_slip ( j , of ) ) EdgeDipDistance = state ( instance ) % mfp_slip ( j , of )
2014-11-06 00:41:09 +05:30
if ( EdgeDipDistance < EdgeDipMinDistance ) EdgeDipDistance = EdgeDipMinDistance
DotRhoDipFormation = &
2015-01-21 20:44:00 +05:30
( ( 2.0_pReal * EdgeDipDistance ) / plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) ) * &
2018-11-28 00:19:04 +05:30
state ( instance ) % rhoEdge ( j , of ) * abs ( dotState ( instance ) % accshear_slip ( j , of ) ) * plastic_disloUCLA_dipoleFormationFactor ( instance )
2014-11-06 00:41:09 +05:30
endif
!* Spontaneous annihilation of 2 single edge dislocations
DotRhoEdgeEdgeAnnihilation = &
2015-01-21 20:44:00 +05:30
( ( 2.0_pReal * EdgeDipMinDistance ) / plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) ) * &
2018-11-28 00:19:04 +05:30
state ( instance ) % rhoEdge ( j , of ) * abs ( dotState ( instance ) % accshear_slip ( j , of ) )
2014-11-06 00:41:09 +05:30
!* Spontaneous annihilation of a single edge dislocation with a dipole constituent
DotRhoEdgeDipAnnihilation = &
2015-01-21 20:44:00 +05:30
( ( 2.0_pReal * EdgeDipMinDistance ) / plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) ) * &
2018-11-28 00:19:04 +05:30
state ( instance ) % rhoEdgeDip ( j , of ) * abs ( dotState ( instance ) % accshear_slip ( j , of ) )
2014-11-06 00:41:09 +05:30
!* Dislocation dipole climb
AtomicVolume = &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_CAtomicVolume ( instance ) * plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) ** ( 3.0_pReal )
2014-11-06 00:41:09 +05:30
VacancyDiffusion = &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_D0 ( instance ) * exp ( - plastic_disloUCLA_Qsd ( instance ) / ( kB * Temperature ) )
2018-11-27 23:11:33 +05:30
if ( dEq0 ( tau_slip_pos ( j ) ) ) then
2014-11-06 00:41:09 +05:30
DotRhoEdgeDipClimb = 0.0_pReal
else
ClimbVelocity = &
( ( 3.0_pReal * lattice_mu ( ph ) * VacancyDiffusion * AtomicVolume ) / ( 2.0_pReal * pi * kB * Temperature ) ) * &
( 1 / ( EdgeDipDistance + EdgeDipMinDistance ) )
DotRhoEdgeDipClimb = &
2016-01-15 20:56:24 +05:30
( 4.0_pReal * ClimbVelocity * state ( instance ) % rhoEdgeDip ( j , of ) ) / ( EdgeDipDistance - EdgeDipMinDistance )
2014-11-06 00:41:09 +05:30
endif
!* Edge dislocation density rate of change
2016-01-15 20:56:24 +05:30
dotState ( instance ) % rhoEdge ( j , of ) = &
2014-11-06 00:41:09 +05:30
DotRhoMultiplication - DotRhoDipFormation - DotRhoEdgeEdgeAnnihilation
!* Edge dislocation dipole density rate of change
2016-01-15 20:56:24 +05:30
dotState ( instance ) % rhoEdgeDip ( j , of ) = &
2014-11-06 00:41:09 +05:30
DotRhoDipFormation - DotRhoEdgeDipAnnihilation - DotRhoEdgeDipClimb
2018-11-28 00:19:04 +05:30
2014-11-06 00:41:09 +05:30
enddo slipSystems
enddo slipFamilies
2016-04-25 02:06:35 +05:30
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
end subroutine plastic_disloUCLA_dotState
2014-11-06 00:41:09 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief return array of constitutive results
!--------------------------------------------------------------------------------------------------
2018-11-28 11:14:32 +05:30
function plastic_disloUCLA_postResults ( Mp , Temperature , ipc , ip , el )
2014-11-06 00:41:09 +05:30
use prec , only : &
2016-05-29 14:15:03 +05:30
tol_math_check , &
2017-11-21 04:13:06 +05:30
dEq , dNeq0
2014-11-06 00:41:09 +05:30
use math , only : &
2018-11-28 11:14:32 +05:30
pi , &
math_mul33xx33
2014-11-06 00:41:09 +05:30
use material , only : &
material_phase , &
phase_plasticityInstance , &
2016-01-15 20:56:24 +05:30
!plasticState, &
2016-01-15 05:49:44 +05:30
phaseAt , phasememberAt
2014-11-06 00:41:09 +05:30
use lattice , only : &
2018-11-28 11:14:32 +05:30
lattice_Sslip , &
2014-11-06 00:41:09 +05:30
lattice_maxNslipFamily , &
lattice_NslipSystem , &
2016-04-25 02:06:35 +05:30
lattice_mu
2014-11-06 00:41:09 +05:30
implicit none
2018-11-28 11:14:32 +05:30
real ( pReal ) , dimension ( 3 , 3 ) , intent ( in ) :: &
Mp !< 2nd Piola Kirchhoff stress tensor in Mandel notation
2014-11-06 00:41:09 +05:30
real ( pReal ) , intent ( in ) :: &
temperature !< temperature at integration point
integer ( pInt ) , intent ( in ) :: &
ipc , & !< component-ID of integration point
ip , & !< integration point
el !< element
2015-01-21 20:44:00 +05:30
real ( pReal ) , dimension ( plastic_disloUCLA_sizePostResults ( phase_plasticityInstance ( material_phase ( ipc , ip , el ) ) ) ) :: &
plastic_disloUCLA_postResults
2014-11-06 00:41:09 +05:30
integer ( pInt ) :: &
instance , &
2016-04-25 02:06:35 +05:30
ns , &
2018-11-28 00:19:04 +05:30
f , o , i , c , j , index_myFamily , &
2014-11-06 00:41:09 +05:30
ph , &
of
2015-01-21 20:44:00 +05:30
real ( pReal ) , dimension ( plastic_disloUCLA_totalNslip ( phase_plasticityInstance ( material_phase ( ipc , ip , el ) ) ) ) :: &
2014-11-06 02:23:25 +05:30
gdot_slip_pos , dgdot_dtauslip_pos , tau_slip_pos , gdot_slip_neg , dgdot_dtauslip_neg , tau_slip_neg
2014-11-06 00:41:09 +05:30
!* Shortened notation
2016-01-15 05:49:44 +05:30
of = phasememberAt ( ipc , ip , el )
ph = phaseAt ( ipc , ip , el )
2014-11-06 00:41:09 +05:30
instance = phase_plasticityInstance ( ph )
2015-01-21 20:44:00 +05:30
ns = plastic_disloUCLA_totalNslip ( instance )
2014-11-06 00:41:09 +05:30
!* Required output
c = 0_pInt
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_postResults = 0.0_pReal
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
do o = 1_pInt , plastic_disloUCLA_Noutput ( instance )
select case ( plastic_disloUCLA_outputID ( o , instance ) )
2014-11-06 00:41:09 +05:30
2018-11-28 21:15:45 +05:30
case ( rho_ID )
2016-01-15 20:56:24 +05:30
plastic_disloUCLA_postResults ( c + 1_pInt : c + ns ) = state ( instance ) % rhoEdge ( 1_pInt : ns , of )
2014-11-06 00:41:09 +05:30
c = c + ns
2018-11-28 21:15:45 +05:30
case ( rhoDip_ID )
2016-01-15 20:56:24 +05:30
plastic_disloUCLA_postResults ( c + 1_pInt : c + ns ) = state ( instance ) % rhoEdgeDip ( 1_pInt : ns , of )
2014-11-06 00:41:09 +05:30
c = c + ns
2018-11-28 21:15:45 +05:30
case ( shearrate_ID , stressexponent_ID )
2018-11-28 11:48:50 +05:30
call kinetics ( Mp , Temperature , ph , instance , of , &
2018-11-27 22:55:06 +05:30
gdot_slip_pos , dgdot_dtauslip_pos , tau_slip_pos , gdot_slip_neg , dgdot_dtauslip_neg , tau_slip_neg )
2018-11-28 21:15:45 +05:30
if ( plastic_disloUCLA_outputID ( o , instance ) == shearrate_ID ) then
2018-11-27 22:55:06 +05:30
plastic_disloUCLA_postResults ( c + 1 : c + ns ) = ( gdot_slip_pos + gdot_slip_neg ) * 0.5_pReal
c = c + ns
2018-11-28 21:15:45 +05:30
elseif ( plastic_disloUCLA_outputID ( o , instance ) == stressexponent_ID ) then
2018-11-27 22:55:06 +05:30
do j = 1_pInt , ns
if ( dEq ( gdot_slip_pos ( j ) + gdot_slip_neg ( j ) , 0.0_pReal ) ) then
plastic_disloUCLA_postResults ( c + j ) = 0.0_pReal
else
plastic_disloUCLA_postResults ( c + j ) = ( tau_slip_pos ( j ) + tau_slip_neg ( j ) ) / &
( gdot_slip_pos ( j ) + gdot_slip_neg ( j ) ) * &
( dgdot_dtauslip_pos ( j ) + dgdot_dtauslip_neg ( j ) ) * 0.5_pReal
endif
enddo
c = c + ns
endif
2018-11-28 21:15:45 +05:30
case ( accumulatedshear_ID )
2018-11-27 22:55:06 +05:30
plastic_disloUCLA_postResults ( c + 1_pInt : c + ns ) = &
state ( instance ) % accshear_slip ( 1_pInt : ns , of )
c = c + ns
2018-11-28 21:15:45 +05:30
case ( mfp_ID )
2018-11-27 22:55:06 +05:30
plastic_disloUCLA_postResults ( c + 1_pInt : c + ns ) = &
state ( instance ) % mfp_slip ( 1_pInt : ns , of )
c = c + ns
2018-11-28 21:15:45 +05:30
case ( resolvedstress_ID )
2018-11-27 22:55:06 +05:30
j = 0_pInt
slipFamilies1 : do f = 1_pInt , lattice_maxNslipFamily
index_myFamily = sum ( lattice_NslipSystem ( 1 : f - 1_pInt , ph ) ) ! at which index starts my family
slipSystems1 : do i = 1_pInt , plastic_disloUCLA_Nslip ( f , instance )
j = j + 1_pInt
plastic_disloUCLA_postResults ( c + j ) = &
2018-11-28 11:14:32 +05:30
math_mul33xx33 ( Mp , lattice_Sslip ( : , : , 1 , index_myFamily + i , ph ) )
2018-11-27 22:55:06 +05:30
enddo slipSystems1 ; enddo slipFamilies1
c = c + ns
2018-11-28 21:15:45 +05:30
case ( thresholdstress_ID )
2018-11-27 22:55:06 +05:30
plastic_disloUCLA_postResults ( c + 1_pInt : c + ns ) = &
state ( instance ) % threshold_stress_slip ( 1_pInt : ns , of )
c = c + ns
2018-11-28 21:15:45 +05:30
case ( dipoleDistance_ID )
2018-11-27 22:55:06 +05:30
j = 0_pInt
slipFamilies2 : do f = 1_pInt , lattice_maxNslipFamily
index_myFamily = sum ( lattice_NslipSystem ( 1 : f - 1_pInt , ph ) ) ! at which index starts my family
slipSystems2 : do i = 1_pInt , plastic_disloUCLA_Nslip ( f , instance )
j = j + 1_pInt
2018-11-28 11:14:32 +05:30
if ( dNeq0 ( abs ( math_mul33xx33 ( Mp , lattice_Sslip ( : , : , 1 , index_myFamily + i , ph ) ) ) ) ) then
2018-11-27 22:55:06 +05:30
plastic_disloUCLA_postResults ( c + j ) = &
( 3.0_pReal * lattice_mu ( ph ) * plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) ) / &
2018-11-28 11:14:32 +05:30
( 1 6.0_pReal * pi * abs ( math_mul33xx33 ( Mp , lattice_Sslip ( : , : , 1 , index_myFamily + i , ph ) ) ) )
2018-11-27 22:55:06 +05:30
else
plastic_disloUCLA_postResults ( c + j ) = huge ( 1.0_pReal )
endif
plastic_disloUCLA_postResults ( c + j ) = min ( plastic_disloUCLA_postResults ( c + j ) , &
state ( instance ) % mfp_slip ( j , of ) )
enddo slipSystems2 ; enddo slipFamilies2
c = c + ns
end select
enddo
end function plastic_disloUCLA_postResults
!--------------------------------------------------------------------------------------------------
!> @brief return array of constitutive results
!--------------------------------------------------------------------------------------------------
2018-11-28 11:48:50 +05:30
subroutine kinetics ( Mp , Temperature , ph , instance , of , &
2018-11-27 22:55:06 +05:30
gdot_slip_pos , dgdot_dtauslip_pos , tau_slip_pos , gdot_slip_neg , dgdot_dtauslip_neg , tau_slip_neg )
use prec , only : &
tol_math_check , &
dEq , dNeq0
use math , only : &
2018-11-28 11:14:32 +05:30
pi , &
math_mul33xx33
2018-11-27 22:55:06 +05:30
use material , only : &
material_phase , &
phase_plasticityInstance , &
!plasticState, &
phaseAt , phasememberAt
use lattice , only : &
2018-11-28 11:14:32 +05:30
lattice_Sslip , &
2018-11-27 22:55:06 +05:30
lattice_maxNslipFamily , &
lattice_NslipSystem , &
2018-11-28 00:19:04 +05:30
lattice_NnonSchmid
2018-11-27 22:55:06 +05:30
implicit none
2018-11-28 11:14:32 +05:30
real ( pReal ) , dimension ( 3 , 3 ) , intent ( in ) :: &
Mp !< 2nd Piola Kirchhoff stress tensor in Mandel notation
2018-11-27 22:55:06 +05:30
real ( pReal ) , intent ( in ) :: &
temperature !< temperature at integration point
integer ( pInt ) , intent ( in ) :: &
2018-11-28 11:48:50 +05:30
ph , instance , of
2018-11-27 22:55:06 +05:30
integer ( pInt ) :: &
ns , &
2018-11-28 11:48:50 +05:30
f , i , j , k , index_myFamily
2018-11-27 22:55:06 +05:30
real ( pReal ) :: StressRatio_p , StressRatio_pminus1 , &
BoltzmannRatio , DotGamma0 , stressRatio , &
dvel_slip , vel_slip
2018-11-28 11:48:50 +05:30
real ( pReal ) , intent ( out ) , dimension ( plastic_disloUCLA_totalNslip ( instance ) ) :: &
2018-11-27 22:55:06 +05:30
gdot_slip_pos , dgdot_dtauslip_pos , tau_slip_pos , gdot_slip_neg , dgdot_dtauslip_neg , tau_slip_neg
!* Shortened notation
ns = plastic_disloUCLA_totalNslip ( instance )
2014-11-06 00:41:09 +05:30
gdot_slip_pos = 0.0_pReal
2014-11-06 02:23:25 +05:30
gdot_slip_neg = 0.0_pReal
dgdot_dtauslip_pos = 0.0_pReal
dgdot_dtauslip_neg = 0.0_pReal
2014-11-06 00:41:09 +05:30
j = 0_pInt
2014-11-06 02:23:25 +05:30
slipFamilies : do f = 1_pInt , lattice_maxNslipFamily
2014-11-06 01:09:23 +05:30
index_myFamily = sum ( lattice_NslipSystem ( 1 : f - 1_pInt , ph ) ) ! at which index starts my family
2015-01-21 20:44:00 +05:30
slipSystems : do i = 1_pInt , plastic_disloUCLA_Nslip ( f , instance )
2014-11-06 01:09:23 +05:30
j = j + 1_pInt
2014-11-07 16:53:34 +05:30
!* Boltzmann ratio
2015-01-21 20:44:00 +05:30
BoltzmannRatio = plastic_disloUCLA_QedgePerSlipSystem ( j , instance ) / ( kB * Temperature )
2014-11-07 16:53:34 +05:30
!* Initial shear rates
DotGamma0 = &
2016-01-15 20:56:24 +05:30
state ( instance ) % rhoEdge ( j , of ) * plastic_disloUCLA_burgersPerSlipSystem ( j , instance ) * &
2015-01-21 20:44:00 +05:30
plastic_disloUCLA_v0PerSlipSystem ( j , instance )
2014-11-06 01:09:23 +05:30
!* Resolved shear stress on slip system
2018-11-28 11:14:32 +05:30
tau_slip_pos ( j ) = math_mul33xx33 ( Mp , lattice_Sslip ( : , : , 1 , index_myFamily + i , ph ) )
2014-11-06 02:23:25 +05:30
tau_slip_neg ( j ) = tau_slip_pos ( j )
nonSchmidSystems : do k = 1 , lattice_NnonSchmid ( ph )
2015-01-21 20:44:00 +05:30
tau_slip_pos = tau_slip_pos + plastic_disloUCLA_nonSchmidCoeff ( k , instance ) * &
2018-11-28 11:14:32 +05:30
math_mul33xx33 ( Mp , lattice_Sslip ( 1 : 3 , 1 : 3 , 2 * k , index_myFamily + i , ph ) )
2015-01-21 20:44:00 +05:30
tau_slip_neg = tau_slip_neg + plastic_disloUCLA_nonSchmidCoeff ( k , instance ) * &
2018-11-28 11:14:32 +05:30
math_mul33xx33 ( Mp , lattice_Sslip ( 1 : 3 , 1 : 3 , 2 * k + 1 , index_myFamily + i , ph ) )
2014-11-06 02:23:25 +05:30
enddo nonSchmidSystems
2014-11-07 16:53:34 +05:30
2016-01-15 20:56:24 +05:30
significantPositiveTau : if ( ( abs ( tau_slip_pos ( j ) ) - state ( instance ) % threshold_stress_slip ( j , of ) ) > tol_math_check ) then
2015-01-21 20:44:00 +05:30
!* Stress ratio
2016-01-15 20:56:24 +05:30
stressRatio = ( ( abs ( tau_slip_pos ( j ) ) - state ( instance ) % threshold_stress_slip ( j , of ) ) / &
2015-01-21 20:44:00 +05:30
( plastic_disloUCLA_SolidSolutionStrength ( instance ) + &
plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) ) )
stressRatio_p = stressRatio ** plastic_disloUCLA_pPerSlipFamily ( f , instance )
stressRatio_pminus1 = stressRatio ** ( plastic_disloUCLA_pPerSlipFamily ( f , instance ) - 1.0_pReal )
!* Shear rates due to slip
vel_slip = 2.0_pReal * plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_kinkheight ( f , instance ) * plastic_disloUCLA_omega ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
* ( tau_slip_pos ( j ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) &
2015-01-16 04:10:17 +05:30
/ ( &
2015-01-21 20:44:00 +05:30
2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) * tau_slip_pos ( j ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
)
2014-11-06 00:41:09 +05:30
2014-11-06 01:09:23 +05:30
gdot_slip_pos ( j ) = DotGamma0 &
2015-01-15 16:26:15 +05:30
* vel_slip &
2014-11-06 02:23:25 +05:30
* sign ( 1.0_pReal , tau_slip_pos ( j ) )
!* Derivatives of shear rates
2015-01-21 20:44:00 +05:30
2014-11-06 02:23:25 +05:30
dvel_slip = &
2015-01-21 20:44:00 +05:30
2.0_pReal * plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_kinkheight ( f , instance ) * plastic_disloUCLA_omega ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
* ( &
2015-01-21 20:44:00 +05:30
( exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
+ tau_slip_pos ( j ) &
2015-01-21 20:44:00 +05:30
* ( abs ( exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) & !deltaf(i)
* BoltzmannRatio * plastic_disloUCLA_pPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_qPerSlipFamily ( f , instance ) / &
( plastic_disloUCLA_SolidSolutionStrength ( instance ) + plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) ) * &
StressRatio_pminus1 * ( 1 - StressRatio_p ) ** ( plastic_disloUCLA_qPerSlipFamily ( f , instance ) - 1.0_pReal ) ) & !deltaf(f)
2015-01-16 04:10:17 +05:30
) &
2015-01-21 20:44:00 +05:30
* ( 2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) * tau_slip_pos ( j ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
) &
- ( tau_slip_pos ( j ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) &
* ( 2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* ( abs ( exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) & !deltaf(i)
* BoltzmannRatio * plastic_disloUCLA_pPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_qPerSlipFamily ( f , instance ) / &
( plastic_disloUCLA_SolidSolutionStrength ( instance ) + plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) ) * &
StressRatio_pminus1 * ( 1 - StressRatio_p ) ** ( plastic_disloUCLA_qPerSlipFamily ( f , instance ) - 1.0_pReal ) ) & !deltaf(f)
2015-01-16 04:10:17 +05:30
) &
) &
/ ( &
( &
2015-01-21 20:44:00 +05:30
2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) * tau_slip_pos ( j ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
) ** 2.0_pReal &
)
2015-01-15 16:26:15 +05:30
dgdot_dtauslip_pos ( j ) = DotGamma0 * dvel_slip
2016-01-15 20:56:24 +05:30
endif significantPositiveTau
significantNegativeTau : if ( ( abs ( tau_slip_neg ( j ) ) - state ( instance ) % threshold_stress_slip ( j , of ) ) > tol_math_check ) then
2014-11-06 02:23:25 +05:30
!* Stress ratios
2016-01-15 20:56:24 +05:30
stressRatio = ( ( abs ( tau_slip_neg ( j ) ) - state ( instance ) % threshold_stress_slip ( j , of ) ) / &
2015-01-21 20:44:00 +05:30
( plastic_disloUCLA_SolidSolutionStrength ( instance ) + &
plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) ) )
stressRatio_p = stressRatio ** plastic_disloUCLA_pPerSlipFamily ( f , instance )
stressRatio_pminus1 = stressRatio ** ( plastic_disloUCLA_pPerSlipFamily ( f , instance ) - 1.0_pReal )
2014-11-06 02:23:25 +05:30
!* Shear rates due to slip
2015-01-21 20:44:00 +05:30
vel_slip = 2.0_pReal * plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_kinkheight ( f , instance ) * plastic_disloUCLA_omega ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
* ( tau_slip_neg ( j ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) &
2015-01-16 04:10:17 +05:30
/ ( &
2015-01-21 20:44:00 +05:30
2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) * tau_slip_neg ( j ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
)
2015-01-15 16:26:15 +05:30
2014-11-06 02:23:25 +05:30
gdot_slip_neg ( j ) = DotGamma0 &
2015-01-15 16:26:15 +05:30
* vel_slip &
2014-11-06 02:23:25 +05:30
* sign ( 1.0_pReal , tau_slip_neg ( j ) )
2014-11-06 01:09:23 +05:30
!* Derivatives of shear rates
dvel_slip = &
2015-01-21 20:44:00 +05:30
2.0_pReal * plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_kinkheight ( f , instance ) * plastic_disloUCLA_omega ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
* ( &
2015-01-21 20:44:00 +05:30
( exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
+ tau_slip_neg ( j ) &
2015-01-21 20:44:00 +05:30
* ( abs ( exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) & !deltaf(i)
* BoltzmannRatio * plastic_disloUCLA_pPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_qPerSlipFamily ( f , instance ) / &
( plastic_disloUCLA_SolidSolutionStrength ( instance ) + plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) ) * &
StressRatio_pminus1 * ( 1 - StressRatio_p ) ** ( plastic_disloUCLA_qPerSlipFamily ( f , instance ) - 1.0_pReal ) ) & !deltaf(f)
2015-01-16 04:10:17 +05:30
) &
2015-01-21 20:44:00 +05:30
* ( 2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) * tau_slip_neg ( j ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
) &
- ( tau_slip_neg ( j ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) &
* ( 2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* ( abs ( exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) ) & !deltaf(i)
* BoltzmannRatio * plastic_disloUCLA_pPerSlipFamily ( f , instance ) &
* plastic_disloUCLA_qPerSlipFamily ( f , instance ) / &
( plastic_disloUCLA_SolidSolutionStrength ( instance ) + plastic_disloUCLA_tau_peierlsPerSlipFamily ( f , instance ) ) * &
StressRatio_pminus1 * ( 1 - StressRatio_p ) ** ( plastic_disloUCLA_qPerSlipFamily ( f , instance ) - 1.0_pReal ) ) & !deltaf(f)
2015-01-16 04:10:17 +05:30
) &
) &
/ ( &
( &
2015-01-21 20:44:00 +05:30
2.0_pReal * ( plastic_disloUCLA_burgersPerSlipFamily ( f , instance ) ** 2.0_pReal ) * tau_slip_neg ( j ) &
+ plastic_disloUCLA_omega ( f , instance ) * plastic_disloUCLA_friction ( f , instance ) &
2016-01-15 20:56:24 +05:30
* ( ( state ( instance ) % mfp_slip ( j , of ) - plastic_disloUCLA_kinkwidth ( f , instance ) ) ** 2.0_pReal ) &
2015-01-21 20:44:00 +05:30
* exp ( - BoltzmannRatio * ( 1 - StressRatio_p ) ** plastic_disloUCLA_qPerSlipFamily ( f , instance ) ) &
2015-01-16 04:10:17 +05:30
) ** 2.0_pReal &
)
2015-01-15 16:26:15 +05:30
dgdot_dtauslip_neg ( j ) = DotGamma0 * dvel_slip
2016-01-15 20:56:24 +05:30
endif significantNegativeTau
2014-11-06 02:23:25 +05:30
enddo slipSystems
enddo slipFamilies
2018-11-27 22:55:06 +05:30
end subroutine kinetics
2014-11-06 00:41:09 +05:30
2015-01-21 20:44:00 +05:30
end module plastic_disloUCLA