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

534 lines
26 KiB
Fortran
Raw Normal View History

state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
!--------------------------------------------------------------------------------------------------
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!> @author Franz Roters, Max-Planck-Institut für Eisenforschung GmbH
!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH
using default value for when getting strings, setting correct size for post results
2018-06-22 02:44:30 +05:30
!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH
mutual best practise phenopowerlaw <-> disloUCLA
2019-01-06 04:03:18 +05:30
!> @brief phenomenological crystal plasticity formulation using a powerlaw fitting
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
submodules allow inter-module communication
2019-12-03 01:13:02 +05:30
submodule(constitutive) plastic_phenopowerlaw
moved reading in of lattice type and elastic constants to lattice module removed structure type for hex, fcc, bcc, now defining slip/twin systems for each phase found in material.config constitutive modules will only be initialized if needed homogenizedC function is only needed for models incorporating twinning in a physical way (titanmod and dislotwin)
2014-03-09 02:20:31 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
type :: tParameters
real(pReal) :: &
gdot0_slip, & !< reference shear strain rate for slip
gdot0_twin, & !< reference shear strain rate for twin
n_slip, & !< stress exponent for slip
n_twin, & !< stress exponent for twin
spr, & !< push-up factor for slip saturation due to twinning
names from paper
2020-02-01 02:13:12 +05:30
c_1, &
natural order
2020-02-01 02:13:45 +05:30
c_2, &
names from paper
2020-02-01 02:13:12 +05:30
c_3, &
natural order
2020-02-01 02:13:45 +05:30
c_4, &
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
h0_SlipSlip, & !< reference hardening slip - slip
h0_TwinSlip, & !< reference hardening twin - slip
h0_TwinTwin, & !< reference hardening twin - twin
no need to store atol twice
2020-03-15 12:58:38 +05:30
a_slip
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
real(pReal), allocatable, dimension(:) :: &
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
xi_slip_0, & !< initial critical shear stress for slip
xi_twin_0, & !< initial critical shear stress for twin
xi_slip_sat, & !< maximum critical shear stress for slip
nonSchmidCoeff, &
H_int, & !< per family hardening activity (optional)
gamma_twin_char !< characteristic shear for twins
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
real(pReal), allocatable, dimension(:,:) :: &
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
interaction_SlipSlip, & !< slip resistance from slip activity
interaction_SlipTwin, & !< slip resistance from twin activity
interaction_TwinSlip, & !< twin resistance from slip activity
interaction_TwinTwin !< twin resistance from twin activity
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
real(pReal), allocatable, dimension(:,:,:) :: &
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
Schmid_slip, &
Schmid_twin, &
nonSchmid_pos, &
nonSchmid_neg
integer :: &
totalNslip, & !< total number of active slip system
totalNtwin !< total number of active twin systems
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
integer, allocatable, dimension(:) :: &
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
Nslip, & !< number of active slip systems for each family
Ntwin !< number of active twin systems for each family
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
character(len=pStringLen), allocatable, dimension(:) :: &
output
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
end type tParameters
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
type :: tPhenopowerlawState
real(pReal), pointer, dimension(:,:) :: &
xi_slip, &
xi_twin, &
gamma_slip, &
gamma_twin
end type tPhenopowerlawState
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
make similarity of state/param structure clear
2019-01-13 21:33:49 +05:30
!--------------------------------------------------------------------------------------------------
! containers for parameters and state
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
type(tParameters), allocatable, dimension(:) :: param
type(tPhenopowerlawState), allocatable, dimension(:) :: &
dotState, &
state
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
contains
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
more documentation and parameters capitalization unified and using ipc in all modules (sometimes called gr) nonlocal: only missing line continuation in string fixed
2013-07-01 11:40:42 +05:30
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
!> @brief Perform module initialization.
more documentation and parameters capitalization unified and using ipc in all modules (sometimes called gr) nonlocal: only missing line continuation in string fixed
2013-07-01 11:40:42 +05:30
!> @details reads in material parameters, allocates arrays, and does sanity checks
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
submodules allow inter-module communication
2019-12-03 01:13:02 +05:30
module subroutine plastic_phenopowerlaw_init
changed lattice_interaction matrices to (other:me) notation fixed small mistake in hexagonal twin--slip interaction matrix adopted above switched notation for hardening matrix calculation shortened dotState by introducing dot_product notation
2009-10-21 18:40:12 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
integer :: &
Ninstance, &
p, i, &
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
NipcMyPhase, &
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
sizeState, sizeDotState, &
startIndex, endIndex
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
character(len=pStringLen) :: &
extmsg = ''
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
no need to store atol twice
2020-03-15 12:58:38 +05:30
write(6,'(/,a)') ' <<<+- plastic_'//PLASTICITY_PHENOPOWERLAW_LABEL//' init -+>>>'; flush(6)
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
Ninstance = count(phase_plasticity == PLASTICITY_PHENOPOWERLAW_ID)
if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) &
write(6,'(a16,1x,i5,/)') '# instances:',Ninstance
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
allocate(param(Ninstance))
allocate(state(Ninstance))
allocate(dotState(Ninstance))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
do p = 1, size(phase_plasticity)
if (phase_plasticity(p) /= PLASTICITY_PHENOPOWERLAW_ID) cycle
associate(prm => param(phase_plasticityInstance(p)), &
dot => dotState(phase_plasticityInstance(p)), &
stt => state(phase_plasticityInstance(p)), &
config => config_phase(p))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
polishing
2018-10-14 12:56:32 +05:30
!--------------------------------------------------------------------------------------------------
! optional parameters that need to be defined
natural order
2020-02-01 02:13:45 +05:30
prm%c_1 = config%getFloat('twin_c',defaultVal=0.0_pReal)
prm%c_2 = config%getFloat('twin_b',defaultVal=1.0_pReal)
prm%c_3 = config%getFloat('twin_e',defaultVal=0.0_pReal)
prm%c_4 = config%getFloat('twin_d',defaultVal=0.0_pReal)
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
polishing
2018-10-14 12:56:32 +05:30
!--------------------------------------------------------------------------------------------------
! slip related parameters
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
prm%Nslip = config%getInts('nslip',defaultVal=emptyIntArray)
prm%totalNslip = sum(prm%Nslip)
slipActive: if (prm%totalNslip > 0) then
prm%Schmid_slip = lattice_SchmidMatrix_slip(prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
if(trim(config%getString('lattice_structure')) == 'bcc') then
prm%nonSchmidCoeff = config%getFloats('nonschmid_coefficients',&
defaultVal = emptyRealArray)
prm%nonSchmid_pos = lattice_nonSchmidMatrix(prm%Nslip,prm%nonSchmidCoeff,+1)
prm%nonSchmid_neg = lattice_nonSchmidMatrix(prm%Nslip,prm%nonSchmidCoeff,-1)
else
allocate(prm%nonSchmidCoeff(0))
prm%nonSchmid_pos = prm%Schmid_slip
prm%nonSchmid_neg = prm%Schmid_slip
endif
prm%interaction_SlipSlip = lattice_interaction_SlipBySlip(prm%Nslip, &
config%getFloats('interaction_slipslip'), &
config%getString('lattice_structure'))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
prm%xi_slip_0 = config%getFloats('tau0_slip', requiredSize=size(prm%Nslip))
prm%xi_slip_sat = config%getFloats('tausat_slip', requiredSize=size(prm%Nslip))
prm%H_int = config%getFloats('h_int', requiredSize=size(prm%Nslip), &
defaultVal=[(0.0_pReal,i=1,size(prm%Nslip))])
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
prm%gdot0_slip = config%getFloat('gdot0_slip')
prm%n_slip = config%getFloat('n_slip')
prm%a_slip = config%getFloat('a_slip')
prm%h0_SlipSlip = config%getFloat('h0_slipslip')
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
! expand: family => system
prm%xi_slip_0 = math_expand(prm%xi_slip_0, prm%Nslip)
prm%xi_slip_sat = math_expand(prm%xi_slip_sat,prm%Nslip)
prm%H_int = math_expand(prm%H_int, prm%Nslip)
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
! sanity checks
if ( prm%gdot0_slip <= 0.0_pReal) extmsg = trim(extmsg)//' gdot0_slip'
if ( prm%a_slip <= 0.0_pReal) extmsg = trim(extmsg)//' a_slip'
if ( prm%n_slip <= 0.0_pReal) extmsg = trim(extmsg)//' n_slip'
if (any(prm%xi_slip_0 <= 0.0_pReal)) extmsg = trim(extmsg)//' xi_slip_0'
if (any(prm%xi_slip_sat <= 0.0_pReal)) extmsg = trim(extmsg)//' xi_slip_sat'
else slipActive
allocate(prm%interaction_SlipSlip(0,0))
allocate(prm%xi_slip_0(0))
endif slipActive
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
polishing
2018-10-14 12:56:32 +05:30
!--------------------------------------------------------------------------------------------------
! twin related parameters
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
prm%Ntwin = config%getInts('ntwin', defaultVal=emptyIntArray)
prm%totalNtwin = sum(prm%Ntwin)
twinActive: if (prm%totalNtwin > 0) then
prm%Schmid_twin = lattice_SchmidMatrix_twin(prm%Ntwin,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
prm%interaction_TwinTwin = lattice_interaction_TwinByTwin(prm%Ntwin,&
config%getFloats('interaction_twintwin'), &
config%getString('lattice_structure'))
prm%gamma_twin_char = lattice_characteristicShear_twin(prm%Ntwin,config%getString('lattice_structure'),&
config%getFloat('c/a'))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
prm%xi_twin_0 = config%getFloats('tau0_twin',requiredSize=size(prm%Ntwin))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
prm%gdot0_twin = config%getFloat('gdot0_twin')
prm%n_twin = config%getFloat('n_twin')
prm%spr = config%getFloat('s_pr')
prm%h0_TwinTwin = config%getFloat('h0_twintwin')
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
! expand: family => system
prm%xi_twin_0 = math_expand(prm%xi_twin_0, prm%Ntwin)
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
! sanity checks
if (prm%gdot0_twin <= 0.0_pReal) extmsg = trim(extmsg)//' gdot0_twin'
if (prm%n_twin <= 0.0_pReal) extmsg = trim(extmsg)//' n_twin'
else twinActive
allocate(prm%interaction_TwinTwin(0,0))
allocate(prm%xi_twin_0(0))
allocate(prm%gamma_twin_char(0))
endif twinActive
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
polishing
2018-10-14 12:56:32 +05:30
!--------------------------------------------------------------------------------------------------
! slip-twin related parameters
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
slipAndTwinActive: if (prm%totalNslip > 0 .and. prm%totalNtwin > 0) then
prm%h0_TwinSlip = config%getFloat('h0_twinslip')
prm%interaction_SlipTwin = lattice_interaction_SlipByTwin(prm%Nslip,prm%Ntwin,&
config%getFloats('interaction_sliptwin'), &
config%getString('lattice_structure'))
prm%interaction_TwinSlip = lattice_interaction_TwinBySlip(prm%Ntwin,prm%Nslip,&
config%getFloats('interaction_twinslip'), &
config%getString('lattice_structure'))
else slipAndTwinActive
allocate(prm%interaction_SlipTwin(prm%TotalNslip,prm%TotalNtwin)) ! at least one dimension is 0
allocate(prm%interaction_TwinSlip(prm%TotalNtwin,prm%TotalNslip)) ! at least one dimension is 0
prm%h0_TwinSlip = 0.0_pReal
endif slipAndTwinActive
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
polishing
2018-10-14 12:56:32 +05:30
!--------------------------------------------------------------------------------------------------
! output pararameters
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
prm%output = config%getStrings('(output)',defaultVal=emptyStringArray)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
!--------------------------------------------------------------------------------------------------
! allocate state arrays
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
NipcMyPhase = count(material_phaseAt == p) * discretization_nIP
sizeDotState = size(['tau_slip ','gamma_slip']) * prm%totalNslip &
+ size(['tau_twin ','gamma_twin']) * prm%totalNtwin
sizeState = sizeDotState
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
call material_allocatePlasticState(p,NipcMyPhase,sizeState,sizeDotState,0)
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
simplified reading in and initialization init of absolute tolerances and state0 done on the fly reading in array type parameters in the param structure :
2018-04-25 23:11:18 +05:30
!--------------------------------------------------------------------------------------------------
no need to store atol twice
2020-03-15 12:58:38 +05:30
! locally defined state aliases and initialization of state0 and atolState
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
startIndex = 1
endIndex = prm%totalNslip
stt%xi_slip => plasticState(p)%state (startIndex:endIndex,:)
stt%xi_slip = spread(prm%xi_slip_0, 2, NipcMyPhase)
dot%xi_slip => plasticState(p)%dotState(startIndex:endIndex,:)
no need to store atol twice
2020-03-15 12:58:38 +05:30
plasticState(p)%atolState(startIndex:endIndex) = config%getFloat('atol_resistance',defaultVal=1.0_pReal)
if(any(plasticState(p)%atolState(startIndex:endIndex)<=0.0_pReal)) &
extmsg = trim(extmsg)//' atol_xi'
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
startIndex = endIndex + 1
endIndex = endIndex + prm%totalNtwin
stt%xi_twin => plasticState(p)%state (startIndex:endIndex,:)
stt%xi_twin = spread(prm%xi_twin_0, 2, NipcMyPhase)
dot%xi_twin => plasticState(p)%dotState(startIndex:endIndex,:)
no need to store atol twice
2020-03-15 12:58:38 +05:30
plasticState(p)%atolState(startIndex:endIndex) = config%getFloat('atol_resistance',defaultVal=1.0_pReal)
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
startIndex = endIndex + 1
endIndex = endIndex + prm%totalNslip
stt%gamma_slip => plasticState(p)%state (startIndex:endIndex,:)
dot%gamma_slip => plasticState(p)%dotState(startIndex:endIndex,:)
no need to store atol twice
2020-03-15 12:58:38 +05:30
plasticState(p)%atolState(startIndex:endIndex) = config%getFloat('atol_shear',defaultVal=1.0e-6_pReal)
if(any(plasticState(p)%atolState(startIndex:endIndex)<=0.0_pReal)) &
extmsg = trim(extmsg)//' atol_gamma_slip'
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
! global alias
plasticState(p)%slipRate => plasticState(p)%dotState(startIndex:endIndex,:)
consistent names
2020-02-11 22:06:43 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
startIndex = endIndex + 1
endIndex = endIndex + prm%totalNtwin
stt%gamma_twin => plasticState(p)%state (startIndex:endIndex,:)
dot%gamma_twin => plasticState(p)%dotState(startIndex:endIndex,:)
no need to store atol twice
2020-03-15 12:58:38 +05:30
plasticState(p)%atolState(startIndex:endIndex) = config%getFloat('atol_twinfrac',defaultVal=1.0e-6_pReal)
if(any(plasticState(p)%atolState(startIndex:endIndex)<=0.0_pReal)) &
extmsg = trim(extmsg)//' atol_gamma_twin'
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
plasticState(p)%state0 = plasticState(p)%state ! ToDo: this could be done centrally
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
end associate
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
no need to store atol twice
2020-03-15 12:58:38 +05:30
!--------------------------------------------------------------------------------------------------
! exit if any parameter is out of range
if (extmsg /= '') call IO_error(211,ext_msg=trim(extmsg)//'('//PLASTICITY_PHENOPOWERLAW_LABEL//')')
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
enddo
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
simplified reading in and initialization init of absolute tolerances and state0 done on the fly reading in array type parameters in the param structure :
2018-04-25 23:11:18 +05:30
end subroutine plastic_phenopowerlaw_init
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
!> @brief Calculate plastic velocity gradient and its tangent.
whitespace not needed
2019-01-07 11:54:02 +05:30
!> @details asummes that deformation by dislocation glide affects twinned and untwinned volume
following best practise from phenopowerlaw
2019-01-07 01:48:35 +05:30
! equally (Taylor assumption). Twinning happens only in untwinned volume
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
submodules allow inter-module communication
2019-12-03 01:13:02 +05:30
pure module subroutine plastic_phenopowerlaw_LpAndItsTangent(Lp,dLp_dMp,Mp,instance,of)
kinetics_slip does not seem to be the problem
2018-10-14 19:23:24 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(3,3), intent(out) :: &
Lp !< plastic velocity gradient
real(pReal), dimension(3,3,3,3), intent(out) :: &
dLp_dMp !< derivative of Lp with respect to the Mandel stress
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress
integer, intent(in) :: &
instance, &
of
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
integer :: &
i,k,l,m,n
real(pReal), dimension(param(instance)%totalNslip) :: &
gdot_slip_pos,gdot_slip_neg, &
dgdot_dtauslip_pos,dgdot_dtauslip_neg
real(pReal), dimension(param(instance)%totalNtwin) :: &
gdot_twin,dgdot_dtautwin
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
Lp = 0.0_pReal
dLp_dMp = 0.0_pReal
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
associate(prm => param(instance))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
call kinetics_slip(Mp,instance,of,gdot_slip_pos,gdot_slip_neg,dgdot_dtauslip_pos,dgdot_dtauslip_neg)
slipSystems: do i = 1, prm%totalNslip
Lp = Lp + (gdot_slip_pos(i)+gdot_slip_neg(i))*prm%Schmid_slip(1:3,1:3,i)
forall (k=1:3,l=1:3,m=1:3,n=1:3) &
dLp_dMp(k,l,m,n) = dLp_dMp(k,l,m,n) &
+ 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
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
call kinetics_twin(Mp,instance,of,gdot_twin,dgdot_dtautwin)
twinSystems: do i = 1, prm%totalNtwin
Lp = Lp + gdot_twin(i)*prm%Schmid_twin(1:3,1:3,i)
forall (k=1:3,l=1:3,m=1:3,n=1:3) &
dLp_dMp(k,l,m,n) = dLp_dMp(k,l,m,n) &
+ dgdot_dtautwin(i)*prm%Schmid_twin(k,l,i)*prm%Schmid_twin(m,n,i)
enddo twinSystems
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
end associate
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
changed constitutive_* prefix for plasticity laws to plastic_* to be consistent with novel thermal_, damage_, vacancy_, etc. laws.
2014-12-08 21:25:30 +05:30
end subroutine plastic_phenopowerlaw_LpAndItsTangent
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
checking with Philip
2018-08-03 04:44:18 +05:30
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
!> @brief Calculate the rate of change of microstructure.
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
submodules allow inter-module communication
2019-12-03 01:13:02 +05:30
module subroutine plastic_phenopowerlaw_dotState(Mp,instance,of)
kinetics_slip does not seem to be the problem
2018-10-14 19:23:24 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress
integer, intent(in) :: &
instance, &
of
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal) :: &
c_SlipSlip,c_TwinSlip,c_TwinTwin, &
xi_slip_sat_offset,&
sumGamma,sumF
real(pReal), dimension(param(instance)%totalNslip) :: &
left_SlipSlip,right_SlipSlip, &
gdot_slip_pos,gdot_slip_neg
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
associate(prm => param(instance), stt => state(instance), dot => dotState(instance))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
sumGamma = sum(stt%gamma_slip(:,of))
sumF = sum(stt%gamma_twin(:,of)/prm%gamma_twin_char)
add pheno+ module in
2015-10-14 00:22:01 +05:30
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
switched saturation behavior!! was \dot s_alpha = (1-s_alpha/s_inf)^a h_alphabeta \dot gamma_beta now \dot s_alpha = h_alphabeta (1-s_beta/s_inf)^a \dot gamma_beta current form is consistent with the genmat implementation (and appears to make more physical sense). Kalidindi_etal1992 suggested this form, but altered it to the alpha-one in Bachu+Kalidindi1998... By now, it seems that some groups use alpha, others beta approach. introduced two new absolute tolerance values for "shears" and "twinFrac" (default 1e-6).
2012-10-22 20:25:07 +05:30
! system-independent (nonlinear) prefactors to M_Xx (X influenced by x) matrices
names from paper
2020-02-01 02:13:12 +05:30
c_SlipSlip = prm%h0_slipslip * (1.0_pReal + prm%c_1*sumF** prm%c_2)
c_TwinSlip = prm%h0_TwinSlip * sumGamma**prm%c_3
c_TwinTwin = prm%h0_TwinTwin * sumF**prm%c_4
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
more documentation and parameters capitalization unified and using ipc in all modules (sometimes called gr) nonlocal: only missing line continuation in string fixed
2013-07-01 11:40:42 +05:30
!--------------------------------------------------------------------------------------------------
extendend to Schmid_twin
2018-08-26 00:25:15 +05:30
! calculate left and right vectors
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
left_SlipSlip = 1.0_pReal + prm%H_int
xi_slip_sat_offset = prm%spr*sqrt(sumF)
right_SlipSlip = abs(1.0_pReal-stt%xi_slip(:,of) / (prm%xi_slip_sat+xi_slip_sat_offset)) **prm%a_slip &
* sign(1.0_pReal,1.0_pReal-stt%xi_slip(:,of) / (prm%xi_slip_sat+xi_slip_sat_offset))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
cleaning
2018-09-12 13:29:09 +05:30
!--------------------------------------------------------------------------------------------------
! shear rates
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
call kinetics_slip(Mp,instance,of,gdot_slip_pos,gdot_slip_neg)
dot%gamma_slip(:,of) = abs(gdot_slip_pos+gdot_slip_neg)
call kinetics_twin(Mp,instance,of,dot%gamma_twin(:,of))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
added comments (doxygen conform) to phenopowerlaw, added warning on specifying h0_sliptwin as it has no effect
2012-10-11 20:19:12 +05:30
!--------------------------------------------------------------------------------------------------
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
! hardening
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
dot%xi_slip(:,of) = c_SlipSlip * left_SlipSlip * &
matmul(prm%interaction_SlipSlip,dot%gamma_slip(:,of)*right_SlipSlip) &
+ matmul(prm%interaction_SlipTwin,dot%gamma_twin(:,of))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
dot%xi_twin(:,of) = c_TwinSlip * matmul(prm%interaction_TwinSlip,dot%gamma_slip(:,of)) &
+ c_TwinTwin * matmul(prm%interaction_TwinTwin,dot%gamma_twin(:,of))
end associate
simplified
2018-08-26 00:43:32 +05:30
changed constitutive_* prefix for plasticity laws to plastic_* to be consistent with novel thermal_, damage_, vacancy_, etc. laws.
2014-12-08 21:25:30 +05:30
end subroutine plastic_phenopowerlaw_dotState
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
shorthand names improve readability for dotstate and LpAnd...
2018-06-30 17:41:05 +05:30
Merge remote-tracking branch 'origin/development' into 56-parallel-hdf5
2019-01-07 01:26:36 +05:30
!--------------------------------------------------------------------------------------------------
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
!> @brief Write results to HDF5 output file.
Merge remote-tracking branch 'origin/development' into 56-parallel-hdf5
2019-01-07 01:26:36 +05:30
!--------------------------------------------------------------------------------------------------
submodules allow inter-module communication
2019-12-03 01:13:02 +05:30
module subroutine plastic_phenopowerlaw_results(instance,group)
writing more results out
2019-04-04 11:22:36 +05:30
integer, intent(in) :: instance
character(len=*), intent(in) :: group
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
writing more results out
2019-04-04 11:22:36 +05:30
integer :: o
associate(prm => param(instance), stt => state(instance))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
outputsLoop: do o = 1,size(prm%output)
select case(trim(prm%output(o)))
case('resistance_slip')
if(prm%totalNslip>0) call results_writeDataset(group,stt%xi_slip, 'xi_sl', &
'resistance against plastic slip','Pa')
case('accumulatedshear_slip')
if(prm%totalNslip>0) call results_writeDataset(group,stt%gamma_slip,'gamma_sl', &
'plastic shear','1')
case('resistance_twin')
if(prm%totalNtwin>0) call results_writeDataset(group,stt%xi_twin, 'xi_tw', &
'resistance against twinning','Pa')
case('accumulatedshear_twin')
if(prm%totalNtwin>0) call results_writeDataset(group,stt%gamma_twin,'gamma_tw', &
'twinning shear','1')
writing more results out
2019-04-04 11:22:36 +05:30
end select
enddo outputsLoop
end associate
Merge remote-tracking branch 'origin/development' into 56-parallel-hdf5
2019-01-07 01:26:36 +05:30
end subroutine plastic_phenopowerlaw_results
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
!--------------------------------------------------------------------------------------------------
no need for enums they just complicate the code, any performance gain should be negligible
2020-02-14 13:30:14 +05:30
!> @brief Calculate shear rates on slip systems and their derivatives with respect to resolved
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
! stress.
whitespace not needed
2019-01-07 11:54:02 +05:30
!> @details Derivatives are calculated only optionally.
! NOTE: Against the common convention, the result (i.e. intent(out)) variables are the last to
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
! have the optional arguments at the end.
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
!--------------------------------------------------------------------------------------------------
put private functions at the end for easy separation
2018-12-21 19:26:32 +05:30
pure subroutine kinetics_slip(Mp,instance,of, &
gdot_slip_pos,gdot_slip_neg,dgdot_dtau_slip_pos,dgdot_dtau_slip_neg)
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress
integer, intent(in) :: &
instance, &
of
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), intent(out), dimension(param(instance)%totalNslip) :: &
gdot_slip_pos, &
gdot_slip_neg
real(pReal), intent(out), optional, dimension(param(instance)%totalNslip) :: &
dgdot_dtau_slip_pos, &
dgdot_dtau_slip_neg
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(param(instance)%totalNslip) :: &
tau_slip_pos, &
tau_slip_neg
integer :: i
logical :: nonSchmidActive
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
associate(prm => param(instance), stt => state(instance))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
nonSchmidActive = size(prm%nonSchmidCoeff) > 0
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
do i = 1, prm%totalNslip
tau_slip_pos(i) = math_mul33xx33(Mp,prm%nonSchmid_pos(1:3,1:3,i))
tau_slip_neg(i) = merge(math_mul33xx33(Mp,prm%nonSchmid_neg(1:3,1:3,i)), &
0.0_pReal, nonSchmidActive)
enddo
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
where(dNeq0(tau_slip_pos))
gdot_slip_pos = prm%gdot0_slip * merge(0.5_pReal,1.0_pReal, nonSchmidActive) & ! 1/2 if non-Schmid active
* sign(abs(tau_slip_pos/stt%xi_slip(:,of))**prm%n_slip, tau_slip_pos)
else where
gdot_slip_pos = 0.0_pReal
end where
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
where(dNeq0(tau_slip_neg))
gdot_slip_neg = prm%gdot0_slip * 0.5_pReal & ! only used if non-Schmid active, always 1/2
* sign(abs(tau_slip_neg/stt%xi_slip(:,of))**prm%n_slip, tau_slip_neg)
else where
gdot_slip_neg = 0.0_pReal
end where
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
if (present(dgdot_dtau_slip_pos)) then
where(dNeq0(gdot_slip_pos))
dgdot_dtau_slip_pos = gdot_slip_pos*prm%n_slip/tau_slip_pos
else where
dgdot_dtau_slip_pos = 0.0_pReal
end where
endif
if (present(dgdot_dtau_slip_neg)) then
where(dNeq0(gdot_slip_neg))
dgdot_dtau_slip_neg = gdot_slip_neg*prm%n_slip/tau_slip_neg
else where
dgdot_dtau_slip_neg = 0.0_pReal
end where
endif
end associate
[skip sc] resolved stress not needed using kinetics_xxx as in disloUCLA compiles on gfortran but pre-receive hook with intel compiler (MSC.Marc) fails
2018-09-12 16:35:23 +05:30
end subroutine kinetics_slip
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
!--------------------------------------------------------------------------------------------------
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
!> @brief Calculate shear rates on twin systems and their derivatives with respect to resolved
! stress. Twinning is assumed to take place only in untwinned volume.
!> @details Derivatives are calculated only optionally.
whitespace not needed
2019-01-07 11:54:02 +05:30
! NOTE: Against the common convention, the result (i.e. intent(out)) variables are the last to
IMPORTANT Behavior change: Slip (Lp) happens in twinned volume fraction aliases for associate do not have to be defined
2018-12-12 20:43:57 +05:30
! have the optional arguments at the end.
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
!--------------------------------------------------------------------------------------------------
put private functions at the end for easy separation
2018-12-21 19:26:32 +05:30
pure subroutine kinetics_twin(Mp,instance,of,&
gdot_twin,dgdot_dtau_twin)
avoid repeated calculations does not save so much here, but avoids having inconsistent calculation (e.g. nonSchmid effects) and serves as a template for more complex models
2018-09-12 12:53:11 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(3,3), intent(in) :: &
Mp !< Mandel stress
integer, intent(in) :: &
instance, &
of
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(param(instance)%totalNtwin), intent(out) :: &
gdot_twin
real(pReal), dimension(param(instance)%totalNtwin), intent(out), optional :: &
dgdot_dtau_twin
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
real(pReal), dimension(param(instance)%totalNtwin) :: &
tau_twin
integer :: i
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
associate(prm => param(instance), stt => state(instance))
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
do i = 1, prm%totalNtwin
tau_twin(i) = math_mul33xx33(Mp,prm%Schmid_twin(1:3,1:3,i))
enddo
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
where(tau_twin > 0.0_pReal)
gdot_twin = (1.0_pReal-sum(stt%gamma_twin(:,of)/prm%gamma_twin_char)) & ! only twin in untwinned volume fraction
* prm%gdot0_twin*(abs(tau_twin)/stt%xi_twin(:,of))**prm%n_twin
else where
gdot_twin = 0.0_pReal
end where
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
if (present(dgdot_dtau_twin)) then
where(dNeq0(gdot_twin))
dgdot_dtau_twin = gdot_twin*prm%n_twin/tau_twin
else where
dgdot_dtau_twin = 0.0_pReal
end where
endif
no need for outputID just adds overhead, one string comparison per output and increment is computationally not an issue also unified to PEP recommendation of function description
2020-02-14 11:47:30 +05:30
fixing indentation always 2 spaces, not 1 for the first level
2020-02-01 02:07:18 +05:30
end associate
cleaning and fixing bugs (wrong indices)
2018-08-26 00:57:14 +05:30
put private functions at the end for easy separation
2018-12-21 19:26:32 +05:30
end subroutine kinetics_twin
dummy structure to write plasticity results
2018-12-12 11:10:57 +05:30
submodules allow inter-module communication
2019-12-03 01:13:02 +05:30
end submodule plastic_phenopowerlaw