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/plastic_phenopowerlaw.f90

886 lines
42 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
add pheno+ module in
2015-10-14 00:22:01 +05:30
!> @brief material subroutine for phenomenological crystal plasticity formulation using a powerlaw
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
!! 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
!--------------------------------------------------------------------------------------------------
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
module plastic_phenopowerlaw
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
use prec, only: &
pReal,&
introduced #EOF# as module wide parameter in IO.f90 renamed read/write binary file to read/write real/int removed suffix job from readFile functions as the name of the model is needed as an argument
2013-09-18 19:37:55 +05:30
pInt
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 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
implicit none
added Onurs modified description for tausat in j2 law. Polishing phenopowerlaw
2012-04-11 19:31:02 +05:30
private
improved on enums (introduced them for output in j2), fixed wrong recursion depth bug in IO, fixed a bug in reading in for none, j2, phenopowerlaw
2013-12-12 03:33:09 +05:30
integer(pInt), dimension(:,:), allocatable, target, public :: &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
plastic_phenopowerlaw_sizePostResult !< size of each post result output
add pheno+ module in
2015-10-14 00:22:01 +05:30
character(len=64), dimension(:,:), allocatable, target, public :: &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
plastic_phenopowerlaw_output !< name of each post result output
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
add pheno+ module in
2015-10-14 00:22:01 +05:30
enum, bind(c)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
enumerator :: &
undefined_ID, &
resistance_slip_ID, &
accumulatedshear_slip_ID, &
shearrate_slip_ID, &
resolvedstress_slip_ID, &
totalshear_ID, &
resistance_twin_ID, &
accumulatedshear_twin_ID, &
shearrate_twin_ID, &
resolvedstress_twin_ID, &
totalvolfrac_twin_ID
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
end enum
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
type, private :: tParameters !< container type for internal constitutive parameters
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
integer(pInt) :: &
totalNslip, &
totalNtwin
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
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
twinB, &
twinC, &
twinD, &
twinE, &
h0_SlipSlip, & !< reference hardening slip - slip
h0_TwinSlip, & !< reference hardening twin - slip
h0_TwinTwin, & !< reference hardening twin - twin
a_slip, &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
aTolResistance, & ! default absolute tolerance 1 Pa
aTolShear, & ! default absolute tolerance 1e-6
aTolTwinfrac ! default absolute tolerance 1e-6
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
integer(pInt), dimension(:), allocatable :: &
Nslip, & !< active number of slip systems per family
Ntwin !< active number of twin systems per family
real(pReal), dimension(:), allocatable :: &
tau0_slip, & !< initial critical shear stress for slip
tau0_twin, & !< initial critical shear stress for twin
tausat_slip, & !< maximum critical shear stress for slip
nonSchmidCoeff, &
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
H_int !< per family hardening activity (optional)
real(pReal), dimension(:,:), allocatable :: &
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +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
using material.config values from main memory
2018-06-02 02:26:20 +05:30
integer(kind(undefined_ID)), dimension(:), allocatable :: &
outputID !< ID of each post result output
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
end type
using material.config values from main memory
2018-06-02 02:26:20 +05:30
type(tParameters), dimension(:), allocatable, target, private :: param !< containers of constitutive parameters (len Ninstance)
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
type, private :: tPhenopowerlawState
real(pReal), pointer, dimension(:,:) :: &
s_slip, &
s_twin, &
accshear_slip, &
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
accshear_twin, &
whole
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
real(pReal), pointer, dimension(:) :: &
sumGamma, &
sumF
end type
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
type(tPhenopowerlawState), allocatable, dimension(:), target, private :: &
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
dotState, &
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
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 Onurs modified description for tausat in j2 law. Polishing phenopowerlaw
2012-04-11 19:31:02 +05:30
public :: &
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
plastic_phenopowerlaw_init, &
plastic_phenopowerlaw_LpAndItsTangent, &
plastic_phenopowerlaw_dotState, &
plastic_phenopowerlaw_postResults
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +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
!--------------------------------------------------------------------------------------------------
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
!> @brief module initialization
!> @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
!--------------------------------------------------------------------------------------------------
using material.config values from main memory
2018-06-02 02:26:20 +05:30
subroutine plastic_phenopowerlaw_init
compiler_options and compiler_version supported by new Intel compiler
2018-02-02 17:06:09 +05:30
#if defined(__GFORTRAN__) || __INTEL_COMPILER >= 1800
suppress warning when compiling with gfortran
2017-10-05 20:05:34 +05:30
use, intrinsic :: iso_fortran_env, only: &
compiler_version, &
compiler_options
#endif
using dEq, dNeq, cEq, dEq
2016-05-29 14:15:03 +05:30
use prec, only: &
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
dEq0
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
use debug, only: &
debug_level, &
debug_constitutive,&
debug_levelBasic
fixed over-sensitive error in homogeniztion and ifort option in makefile
2013-12-19 14:19:47 +05:30
use math, only: &
math_Mandel3333to66, &
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
math_Voigt66to3333, &
math_expand
fixed over-sensitive error in homogeniztion and ifort option in makefile
2013-12-19 14:19:47 +05:30
use IO, only: &
IO_warning, &
IO_error, &
polishing
2018-06-02 09:09:40 +05:30
IO_timeStamp
fixed over-sensitive error in homogeniztion and ifort option in makefile
2013-12-19 14:19:47 +05:30
use material, only: &
phase_plasticity, &
phase_plasticityInstance, &
phase_Noutput, &
PLASTICITY_PHENOPOWERLAW_label, &
PLASTICITY_PHENOPOWERLAW_ID, &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
material_phase, &
material.config is read in centrally moving data from material to config_material. use statements need to change. All aspects of reading from file will be removed from the individual modules
2018-06-10 21:31:52 +05:30
plasticState
more general name (should include parsing of debug and numerics)
2018-06-14 10:09:49 +05:30
use config, only: &
using config module
2018-06-19 23:13:41 +05:30
MATERIAL_partPhase, &
updated rename
2018-06-27 00:38:13 +05:30
config_phase
improved reading in of values, now only warnings in case of problematic entries in material.config divergence calculation sqrt scaling optionally introduced for basic scheme spectral solver
2013-02-08 21:25:53 +05:30
use lattice
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
use numerics,only: &
numerics_integrator
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
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
implicit none
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
integer(pInt) :: &
maxNinstance, &
adjusted naming convention
2018-06-27 12:42:33 +05:30
instance,p,j,k, f,o, i,&
using material.config values from main memory
2018-06-02 02:26:20 +05:30
NipcMyPhase, outputSize, &
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
index_myFamily, index_otherFamily, &
polishing
2018-06-02 09:09:40 +05:30
sizeState,sizeDotState, &
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
startIndex, endIndex
polishing
2018-06-02 09:09:40 +05:30
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
real(pReal), dimension(:,:), allocatable :: temp1, temp2
adjusted naming convention
2018-06-27 12:42:33 +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)::]
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
using config module
2018-06-19 23:13:41 +05:30
type(tParameters), pointer :: prm
using material.config values from main memory
2018-06-02 02:26:20 +05:30
integer(kind(undefined_ID)) :: &
outputID !< ID of each post result output
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
polishing
2018-06-02 09:09:40 +05:30
character(len=512) :: &
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
extmsg = ''
circumventing bug in Gfortran, tests use correct label (a_slip)
2018-06-22 21:44:14 +05:30
character(len=65536), dimension(:), allocatable :: outputs
add pheno+ module in
2015-10-14 00:22:01 +05:30
removed allocation for (dot)state backup, simplified screen output handling for MPI
2016-07-25 23:42:00 +05:30
write(6,'(/,a)') ' <<<+- constitutive_'//PLASTICITY_PHENOPOWERLAW_label//' init -+>>>'
write(6,'(a15,a)') ' Current time: ',IO_timeStamp()
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
#include "compilation_info.f90"
add pheno+ module in
2015-10-14 00:22:01 +05:30
using material.config values from main memory
2018-06-02 02:26:20 +05:30
maxNinstance = int(count(phase_plasticity == PLASTICITY_PHENOPOWERLAW_ID),pInt)
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
if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0_pInt) &
write(6,'(a16,1x,i5,/)') '# instances:',maxNinstance
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
allocate(plastic_phenopowerlaw_sizePostResult(maxval(phase_Noutput),maxNinstance),source=0_pInt)
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
allocate(plastic_phenopowerlaw_output(maxval(phase_Noutput),maxNinstance))
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
plastic_phenopowerlaw_output = ''
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
ntwin = [0] cause problems math_expand now works for sum(how) == 0
2018-05-02 20:14:27 +05:30
allocate(param(maxNinstance)) ! one container of parameters per instance
using material.config values from main memory
2018-06-02 02:26:20 +05:30
allocate(state(maxNinstance))
allocate(dotState(maxNinstance))
improved on enums (introduced them for output in j2), fixed wrong recursion depth bug in IO, fixed a bug in reading in for none, j2, phenopowerlaw
2013-12-12 03:33:09 +05:30
adjusted naming convention
2018-06-27 12:42:33 +05:30
do p = 1_pInt, size(phase_plasticityInstance)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
if (phase_plasticity(p) /= PLASTICITY_PHENOPOWERLAW_ID) cycle
instance = phase_plasticityInstance(p)
prm => param(instance)
prm%Nslip = config_phase(p)%getInts('nslip',defaultVal=emptyIntArray)
if (size(prm%Nslip) > count(lattice_NslipSystem(:,p) > 0_pInt)) call IO_error(150_pInt,ext_msg='Nslip')
if (any(lattice_NslipSystem(1:size(prm%Nslip),p)-prm%Nslip < 0_pInt)) call IO_error(150_pInt,ext_msg='Nslip')
prm%totalNslip = sum(prm%Nslip)
if (prm%totalNslip > 0_pInt) then
prm%tau0_slip = config_phase(p)%getFloats('tau0_slip')
prm%tausat_slip = config_phase(p)%getFloats('tausat_slip')
prm%interaction_SlipSlip = spread(config_phase(p)%getFloats('interaction_slipslip'),2,1)
prm%H_int = config_phase(p)%getFloats('h_int',&
defaultVal=[(0.0_pReal,i=1_pInt,size(prm%Nslip))])
prm%nonSchmidCoeff = config_phase(p)%getFloats('nonschmid_coefficients',&
defaultVal = emptyRealArray )
prm%gdot0_slip = config_phase(p)%getFloat('gdot0_slip')
prm%n_slip = config_phase(p)%getFloat('n_slip')
prm%a_slip = config_phase(p)%getFloat('a_slip')
prm%h0_SlipSlip = config_phase(p)%getFloat('h0_slipslip')
endif
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
prm%Ntwin = config_phase(p)%getInts('ntwin', defaultVal=emptyIntArray)
if (size(prm%Ntwin) > count(lattice_NtwinSystem(:,p) > 0_pInt)) call IO_error(150_pInt,ext_msg='Ntwin')
if (any(lattice_NtwinSystem(1:size(prm%Ntwin),p)-prm%Ntwin < 0_pInt)) call IO_error(150_pInt,ext_msg='Ntwin')
prm%totalNtwin = sum(prm%Ntwin)
if (prm%totalNtwin > 0_pInt) then
prm%tau0_twin = config_phase(p)%getFloats('tau0_twin')
prm%interaction_TwinTwin = spread(config_phase(p)%getFloats('interaction_twintwin'),2,1)
prm%gdot0_twin = config_phase(p)%getFloat('gdot0_twin')
prm%n_twin = config_phase(p)%getFloat('n_twin')
prm%spr = config_phase(p)%getFloat('s_pr')
prm%twinB = config_phase(p)%getFloat('twin_b')
prm%twinC = config_phase(p)%getFloat('twin_c')
prm%twinD = config_phase(p)%getFloat('twin_d')
prm%twinE = config_phase(p)%getFloat('twin_e')
prm%h0_TwinTwin = config_phase(p)%getFloat('h0_twintwin')
endif
polishing
2018-06-02 09:09:40 +05:30
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
if (prm%totalNslip > 0_pInt .and. prm%totalNtwin > 0_pInt) then
prm%interaction_SlipTwin = spread(config_phase(p)%getFloats('interaction_sliptwin'),2,1)
prm%interaction_TwinSlip = spread(config_phase(p)%getFloats('interaction_twinslip'),2,1)
prm%h0_TwinSlip = config_phase(p)%getFloat('h0_twinslip')
endif
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
proper error checks
2018-06-02 13:49:22 +05:30
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
prm%aTolResistance = config_phase(p)%getFloat('atol_resistance',defaultVal=1.0_pReal)
prm%aTolShear = config_phase(p)%getFloat('atol_shear',defaultVal=1.0e-6_pReal)
prm%aTolTwinfrac = config_phase(p)%getFloat('atol_twinfrac',defaultVal=1.0e-6_pReal)
outputs = config_phase(p)%getStrings('(output)',defaultVal=emptyStringArray)
allocate(prm%outputID(0))
do i=1_pInt, size(outputs)
outputID = undefined_ID
select case(outputs(i))
case ('resistance_slip')
outputID = resistance_slip_ID
outputSize = sum(prm%Nslip)
case ('accumulatedshear_slip')
outputID = accumulatedshear_slip_ID
outputSize = sum(prm%Nslip)
case ('shearrate_slip')
outputID = shearrate_slip_ID
outputSize = sum(prm%Nslip)
case ('resolvedstress_slip')
outputID = resolvedstress_slip_ID
outputSize = sum(prm%Nslip)
case ('resistance_twin')
outputID = resistance_twin_ID
outputSize = sum(prm%Ntwin)
case ('accumulatedshear_twin')
outputID = accumulatedshear_twin_ID
outputSize = sum(prm%Ntwin)
case ('shearrate_twin')
outputID = shearrate_twin_ID
outputSize = sum(prm%Ntwin)
case ('resolvedstress_twin')
outputID = resolvedstress_twin_ID
outputSize = sum(prm%Ntwin)
case ('totalvolfrac_twin')
outputID = totalvolfrac_twin_ID
outputSize = 1_pInt
case ('totalshear')
outputID = totalshear_ID
outputSize = 1_pInt
end select
if (outputID /= undefined_ID) then
plastic_phenopowerlaw_output(i,instance) = outputs(i)
plastic_phenopowerlaw_sizePostResult(i,instance) = outputSize
prm%outputID = [prm%outputID , outputID]
endif
end do
extmsg = ''
if (sum(prm%Nslip) > 0_pInt) then
if (size(prm%tau0_slip) /= size(prm%Nslip)) call IO_error(211_pInt,ip=instance, &
ext_msg='shape(tau0_slip) ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (size(prm%tausat_slip) /= size(prm%Nslip)) call IO_error(211_pInt,ip=instance, &
ext_msg='shape(tausat_slip) ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (size(prm%H_int) /= size(prm%Nslip)) call IO_error(211_pInt,ip=instance, &
ext_msg='shape(H_int) ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (any(prm%tau0_slip < 0.0_pReal .and. prm%Nslip > 0_pInt)) &
extmsg = trim(extmsg)//"tau0_slip "
if (any(prm%tausat_slip < prm%tau0_slip .and. prm%Nslip > 0_pInt)) &
extmsg = trim(extmsg)//"tausat_slip "
if (prm%gdot0_slip <= 0.0_pReal) extmsg = trim(extmsg)//" gdot0_slip "
if (dEq0(prm%a_slip)) extmsg = trim(extmsg)//" a_slip " ! ToDo: negative values ok?
if (dEq0(prm%n_slip)) extmsg = trim(extmsg)//" n_slip " ! ToDo: negative values ok?
endif
if (sum(prm%Ntwin) > 0_pInt) then
if (size(prm%tau0_twin) /= size(prm%ntwin)) call IO_error(211_pInt,ip=instance,&
ext_msg='shape(tau0_twin) ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (any(prm%tau0_twin < 0.0_pReal .and. prm%Ntwin > 0_pInt)) &
extmsg = trim(extmsg)//"tau0_twin "
if (prm%gdot0_twin <= 0.0_pReal) extmsg = trim(extmsg)//"gdot0_twin "
if (dEq0(prm%n_twin)) extmsg = trim(extmsg)//"n_twin " ! ToDo: negative values ok?
endif
if (prm%aTolResistance <= 0.0_pReal) extmsg = trim(extmsg)//"aTolresistance "
if (prm%aTolShear <= 0.0_pReal) extmsg = trim(extmsg)//"aTolShear "
if (prm%aTolTwinfrac <= 0.0_pReal) extmsg = trim(extmsg)//"atoltwinfrac "
volume fraction where new twins may form is now limited to (1-F) instead of 1... "relevantResistance" is set to 1 Pa as default
2009-10-22 14:28:14 +05:30
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
if (extmsg /= '') call IO_error(211_pInt,ip=instance,&
ext_msg=trim(extmsg)//'('//PLASTICITY_PHENOPOWERLAW_label//')')
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
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
!--------------------------------------------------------------------------------------------------
! allocate state arrays
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
NipcMyPhase = count(material_phase == p) ! number of IPCs containing my phase
don't complicate code with potential enhancements
2018-06-27 13:39:19 +05:30
sizeState = size(['tau_slip ','accshear_slip']) * prm%TotalNslip &
+ size(['tau_twin ','accshear_twin']) * prm%TotalNtwin &
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
+ size(['sum(gamma)', 'sum(f) '])
sizeDotState = sizeState
plasticState(p)%sizeState = sizeState
plasticState(p)%sizeDotState = sizeDotState
plasticState(p)%sizePostResults = sum(plastic_phenopowerlaw_sizePostResult(:,instance))
plasticState(p)%nSlip = sum(prm%Nslip)
plasticState(p)%nTwin = sum(prm%Ntwin)
allocate(plasticState(p)%aTolState ( sizeState), source=0.0_pReal)
allocate(plasticState(p)%state0 ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(p)%partionedState0 ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(p)%subState0 ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(p)%state ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(p)%dotState (sizeDotState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(p)%deltaState (0_pInt,NipcMyPhase), source=0.0_pReal)
if (any(numerics_integrator == 1_pInt)) then
allocate(plasticState(p)%previousDotState (sizeDotState,NipcMyPhase),source=0.0_pReal)
allocate(plasticState(p)%previousDotState2(sizeDotState,NipcMyPhase),source=0.0_pReal)
endif
if (any(numerics_integrator == 4_pInt)) &
allocate(plasticState(p)%RK4dotState (sizeDotState,NipcMyPhase), source=0.0_pReal)
if (any(numerics_integrator == 5_pInt)) &
allocate(plasticState(p)%RKCK45dotState (6,sizeDotState,NipcMyPhase), source=0.0_pReal)
add pheno+ module in
2015-10-14 00:22:01 +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
!--------------------------------------------------------------------------------------------------
using material.config values from main memory
2018-06-02 02:26:20 +05:30
! calculate hardening matrices
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
allocate(temp1(sum(prm%Nslip),sum(prm%Nslip)),source =0.0_pReal)
allocate(temp2(sum(prm%Nslip),sum(prm%Ntwin)),source =0.0_pReal)
mySlipFamilies: do f = 1_pInt,size(prm%Nslip,1) ! >>> interaction slip -- X
index_myFamily = sum(prm%Nslip(1:f-1_pInt))
mySlipSystems: do j = 1_pInt,prm%Nslip(f)
otherSlipFamilies: do o = 1_pInt,size(prm%Nslip,1)
index_otherFamily = sum(prm%Nslip(1:o-1_pInt))
otherSlipSystems: do k = 1_pInt,prm%Nslip(o)
temp1(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_SlipSlip(lattice_interactionSlipSlip( &
sum(lattice_NslipSystem(1:f-1,p))+j, &
sum(lattice_NslipSystem(1:o-1,p))+k, &
p),1)
enddo otherSlipSystems; enddo otherSlipFamilies
twinFamilies: do o = 1_pInt,size(prm%Ntwin,1)
index_otherFamily = sum(prm%Ntwin(1:o-1_pInt))
twinSystems: do k = 1_pInt,prm%Ntwin(o)
temp2(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_SlipTwin(lattice_interactionSlipTwin( &
sum(lattice_NslipSystem(1:f-1_pInt,p))+j, &
sum(lattice_NtwinSystem(1:o-1_pInt,p))+k, &
p),1)
enddo twinSystems; enddo twinFamilies
enddo mySlipSystems
enddo mySlipFamilies
prm%interaction_SlipSlip = temp1; deallocate(temp1)
prm%interaction_SlipTwin = temp2; deallocate(temp2)
allocate(temp1(sum(prm%Ntwin),sum(prm%Nslip)),source =0.0_pReal)
allocate(temp2(sum(prm%Ntwin),sum(prm%Ntwin)),source =0.0_pReal)
myTwinFamilies: do f = 1_pInt,size(prm%Ntwin,1) ! >>> interaction twin -- X
index_myFamily = sum(prm%Ntwin(1:f-1_pInt))
myTwinSystems: do j = 1_pInt,prm%Ntwin(f)
slipFamilies: do o = 1_pInt,size(prm%Nslip,1)
index_otherFamily = sum(prm%Nslip(1:o-1_pInt))
slipSystems: do k = 1_pInt,prm%Nslip(o)
temp1(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_TwinSlip(lattice_interactionTwinSlip( &
sum(lattice_NtwinSystem(1:f-1_pInt,p))+j, &
sum(lattice_NslipSystem(1:o-1_pInt,p))+k, &
p),1)
enddo slipSystems; enddo slipFamilies
otherTwinFamilies: do o = 1_pInt,size(prm%Ntwin,1)
index_otherFamily = sum(prm%Ntwin(1:o-1_pInt))
otherTwinSystems: do k = 1_pInt,prm%Ntwin(o)
temp2(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_TwinTwin(lattice_interactionTwinTwin( &
sum(lattice_NtwinSystem(1:f-1_pInt,p))+j, &
sum(lattice_NtwinSystem(1:o-1_pInt,p))+k, &
p),1)
enddo otherTwinSystems; enddo otherTwinFamilies
enddo myTwinSystems
enddo myTwinFamilies
prm%interaction_TwinSlip = temp1; deallocate(temp1)
prm%interaction_TwinTwin = temp2; deallocate(temp2)
add pheno+ module in
2015-10-14 00:22:01 +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
!--------------------------------------------------------------------------------------------------
! locally defined state aliases and initialization of state0 and aTolState
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
startIndex = 1_pInt
endIndex = plasticState(p)%nSlip
state (instance)%s_slip=>plasticState(p)%state (startIndex:endIndex,:)
dotState(instance)%s_slip=>plasticState(p)%dotState(startIndex:endIndex,:)
plasticState(p)%state0(startIndex:endIndex,:) = &
spread(math_expand(prm%tau0_slip, prm%Nslip), 2, NipcMyPhase)
plasticState(p)%aTolState(startIndex:endIndex) = prm%aTolResistance
startIndex = endIndex + 1_pInt
endIndex = endIndex + plasticState(p)%nTwin
state (instance)%s_twin=>plasticState(p)%state (startIndex:endIndex,:)
dotState(instance)%s_twin=>plasticState(p)%dotState(startIndex:endIndex,:)
plasticState(p)%state0(startIndex:endIndex,:) = &
spread(math_expand(prm%tau0_twin, prm%Ntwin), 2, NipcMyPhase)
plasticState(p)%aTolState(startIndex:endIndex) = prm%aTolResistance
startIndex = endIndex + 1_pInt
endIndex = endIndex + 1_pInt
state (instance)%sumGamma=>plasticState(p)%state (startIndex,:)
dotState(instance)%sumGamma=>plasticState(p)%dotState(startIndex,:)
plasticState(p)%aTolState(startIndex:endIndex) = prm%aTolShear
startIndex = endIndex + 1_pInt
endIndex = endIndex + 1_pInt
state (instance)%sumF=>plasticState(p)%state (startIndex,:)
dotState(instance)%sumF=>plasticState(p)%dotState(startIndex,:)
plasticState(p)%aTolState(startIndex:endIndex) = prm%aTolTwinFrac
startIndex = endIndex + 1_pInt
endIndex = endIndex + plasticState(p)%nSlip
state (instance)%accshear_slip=>plasticState(p)%state (startIndex:endIndex,:)
dotState(instance)%accshear_slip=>plasticState(p)%dotState(startIndex:endIndex,:)
plasticState(p)%aTolState(startIndex:endIndex) = prm%aTolShear
! global alias
plasticState(p)%slipRate =>plasticState(p)%dotState(startIndex:endIndex,:)
plasticState(p)%accumulatedSlip =>plasticState(p)%state(startIndex:endIndex,:)
startIndex = endIndex + 1_pInt
endIndex = endIndex + plasticState(p)%nTwin
state (instance)%accshear_twin=>plasticState(p)%state (startIndex:endIndex,:)
dotState(instance)%accshear_twin=>plasticState(p)%dotState(startIndex:endIndex,:)
plasticState(p)%aTolState(startIndex:endIndex) = prm%aTolShear
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
dotState(instance)%whole =>plasticState(p)%dotState
polishing
2018-06-02 09:09:40 +05:30
using material.config values from main memory
2018-06-02 02:26:20 +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
!--------------------------------------------------------------------------------------------------
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
!> @brief calculates plastic velocity gradient and its tangent
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
!--------------------------------------------------------------------------------------------------
updated damage models: - coupling to plasticity handled within damage module instead of plasticity module - anisotropic models more stable
2015-01-29 19:26:09 +05:30
subroutine plastic_phenopowerlaw_LpAndItsTangent(Lp,dLp_dTstar99,Tstar_v,ipc,ip,el)
using dEq, dNeq, cEq, dEq
2016-05-29 14:15:03 +05:30
use prec, only: &
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
dNeq0
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
use math, only: &
math_Plain3333to99, &
prevent twin volume fraction from going above 1.0
2014-01-22 21:17:49 +05:30
math_Mandel6to33
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
use lattice, only: &
lattice_Sslip, &
lattice_Sslip_v, &
lattice_Stwin, &
lattice_Stwin_v, &
lattice_NslipSystem, &
proper error checks
2018-06-02 13:49:22 +05:30
lattice_NtwinSystem
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
use material, only: &
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
phasememberAt, &
material_phase, &
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
phase_plasticityInstance
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
implicit none
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
real(pReal), dimension(3,3), intent(out) :: &
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
Lp !< plastic velocity gradient
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
real(pReal), dimension(9,9), intent(out) :: &
added doxygen documentation and unified variable names and some common parts of the code
2013-10-08 21:57:26 +05:30
dLp_dTstar99 !< derivative of Lp with respect to 2nd Piola Kirchhoff stress
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
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
integer(pInt), intent(in) :: &
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
ipc, & !< component-ID of integration point
ip, & !< integration point
el !< element
cleaner interface for ductile damage models
2014-10-28 08:12:25 +05:30
real(pReal), dimension(6), intent(in) :: &
Tstar_v !< 2nd Piola Kirchhoff stress tensor in Mandel notation
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +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
integer(pInt) :: &
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
index_myFamily, &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
f,i,j,k,l,m,n, &
of, &
ph
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
real(pReal) :: &
tau_slip_pos,tau_slip_neg, &
gdot_slip_pos,gdot_slip_neg, &
dgdot_dtauslip_pos,dgdot_dtauslip_neg, &
gdot_twin,dgdot_dtautwin,tau_twin
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
real(pReal), dimension(3,3,3,3) :: &
dLp_dTstar3333 !< derivative of Lp with respect to Tstar as 4th order tensor
real(pReal), dimension(3,3,2) :: &
nonSchmid_tensor
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
type(tParameters), pointer :: prm
type(tPhenopowerlawState), pointer :: stt
add pheno+ module in
2015-10-14 00:22:01 +05:30
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
of = phasememberAt(ipc,ip,el)
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
ph = material_phase(ipc,ip,el)
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
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
prm => param(phase_plasticityInstance(ph))
stt => state(phase_plasticityInstance(ph))
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
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
Lp = 0.0_pReal
dLp_dTstar3333 = 0.0_pReal
comments for doxygen
2013-07-12 12:27:15 +05:30
dLp_dTstar99 = 0.0_pReal
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
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
!--------------------------------------------------------------------------------------------------
! Slip part
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
j = 0_pInt
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
slipFamilies: do f = 1_pInt,size(prm%Nslip,1)
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
index_myFamily = sum(lattice_NslipSystem(1:f-1_pInt,ph)) ! at which index starts my family
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
slipSystems: do i = 1_pInt,prm%Nslip(f)
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
j = j+1_pInt
add pheno+ module in
2015-10-14 00:22:01 +05:30
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
! Calculation of Lp
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
tau_slip_pos = dot_product(Tstar_v,lattice_Sslip_v(1:6,1,index_myFamily+i,ph))
tau_slip_neg = tau_slip_pos
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
nonSchmid_tensor(1:3,1:3,1) = lattice_Sslip(1:3,1:3,1,index_myFamily+i,ph)
nonSchmid behavior now ready to use for bcc with phenopowerlaw and nonlocal constitutive model. nonSchmid tensors according to Koester,Ma,Hartmaier,2012. extended lattice_Sslip with non-Schmid tensors (the full non-symmetric tensors are required for the tangent and cannot be retrieved from the symmetrized Mandel notation)
2013-08-05 14:53:21 +05:30
nonSchmid_tensor(1:3,1:3,2) = nonSchmid_tensor(1:3,1:3,1)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
do k = 1,size(prm%nonSchmidCoeff)
tau_slip_pos = tau_slip_pos + prm%nonSchmidCoeff(k)* &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,2*k,index_myFamily+i,ph))
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
tau_slip_neg = tau_slip_neg + prm%nonSchmidCoeff(k)* &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,2*k+1,index_myFamily+i,ph))
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
nonSchmid_tensor(1:3,1:3,1) = nonSchmid_tensor(1:3,1:3,1) + prm%nonSchmidCoeff(k)*&
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
lattice_Sslip(1:3,1:3,2*k,index_myFamily+i,ph)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
nonSchmid_tensor(1:3,1:3,2) = nonSchmid_tensor(1:3,1:3,2) + prm%nonSchmidCoeff(k)*&
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
lattice_Sslip(1:3,1:3,2*k+1,index_myFamily+i,ph)
added code structure for non-schmid mechanics. work in progress…
2013-01-22 04:41:16 +05:30
enddo
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
gdot_slip_pos = 0.5_pReal*prm%gdot0_slip* &
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
((abs(tau_slip_pos)/(stt%s_slip(j,of)))**prm%n_slip)*sign(1.0_pReal,tau_slip_pos)
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
gdot_slip_neg = 0.5_pReal*prm%gdot0_slip* &
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
((abs(tau_slip_neg)/(stt%s_slip(j,of)))**prm%n_slip)*sign(1.0_pReal,tau_slip_neg)
add pheno+ module in
2015-10-14 00:22:01 +05:30
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
Lp = Lp + (1.0_pReal-stt%sumF(of))*&
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
(gdot_slip_pos+gdot_slip_neg)*lattice_Sslip(1:3,1:3,1,index_myFamily+i,ph)
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
! Calculation of the tangent of Lp
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
if (dNeq0(gdot_slip_pos)) then !@ Philip: Needed? No division
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
dgdot_dtauslip_pos = gdot_slip_pos*prm%n_slip/tau_slip_pos
added code structure for non-schmid mechanics. work in progress…
2013-01-22 04:41:16 +05:30
forall (k=1_pInt:3_pInt,l=1_pInt:3_pInt,m=1_pInt:3_pInt,n=1_pInt:3_pInt) &
dLp_dTstar3333(k,l,m,n) = dLp_dTstar3333(k,l,m,n) + &
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
dgdot_dtauslip_pos*lattice_Sslip(k,l,1,index_myFamily+i,ph)* &
added code structure for non-schmid mechanics. work in progress…
2013-01-22 04:41:16 +05:30
nonSchmid_tensor(m,n,1)
endif
add pheno+ module in
2015-10-14 00:22:01 +05:30
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
if (dNeq0(gdot_slip_neg)) then !@ Philip: Needed? No division
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
dgdot_dtauslip_neg = gdot_slip_neg*prm%n_slip/tau_slip_neg
polishing: adding pInt, removing unused use-statements etc
2012-02-21 21:30:00 +05:30
forall (k=1_pInt:3_pInt,l=1_pInt:3_pInt,m=1_pInt:3_pInt,n=1_pInt:3_pInt) &
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
dLp_dTstar3333(k,l,m,n) = dLp_dTstar3333(k,l,m,n) + &
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
dgdot_dtauslip_neg*lattice_Sslip(k,l,1,index_myFamily+i,ph)* &
added code structure for non-schmid mechanics. work in progress…
2013-01-22 04:41:16 +05:30
nonSchmid_tensor(m,n,2)
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
endif
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo slipSystems
enddo slipFamilies
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
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
!--------------------------------------------------------------------------------------------------
! Twinning part
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
j = 0_pInt
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
twinFamilies: do f = 1_pInt,size(prm%Ntwin,1)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
index_myFamily = sum(lattice_NtwinSystem(1:f-1_pInt,ph)) ! at which index starts my family
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
twinSystems: do i = 1_pInt,prm%Ntwin(f)
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
j = j+1_pInt
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
! Calculation of Lp
add pheno+ module in
2015-10-14 00:22:01 +05:30
tau_twin = dot_product(Tstar_v,lattice_Stwin_v(1:6,index_myFamily+i,ph))
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
gdot_twin = (1.0_pReal-stt%sumF(of))*prm%gdot0_twin*&
(abs(tau_twin)/stt%s_twin(j,of))**&
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
prm%n_twin*max(0.0_pReal,sign(1.0_pReal,tau_twin))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
Lp = Lp + gdot_twin*lattice_Stwin(1:3,1:3,index_myFamily+i,ph)
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
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
! Calculation of the tangent of Lp
state pointer as shortcut, variables not used
2018-06-30 17:07:13 +05:30
if (dNeq0(gdot_twin)) then !@ Philip: Needed? No division
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
dgdot_dtautwin = gdot_twin*prm%n_twin/tau_twin
polishing: adding pInt, removing unused use-statements etc
2012-02-21 21:30:00 +05:30
forall (k=1_pInt:3_pInt,l=1_pInt:3_pInt,m=1_pInt:3_pInt,n=1_pInt:3_pInt) &
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
dLp_dTstar3333(k,l,m,n) = dLp_dTstar3333(k,l,m,n) + &
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
dgdot_dtautwin*lattice_Stwin(k,l,index_myFamily+i,ph)* &
lattice_Stwin(m,n,index_myFamily+i,ph)
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
endif
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo twinSystems
enddo twinFamilies
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
comments for doxygen
2013-07-12 12:27:15 +05:30
dLp_dTstar99 = math_Plain3333to99(dLp_dTstar3333)
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
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
!--------------------------------------------------------------------------------------------------
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
!> @brief calculates 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
!--------------------------------------------------------------------------------------------------
updated damage models: - coupling to plasticity handled within damage module instead of plasticity module - anisotropic models more stable
2015-01-29 19:26:09 +05:30
subroutine plastic_phenopowerlaw_dotState(Tstar_v,ipc,ip,el)
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
use lattice, only: &
lattice_Sslip_v, &
lattice_Stwin_v, &
lattice_maxNslipFamily, &
lattice_maxNtwinFamily, &
lattice_NslipSystem, &
lattice_NtwinSystem, &
pre-defined variables seem to work for gfortran
2018-06-25 17:36:13 +05:30
lattice_shearTwin
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
use material, only: &
material_phase, &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt, &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState, &
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
phase_plasticityInstance
add pheno+ module in
2015-10-14 00:22:01 +05:30
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
implicit none
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
real(pReal), dimension(6), intent(in) :: &
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
Tstar_v !< 2nd Piola Kirchhoff stress tensor in Mandel notation
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
integer(pInt), intent(in) :: &
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
ipc, & !< component-ID of integration point
ip, & !< integration point
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
el !< element !< microstructure state
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 doxygen documentation and unified variable names and some common parts of the code
2013-10-08 21:57:26 +05:30
integer(pInt) :: &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
instance,ph, &
added doxygen documentation and unified variable names and some common parts of the code
2013-10-08 21:57:26 +05:30
f,i,j,k, &
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
index_myFamily, &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
of
added doxygen documentation and unified variable names and some common parts of the code
2013-10-08 21:57:26 +05:30
real(pReal) :: &
sliptwin is not used and will not be used as discussed in the documentation in private
2015-05-06 01:47:50 +05:30
c_SlipSlip,c_TwinSlip,c_TwinTwin, &
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
ssat_offset, &
tau_slip_pos,tau_slip_neg,tau_twin
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
using material.config values from main memory
2018-06-02 02:26:20 +05:30
real(pReal), dimension(plasticState(material_phase(ipc,ip,el))%Nslip) :: &
don't complicate code with potential enhancements
2018-06-27 13:39:19 +05:30
gdot_slip,left_SlipSlip,right_SlipSlip
using material.config values from main memory
2018-06-02 02:26:20 +05:30
real(pReal), dimension(plasticState(material_phase(ipc,ip,el))%Ntwin) :: &
don't complicate code with potential enhancements
2018-06-27 13:39:19 +05:30
gdot_twin
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
type(tParameters), pointer :: prm
type(tPhenopowerlawState), pointer :: stt
add pheno+ module in
2015-10-14 00:22:01 +05:30
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
of = phasememberAt(ipc,ip,el)
ph = phaseAt(ipc,ip,el)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
instance = phase_plasticityInstance(ph)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
prm => param(instance)
stt => state(instance)
add pheno+ module in
2015-10-14 00:22:01 +05:30
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
remved bug in phenopower law state initialization and a minor change in Makefile
2014-07-07 19:51:58 +05:30
plasticState(ph)%dotState(:,of) = 0.0_pReal
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
further simplified
2018-06-27 13:49:50 +05:30
c_SlipSlip = prm%h0_slipslip * (1.0_pReal + prm%twinC*stt%sumF(of)** prm%twinB)
c_TwinSlip = prm%h0_TwinSlip * stt%sumGamma(of)**prm%twinE
c_TwinTwin = prm%h0_TwinTwin * stt%sumF(of)**prm%twinD
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +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
!--------------------------------------------------------------------------------------------------
! calculate left and right vectors and calculate dot gammas
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
ssat_offset = prm%spr*sqrt(stt%sumF(of))
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
j = 0_pInt
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
slipFamilies1: do f =1_pInt,size(prm%Nslip,1)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
index_myFamily = sum(lattice_NslipSystem(1:f-1_pInt,ph)) ! at which index starts my family
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
slipSystems1: do i = 1_pInt,prm%Nslip(f)
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
j = j+1_pInt
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
left_SlipSlip(j) = 1.0_pReal + prm%H_int(f) ! modified no system-dependent left part
right_SlipSlip(j) = abs(1.0_pReal-stt%s_slip(j,of) / &
(prm%tausat_slip(f)+ssat_offset)) &
**prm%a_slip&
*sign(1.0_pReal,1.0_pReal-stt%s_slip(j,of) / &
(prm%tausat_slip(f)+ssat_offset))
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
!--------------------------------------------------------------------------------------------------
add pheno+ module in
2015-10-14 00:22:01 +05:30
! Calculation of dot gamma
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
tau_slip_pos = dot_product(Tstar_v,lattice_Sslip_v(1:6,1,index_myFamily+i,ph))
tau_slip_neg = tau_slip_pos
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
nonSchmidSystems: do k = 1,size(prm%nonSchmidCoeff)
tau_slip_pos = tau_slip_pos + prm%nonSchmidCoeff(k)* &
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,2*k, index_myFamily+i,ph))
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
tau_slip_neg = tau_slip_neg +prm%nonSchmidCoeff(k)* &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,2*k+1,index_myFamily+i,ph))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo nonSchmidSystems
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
gdot_slip(j) = prm%gdot0_slip*0.5_pReal* &
( (abs(tau_slip_pos)/(stt%s_slip(j,of)))**prm%n_slip*sign(1.0_pReal,tau_slip_pos) &
+(abs(tau_slip_neg)/(stt%s_slip(j,of)))**prm%n_slip*sign(1.0_pReal,tau_slip_neg))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo slipSystems1
enddo slipFamilies1
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
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
introduced H_int for family--wise assignment of initial hardening rate.
2016-05-12 00:23:05 +05:30
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
j = 0_pInt
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
twinFamilies1: do f = 1_pInt,size(prm%Ntwin,1)
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
index_myFamily = sum(lattice_NtwinSystem(1:f-1_pInt,ph)) ! at which index starts my family
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
twinSystems1: do i = 1_pInt,prm%Ntwin(f)
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
j = j+1_pInt
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
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
!--------------------------------------------------------------------------------------------------
! Calculation of dot vol frac
add pheno+ module in
2015-10-14 00:22:01 +05:30
tau_twin = dot_product(Tstar_v,lattice_Stwin_v(1:6,index_myFamily+i,ph))
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
gdot_twin(j) = (1.0_pReal-stt%sumF(of))*& ! 1-F
prm%gdot0_twin*&
(abs(tau_twin)/stt%s_twin(j,of))**&
prm%n_twin*max(0.0_pReal,sign(1.0_pReal,tau_twin))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo twinSystems1
enddo twinFamilies1
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
!--------------------------------------------------------------------------------------------------
! calculate the overall hardening based on above
further simplified
2018-06-27 13:49:50 +05:30
do j = 1_pInt,prm%totalNslip
dotState(instance)%s_slip(j,of) = c_SlipSlip * left_SlipSlip(j) * & ! evolution of slip resistance j
dot_product(prm%interaction_SlipSlip(j,1:prm%totalNslip),right_SlipSlip*abs(gdot_slip)) + & ! dot gamma_slip modulated by right-side slip factor
dot_product(prm%interaction_SlipTwin(j,1:prm%totalNtwin),gdot_twin) ! dot gamma_twin modulated by right-side twin factor
enddo
dotState(instance)%sumGamma(of) = dotState(instance)%sumGamma(of) + sum(abs(gdot_slip))
dotState(instance)%accshear_slip(1:prm%totalNslip,of) = abs(gdot_slip)
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
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
j = 0_pInt
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
twinFamilies2: do f = 1_pInt,size(prm%Ntwin,1)
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
index_myFamily = sum(lattice_NtwinSystem(1:f-1_pInt,ph)) ! at which index starts my family
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
twinSystems2: do i = 1_pInt,prm%Ntwin(f)
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
j = j+1_pInt
don't complicate code with potential enhancements
2018-06-27 13:39:19 +05:30
dotState(instance)%s_twin(j,of) = & ! evolution of twin resistance j
c_TwinSlip * dot_product(prm%interaction_TwinSlip(j,1:prm%totalNslip),abs(gdot_slip)) + & ! dot gamma_slip modulated by right-side slip factor
c_TwinTwin * dot_product(prm%interaction_TwinTwin(j,1:prm%totalNtwin),gdot_twin) ! dot gamma_twin modulated by right-side twin factor
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
if (state(instance)%sumF(of) < 0.98_pReal) & ! ensure twin volume fractions stays below 1.0
dotState(instance)%sumF(of) = dotState(instance)%sumF(of) + &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
gdot_twin(j)/lattice_shearTwin(index_myFamily+i,ph)
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
dotState(instance)%accshear_twin(j,of) = abs(gdot_twin(j))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo twinSystems2
enddo twinFamilies2
remved bug in phenopower law state initialization and a minor change in Makefile
2014-07-07 19:51:58 +05:30
add pheno+ module in
2015-10-14 00:22:01 +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
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
!--------------------------------------------------------------------------------------------------
!> @brief return array of constitutive results
!--------------------------------------------------------------------------------------------------
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
function plastic_phenopowerlaw_postResults(Tstar_v,ipc,ip,el)
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
use material, only: &
material_phase, &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState, &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt, &
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
phase_plasticityInstance
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
use lattice, only: &
lattice_Sslip_v, &
lattice_Stwin_v, &
lattice_maxNslipFamily, &
lattice_maxNtwinFamily, &
lattice_NslipSystem, &
nonSchmid behavior now ready to use for bcc with phenopowerlaw and nonlocal constitutive model. nonSchmid tensors according to Koester,Ma,Hartmaier,2012. extended lattice_Sslip with non-Schmid tensors (the full non-symmetric tensors are required for the tangent and cannot be retrieved from the symmetrized Mandel notation)
2013-08-05 14:53:21 +05:30
lattice_NtwinSystem, &
add pheno+ module in
2015-10-14 00:22:01 +05:30
lattice_NnonSchmid
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
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
implicit none
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
real(pReal), dimension(6), intent(in) :: &
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
Tstar_v !< 2nd Piola Kirchhoff stress tensor in Mandel notation
changed state parsing for local models (and for delta_state) such that only the needed part of the state array (for the given material point) is used
2014-03-13 12:13:49 +05:30
integer(pInt), intent(in) :: &
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
ipc, & !< component-ID of integration point
ip, & !< integration point
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
el !< element !< microstructure state
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
using material.config values from main memory
2018-06-02 02:26:20 +05:30
real(pReal), dimension(plasticState(material_phase(ipc,ip,el))%sizePostResults) :: &
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
plastic_phenopowerlaw_postResults
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
integer(pInt) :: &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
instance,ph, of, &
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
o,f,i,c,j,k, &
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
index_myFamily
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
real(pReal) :: &
tau_slip_pos,tau_slip_neg,tau
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
type(tParameters), pointer :: prm
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
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
of = phasememberAt(ipc,ip,el)
ph = phaseAt(ipc,ip,el)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
instance = phase_plasticityInstance(ph)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
prm => param(instance)
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
using material.config values from main memory
2018-06-02 02:26:20 +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
plastic_phenopowerlaw_postResults = 0.0_pReal
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
c = 0_pInt
further simplified
2018-06-27 13:49:50 +05:30
outputsLoop: do o = 1_pInt,size(prm%outputID)
select case(prm%outputID(o))
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (resistance_slip_ID)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt:c+prm%totalNslip) = state(instance)%s_slip(1:prm%totalNslip,of)
c = c + prm%totalNslip
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 ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (accumulatedshear_slip_ID)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt:c+prm%totalNslip) = state(instance)%accshear_slip(1:prm%totalNslip,of)
c = c + prm%totalNslip
added output capabilities for accumulated shears on slip and twin systems.
2013-02-06 23:39:11 +05:30
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (shearrate_slip_ID)
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
j = 0_pInt
further simplified
2018-06-27 13:49:50 +05:30
slipFamilies1: do f = 1_pInt,size(prm%Nslip,1)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
index_myFamily = sum(lattice_NslipSystem(1:f-1_pInt,ph)) ! at which index starts my family
further simplified
2018-06-27 13:49:50 +05:30
slipSystems1: do i = 1_pInt,prm%Nslip(f)
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
j = j + 1_pInt
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
tau_slip_pos = dot_product(Tstar_v,lattice_Sslip_v(1:6,1,index_myFamily+i,ph))
added code structure for non-schmid mechanics. work in progress…
2013-01-22 04:41:16 +05:30
tau_slip_neg = tau_slip_pos
add pheno+ module in
2015-10-14 00:22:01 +05:30
do k = 1,lattice_NnonSchmid(ph)
further simplified
2018-06-27 13:49:50 +05:30
tau_slip_pos = tau_slip_pos +prm%nonSchmidCoeff(k)* &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,2*k,index_myFamily+i,ph))
further simplified
2018-06-27 13:49:50 +05:30
tau_slip_neg = tau_slip_neg +prm%nonSchmidCoeff(k)* &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,2*k+1,index_myFamily+i,ph))
added code structure for non-schmid mechanics. work in progress…
2013-01-22 04:41:16 +05:30
enddo
further simplified
2018-06-27 13:49:50 +05:30
plastic_phenopowerlaw_postResults(c+j) = prm%gdot0_slip*0.5_pReal* &
((abs(tau_slip_pos)/state(instance)%s_slip(j,of))**prm%n_slip &
now also corrected calculation of gamma_dot in postresults
2016-07-18 16:33:23 +05:30
*sign(1.0_pReal,tau_slip_pos) &
further simplified
2018-06-27 13:49:50 +05:30
+(abs(tau_slip_neg)/(state(instance)%s_slip(j,of)))**prm%n_slip &
now also corrected calculation of gamma_dot in postresults
2016-07-18 16:33:23 +05:30
*sign(1.0_pReal,tau_slip_neg))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo slipSystems1
enddo slipFamilies1
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
c = c + prm%totalNslip
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 ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (resolvedstress_slip_ID)
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
j = 0_pInt
further simplified
2018-06-27 13:49:50 +05:30
slipFamilies2: do f = 1_pInt,size(prm%Nslip,1)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
index_myFamily = sum(lattice_NslipSystem(1:f-1_pInt,ph)) ! at which index starts my family
further simplified
2018-06-27 13:49:50 +05:30
slipSystems2: do i = 1_pInt,prm%Nslip(f)
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
j = j + 1_pInt
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
plastic_phenopowerlaw_postResults(c+j) = &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Sslip_v(1:6,1,index_myFamily+i,ph))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo slipSystems2
enddo slipFamilies2
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
c = c + prm%totalNslip
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 ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (totalshear_ID)
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
plastic_phenopowerlaw_postResults(c+1_pInt) = &
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
state(instance)%sumGamma(of)
polishing: adding pInt, removing unused use-statements etc
2012-02-21 21:30:00 +05:30
c = c + 1_pInt
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 ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (resistance_twin_ID)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt:c+prm%totalNtwin) = &
state(instance)%s_twin(1:prm%totalNtwin,of)
c = c + prm%totalNtwin
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
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (accumulatedshear_twin_ID)
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt:c+prm%totalNtwin) = &
state(instance)%accshear_twin(1:prm%totalNtwin,of)
c = c + prm%totalNtwin
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (shearrate_twin_ID)
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
j = 0_pInt
further simplified
2018-06-27 13:49:50 +05:30
twinFamilies1: do f = 1_pInt,size(prm%Ntwin,1)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
index_myFamily = sum(lattice_NtwinSystem(1:f-1_pInt,ph)) ! at which index starts my family
further simplified
2018-06-27 13:49:50 +05:30
twinSystems1: do i = 1_pInt,prm%Ntwin(f)
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
j = j + 1_pInt
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
tau = dot_product(Tstar_v,lattice_Stwin_v(1:6,index_myFamily+i,ph))
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
plastic_phenopowerlaw_postResults(c+j) = (1.0_pReal-state(instance)%sumF(of))*& ! 1-F
further simplified
2018-06-27 13:49:50 +05:30
prm%gdot0_twin*&
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
(abs(tau)/state(instance)%s_twin(j,of))**&
further simplified
2018-06-27 13:49:50 +05:30
prm%n_twin*max(0.0_pReal,sign(1.0_pReal,tau))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo twinSystems1
enddo twinFamilies1
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
c = c + prm%totalNtwin
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 ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (resolvedstress_twin_ID)
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
j = 0_pInt
further simplified
2018-06-27 13:49:50 +05:30
twinFamilies2: do f = 1_pInt,size(prm%Ntwin,1)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
index_myFamily = sum(lattice_NtwinSystem(1:f-1_pInt,ph)) ! at which index starts my family
further simplified
2018-06-27 13:49:50 +05:30
twinSystems2: do i = 1_pInt,prm%Ntwin(f)
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
j = j + 1_pInt
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
plastic_phenopowerlaw_postResults(c+j) = &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dot_product(Tstar_v,lattice_Stwin_v(1:6,index_myFamily+i,ph))
removed imported module variables that are not longer needed, commented loops and simplified calculation for rates, i.e. do not store per system anymore but only once
2014-11-06 13:57:48 +05:30
enddo twinSystems2
enddo twinFamilies2
following ideas implemented by Philip in disloUCLA prm and stt are pointers to instance of parameter and state interaction_xxYY is a matrix, gets shape assigned during calculation totalNslip and totalNslip are defined as derived parameter
2018-06-27 13:31:36 +05:30
c = c + prm%totalNtwin
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
Read in TRIP inputs, changed 'totalvolfrac' to 'totalvolfrac_twin'
2014-11-21 14:24:20 +05:30
case (totalvolfrac_twin_ID)
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt) = state(instance)%sumF(of)
polishing: adding pInt, removing unused use-statements etc
2012-02-21 21:30:00 +05:30
c = c + 1_pInt
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
end select
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
enddo outputsLoop
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 function plastic_phenopowerlaw_postResults
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 module plastic_phenopowerlaw