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

902 lines
45 KiB
Fortran
Raw Normal View History

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
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, &
H_int, & !< per family hardening activity (optional)
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
real(pReal), dimension(:,:), allocatable :: &
matrix_SlipSlip, & !< slip resistance from slip activity
matrix_SlipTwin, & !< slip resistance from twin activity
matrix_TwinSlip, & !< twin resistance from slip activity
matrix_TwinTwin !< twin resistance from twin activity
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, &
accshear_twin
real(pReal), pointer, dimension(:) :: &
sumGamma, &
sumF
end type
type(tPhenopowerlawState), allocatable, dimension(:), private :: &
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, &
phaseConfig
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, &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
instance,phase,j,k, f,o, i,&
NipcMyPhase, outputSize, &
Making use of extended plastic state with pointers, removed helper functions.
2015-01-05 00:56:33 +05:30
offset_slip, 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
using material.config values from main memory
2018-06-02 02:26:20 +05:30
integer(pInt), dimension(0), parameter :: emptyInt = [integer(pInt)::]
polishing
2018-06-02 09:09:40 +05:30
real(pReal), dimension(0), parameter :: emptyReal = [real(pReal)::]
pre-defined variables seem to work for gfortran
2018-06-25 17:36:13 +05:30
character(len=65536), dimension(0), parameter :: emptyString = [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
using material.config values from main memory
2018-06-02 02:26:20 +05:30
do phase = 1_pInt, size(phase_plasticityInstance)
if (phase_plasticity(phase) == PLASTICITY_PHENOPOWERLAW_ID) then
WIP: separate reading in and parsing
2018-05-31 22:01:44 +05:30
instance = phase_plasticityInstance(phase)
using config module
2018-06-19 23:13:41 +05:30
prm => param(instance)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
using config module
2018-06-19 23:13:41 +05:30
prm%Nslip = phaseConfig(phase)%getInts('nslip',defaultVal=emptyInt)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
!if (size > Nchunks_SlipFamilies + 1_pInt) call IO_error(150_pInt,ext_msg=extmsg)
using config module
2018-06-19 23:13:41 +05:30
if (sum(prm%Nslip) > 0_pInt) then
prm%tau0_slip = phaseConfig(phase)%getFloats('tau0_slip')
prm%tausat_slip = phaseConfig(phase)%getFloats('tausat_slip')
prm%interaction_SlipSlip = phaseConfig(phase)%getFloats('interaction_slipslip')
prm%H_int = phaseConfig(phase)%getFloats('h_int',&
defaultVal=[(0.0_pReal,i=1_pInt,size(prm%Nslip))])
prm%nonSchmidCoeff = phaseConfig(phase)%getFloats('nonschmid_coefficients',&
pre-defined variables seem to work for gfortran
2018-06-25 17:36:13 +05:30
defaultVal = emptyReal )
polishing
2018-06-02 09:09:40 +05:30
using config module
2018-06-19 23:13:41 +05:30
prm%gdot0_slip = phaseConfig(phase)%getFloat('gdot0_slip')
prm%n_slip = phaseConfig(phase)%getFloat('n_slip')
prm%a_slip = phaseConfig(phase)%getFloat('a_slip')
prm%h0_SlipSlip = phaseConfig(phase)%getFloat('h0_slipslip')
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endif
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
prm%Ntwin = phaseConfig(phase)%getInts('ntwin', defaultVal=emptyInt)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
!if (size > Nchunks_SlipFamilies + 1_pInt) call IO_error(150_pInt,ext_msg=extmsg)
using config module
2018-06-19 23:13:41 +05:30
if (sum(prm%Ntwin) > 0_pInt) then
prm%tau0_twin = phaseConfig(phase)%getFloats('tau0_twin')
prm%interaction_TwinTwin = phaseConfig(phase)%getFloats('interaction_twintwin')
prm%gdot0_twin = phaseConfig(phase)%getFloat('gdot0_twin')
prm%n_twin = phaseConfig(phase)%getFloat('n_twin')
prm%spr = phaseConfig(phase)%getFloat('s_pr')
prm%twinB = phaseConfig(phase)%getFloat('twin_b')
prm%twinC = phaseConfig(phase)%getFloat('twin_c')
prm%twinD = phaseConfig(phase)%getFloat('twin_d')
prm%twinE = phaseConfig(phase)%getFloat('twin_e')
prm%h0_TwinTwin = phaseConfig(phase)%getFloat('h0_twintwin')
polishing
2018-06-02 09:09:40 +05:30
endif
using config module
2018-06-19 23:13:41 +05:30
if (sum(prm%Nslip) > 0_pInt .and. sum(prm%Ntwin) > 0_pInt) then
prm%interaction_SlipTwin = phaseConfig(phase)%getFloats('interaction_sliptwin')
prm%interaction_TwinSlip = phaseConfig(phase)%getFloats('interaction_twinslip')
prm%h0_TwinSlip = phaseConfig(phase)%getFloat('h0_twinslip')
using material.config values from main memory
2018-06-02 02:26:20 +05:30
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
using config module
2018-06-19 23:13:41 +05:30
allocate(prm%matrix_SlipSlip(sum(prm%Nslip),sum(prm%Nslip)),source =0.0_pReal)
allocate(prm%matrix_SlipTwin(sum(prm%Nslip),sum(prm%Ntwin)),source =0.0_pReal)
allocate(prm%matrix_TwinSlip(sum(prm%Ntwin),sum(prm%Nslip)),source =0.0_pReal)
allocate(prm%matrix_TwinTwin(sum(prm%Ntwin),sum(prm%Ntwin)),source =0.0_pReal)
polishing
2018-06-02 09:09:40 +05:30
using config module
2018-06-19 23:13:41 +05:30
prm%aTolResistance = phaseConfig(phase)%getFloat('atol_resistance',defaultVal=1.0_pReal)
prm%aTolShear = phaseConfig(phase)%getFloat('atol_shear',defaultVal=1.0e-6_pReal)
prm%aTolTwinfrac = phaseConfig(phase)%getFloat('atol_twinfrac',defaultVal=1.0e-6_pReal)
polishing
2018-06-02 09:09:40 +05:30
pre-defined variables seem to work for gfortran
2018-06-25 17:36:13 +05:30
outputs = phaseConfig(phase)%getStrings('(output)',defaultVal=emptyString)
using config module
2018-06-19 23:13:41 +05:30
allocate(prm%outputID(0))
using material.config values from main memory
2018-06-02 02:26:20 +05:30
do i=1_pInt, size(outputs)
outputID = undefined_ID
select case(outputs(i))
case ('resistance_slip')
outputID = resistance_slip_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Nslip)
fixed typo and removed alias
2018-06-25 14:03:22 +05:30
case ('accumulatedshear_slip')
using material.config values from main memory
2018-06-02 02:26:20 +05:30
outputID = accumulatedshear_slip_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Nslip)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
case ('shearrate_slip')
outputID = shearrate_slip_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Nslip)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
case ('resolvedstress_slip')
outputID = resolvedstress_slip_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Nslip)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
case ('resistance_twin')
outputID = resistance_twin_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Ntwin)
fixed typo and removed alias
2018-06-25 14:03:22 +05:30
case ('accumulatedshear_twin')
using material.config values from main memory
2018-06-02 02:26:20 +05:30
outputID = accumulatedshear_twin_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Ntwin)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
case ('shearrate_twin')
outputID = shearrate_twin_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Ntwin)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
case ('resolvedstress_twin')
outputID = resolvedstress_twin_ID
using config module
2018-06-19 23:13:41 +05:30
outputSize = sum(prm%Ntwin)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
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
using config module
2018-06-19 23:13:41 +05:30
prm%outputID = [prm%outputID , outputID]
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endif
proper error checks
2018-06-02 13:49:22 +05:30
end do
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
extmsg = ''
using config module
2018-06-19 23:13:41 +05:30
if (sum(prm%Nslip) > 0_pInt) then
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
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//')')
proper error checks
2018-06-02 13:49:22 +05:30
using config module
2018-06-19 23:13:41 +05:30
if (any(prm%tau0_slip < 0.0_pReal .and. prm%Nslip > 0_pInt)) &
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
extmsg = trim(extmsg)//"tau0_slip "
using config module
2018-06-19 23:13:41 +05:30
if (any(prm%tausat_slip < prm%tau0_slip .and. prm%Nslip > 0_pInt)) &
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
extmsg = trim(extmsg)//"tausat_slip "
proper error checks
2018-06-02 13:49:22 +05:30
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
if (prm%gdot0_slip <= 0.0_pReal) extmsg = trim(extmsg)//" gdot0_slip "
using config module
2018-06-19 23:13:41 +05:30
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?
proper error checks
2018-06-02 13:49:22 +05:30
endif
using config module
2018-06-19 23:13:41 +05:30
if (sum(prm%Ntwin) > 0_pInt) then
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
if (size(prm%tau0_twin) /= size(prm%ntwin)) call IO_error(211_pInt,ip=instance,&
ext_msg='shape(tau0_twin) ('//PLASTICITY_PHENOPOWERLAW_label//')')
proper error checks
2018-06-02 13:49:22 +05:30
using config module
2018-06-19 23:13:41 +05:30
if (any(prm%tau0_twin < 0.0_pReal .and. prm%Ntwin > 0_pInt)) &
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
extmsg = trim(extmsg)//"tau0_twin "
proper error checks
2018-06-02 13:49:22 +05:30
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
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?
proper error checks
2018-06-02 13:49:22 +05:30
endif
exit immediately if array size does not match Nslip/Ntwin otherwise, array acces out of bounds might happen for subsequent sanity checks
2018-06-23 18:18:32 +05:30
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
proper error checks
2018-06-02 13:49:22 +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
polishing
2018-06-02 09:09:40 +05:30
NipcMyPhase = count(material_phase == phase) ! number of IPCs containing my phase
using config module
2018-06-19 23:13:41 +05:30
sizeState = size(['tau_slip ','accshear_slip']) * sum(prm%nslip) &
+ size(['tau_twin ','accshear_twin']) * sum(prm%ntwin) &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
+ size(['sum(gamma)', 'sum(f) '])
add pheno+ module in
2015-10-14 00:22:01 +05:30
fixed previous incomplete commit and few other trivial changes in newstate
2014-06-11 22:22:18 +05:30
sizeDotState = sizeState
removed some redundant parts
2014-07-08 20:28:23 +05:30
plasticState(phase)%sizeState = sizeState
plasticState(phase)%sizeDotState = sizeDotState
using default value for when getting strings, setting correct size for post results
2018-06-22 02:44:30 +05:30
plasticState(phase)%sizePostResults = sum(plastic_phenopowerlaw_sizePostResult(:,instance))
using config module
2018-06-19 23:13:41 +05:30
plasticState(phase)%nSlip = sum(prm%Nslip)
plasticState(phase)%nTwin = sum(prm%Ntwin)
improved commenting and variable names. values for unused slip/twin families are ignored in material.config (do not need to be numeric anymore…)
2014-11-27 02:53:02 +05:30
allocate(plasticState(phase)%aTolState ( sizeState), source=0.0_pReal)
allocate(plasticState(phase)%state0 ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(phase)%partionedState0 ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(phase)%subState0 ( sizeState,NipcMyPhase), source=0.0_pReal)
allocate(plasticState(phase)%state ( sizeState,NipcMyPhase), source=0.0_pReal)
polishing
2018-06-02 09:09:40 +05:30
improved commenting and variable names. values for unused slip/twin families are ignored in material.config (do not need to be numeric anymore…)
2014-11-27 02:53:02 +05:30
allocate(plasticState(phase)%dotState (sizeDotState,NipcMyPhase), source=0.0_pReal)
polishing
2018-06-02 09:09:40 +05:30
allocate(plasticState(phase)%deltaState (0_pInt,NipcMyPhase), source=0.0_pReal)
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
if (any(numerics_integrator == 1_pInt)) then
improved commenting and variable names. values for unused slip/twin families are ignored in material.config (do not need to be numeric anymore…)
2014-11-27 02:53:02 +05:30
allocate(plasticState(phase)%previousDotState (sizeDotState,NipcMyPhase),source=0.0_pReal)
allocate(plasticState(phase)%previousDotState2(sizeDotState,NipcMyPhase),source=0.0_pReal)
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
endif
if (any(numerics_integrator == 4_pInt)) &
improved commenting and variable names. values for unused slip/twin families are ignored in material.config (do not need to be numeric anymore…)
2014-11-27 02:53:02 +05:30
allocate(plasticState(phase)%RK4dotState (sizeDotState,NipcMyPhase), source=0.0_pReal)
improved on new state, fixed wrong indices in output
2014-05-22 20:46:05 +05:30
if (any(numerics_integrator == 5_pInt)) &
improved commenting and variable names. values for unused slip/twin families are ignored in material.config (do not need to be numeric anymore…)
2014-11-27 02:53:02 +05:30
allocate(plasticState(phase)%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
using config module
2018-06-19 23:13:41 +05:30
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)
prm%matrix_SlipSlip(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_SlipSlip(lattice_interactionSlipSlip( &
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
sum(lattice_NslipSystem(1:f-1,phase))+j, &
sum(lattice_NslipSystem(1:o-1,phase))+k, &
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
phase))
enddo otherSlipSystems; enddo otherSlipFamilies
using config module
2018-06-19 23:13:41 +05:30
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)
prm%matrix_SlipTwin(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_SlipTwin(lattice_interactionSlipTwin( &
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
sum(lattice_NslipSystem(1:f-1_pInt,phase))+j, &
sum(lattice_NtwinSystem(1:o-1_pInt,phase))+k, &
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
phase))
enddo twinSystems; enddo twinFamilies
enddo mySlipSystems
enddo mySlipFamilies
using config module
2018-06-19 23:13:41 +05:30
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)
prm%matrix_TwinSlip(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_TwinSlip(lattice_interactionTwinSlip( &
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
sum(lattice_NtwinSystem(1:f-1_pInt,phase))+j, &
sum(lattice_NslipSystem(1:o-1_pInt,phase))+k, &
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
phase))
enddo slipSystems; enddo slipFamilies
using config module
2018-06-19 23:13:41 +05:30
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)
prm%matrix_TwinTwin(index_myFamily+j,index_otherFamily+k) = &
prm%interaction_TwinTwin(lattice_interactionTwinTwin( &
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
sum(lattice_NtwinSystem(1:f-1_pInt,phase))+j, &
sum(lattice_NtwinSystem(1:o-1_pInt,phase))+k, &
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
phase))
enddo otherTwinSystems; enddo otherTwinFamilies
enddo myTwinSystems
enddo myTwinFamilies
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
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 = 1_pInt
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endIndex = plasticState(phase)%nSlip
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
state (instance)%s_slip=>plasticState(phase)%state (startIndex:endIndex,:)
dotState(instance)%s_slip=>plasticState(phase)%dotState(startIndex:endIndex,:)
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
plasticState(phase)%state0(startIndex:endIndex,:) = &
using config module
2018-06-19 23:13:41 +05:30
spread(math_expand(prm%tau0_slip, prm%Nslip), 2, NipcMyPhase)
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 config module
2018-06-19 23:13:41 +05:30
plasticState(phase)%aTolState(startIndex:endIndex) = prm%aTolResistance
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 + 1_pInt
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endIndex = endIndex + plasticState(phase)%nTwin
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
state (instance)%s_twin=>plasticState(phase)%state (startIndex:endIndex,:)
dotState(instance)%s_twin=>plasticState(phase)%dotState(startIndex:endIndex,:)
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
plasticState(phase)%state0(startIndex:endIndex,:) = &
using config module
2018-06-19 23:13:41 +05:30
spread(math_expand(prm%tau0_twin, prm%Ntwin), 2, NipcMyPhase)
plasticState(phase)%aTolState(startIndex:endIndex) = prm%aTolResistance
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 + 1_pInt
endIndex = endIndex + 1_pInt
state (instance)%sumGamma=>plasticState(phase)%state (startIndex,:)
dotState(instance)%sumGamma=>plasticState(phase)%dotState(startIndex,:)
using config module
2018-06-19 23:13:41 +05:30
plasticState(phase)%aTolState(startIndex:endIndex) = prm%aTolShear
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 + 1_pInt
endIndex = endIndex + 1_pInt
state (instance)%sumF=>plasticState(phase)%state (startIndex,:)
dotState(instance)%sumF=>plasticState(phase)%dotState(startIndex,:)
using config module
2018-06-19 23:13:41 +05:30
plasticState(phase)%aTolState(startIndex:endIndex) = prm%aTolTwinFrac
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 + 1_pInt
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endIndex = endIndex + plasticState(phase)%nSlip
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
state (instance)%accshear_slip=>plasticState(phase)%state (startIndex:endIndex,:)
dotState(instance)%accshear_slip=>plasticState(phase)%dotState(startIndex:endIndex,:)
using config module
2018-06-19 23:13:41 +05:30
plasticState(phase)%aTolState(startIndex:endIndex) = prm%aTolShear
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
! global alias
plasticState(phase)%slipRate =>plasticState(phase)%dotState(startIndex:endIndex,:)
plasticState(phase)%accumulatedSlip =>plasticState(phase)%state(startIndex:endIndex,:)
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 + 1_pInt
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endIndex = endIndex + plasticState(phase)%nTwin
wrong pointer alias (no harm caused so far)
2016-05-19 16:31:13 +05:30
state (instance)%accshear_twin=>plasticState(phase)%state (startIndex:endIndex,:)
dotState(instance)%accshear_twin=>plasticState(phase)%dotState(startIndex:endIndex,:)
using config module
2018-06-19 23:13:41 +05:30
plasticState(phase)%aTolState(startIndex:endIndex) = prm%aTolShear
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
polishing
2018-06-02 09:09:40 +05:30
offset_slip = plasticState(phase)%nSlip+plasticState(phase)%nTwin+2_pInt
plasticState(phase)%slipRate => &
plasticState(phase)%dotState(offset_slip+1:offset_slip+plasticState(phase)%nSlip,1:NipcMyPhase)
plasticState(phase)%accumulatedSlip => &
plasticState(phase)%state(offset_slip+1:offset_slip+plasticState(phase)%nSlip,1:NipcMyPhase)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
endif
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_maxNslipFamily, &
lattice_maxNtwinFamily, &
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: &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt, &
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) :: &
add pheno+ module in
2015-10-14 00:22:01 +05:30
instance, &
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
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)
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
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
slipFamilies: do f = 1_pInt,size(param(instance)%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
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
slipSystems: do i = 1_pInt,param(instance)%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)
using material.config values from main memory
2018-06-02 02:26:20 +05:30
do k = 1,size(param(instance)%nonSchmidCoeff)
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
tau_slip_pos = tau_slip_pos + param(instance)%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))
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
tau_slip_neg = tau_slip_neg + param(instance)%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))
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
nonSchmid_tensor(1:3,1:3,1) = nonSchmid_tensor(1:3,1:3,1) + param(instance)%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)
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
nonSchmid_tensor(1:3,1:3,2) = nonSchmid_tensor(1:3,1:3,2) + param(instance)%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
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
gdot_slip_pos = 0.5_pReal*param(instance)%gdot0_slip* &
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
((abs(tau_slip_pos)/(state(instance)%s_slip(j,of))) &
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
**param(instance)%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
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
gdot_slip_neg = 0.5_pReal*param(instance)%gdot0_slip* &
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
((abs(tau_slip_neg)/(state(instance)%s_slip(j,of))) &
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
**param(instance)%n_slip)*sign(1.0_pReal,tau_slip_neg)
add pheno+ module in
2015-10-14 00:22:01 +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
Lp = Lp + (1.0_pReal-state(instance)%sumF(of))*& ! 1-F
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
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
if (dNeq0(gdot_slip_pos)) then
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
dgdot_dtauslip_pos = gdot_slip_pos*param(instance)%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
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
if (dNeq0(gdot_slip_neg)) then
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
dgdot_dtauslip_neg = gdot_slip_neg*param(instance)%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
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
twinFamilies: do f = 1_pInt,size(param(instance)%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
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
twinSystems: do i = 1_pInt,param(instance)%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))
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
gdot_twin = (1.0_pReal-state(instance)%sumF(of))*& ! 1-F
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%gdot0_twin*&
started to introduce alias name via pointer for plastic state in phenopowerlaw for more comfortable access
2015-10-30 21:18:30 +05:30
(abs(tau_twin)/state(instance)%s_twin(j,of))**&
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%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
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
if (dNeq0(gdot_twin)) then
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
dgdot_dtautwin = gdot_twin*param(instance)%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, &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
index_myFamily, nslip,ntwin,&
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) :: &
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,left_SlipSlip,left_SlipTwin,right_SlipSlip,right_TwinSlip
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) :: &
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_twin,left_TwinSlip,left_TwinTwin,right_SlipTwin,right_TwinTwin
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)
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
nSlip= sum(param(instance)%nslip)
nTwin= sum(param(instance)%nTwin)
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
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
c_SlipSlip = param(instance)%h0_slipslip*&
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
(1.0_pReal + param(instance)%twinC*state(instance)%sumF(of)**&
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%twinB)
c_TwinSlip = param(instance)%h0_TwinSlip*&
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
state(instance)%sumGamma(of)**param(instance)%twinE
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
c_TwinTwin = param(instance)%h0_TwinTwin*&
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
state(instance)%sumF(of)**param(instance)%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
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
ssat_offset = param(instance)%spr*sqrt(state(instance)%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
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
slipFamilies1: do f =1_pInt,size(param(instance)%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
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
slipSystems1: do i = 1_pInt,param(instance)%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
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
left_SlipSlip(j) = 1.0_pReal + param(instance)%H_int(f) ! modified no system-dependent left part
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
left_SlipTwin(j) = 1.0_pReal ! no system-dependent left part
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
right_SlipSlip(j) = abs(1.0_pReal-state(instance)%s_slip(j,of) / &
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
(param(instance)%tausat_slip(f)+ssat_offset)) &
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
**param(instance)%a_slip&
misplaced bracket caused wrong results introduced in commit e3bd09d8
2018-05-02 19:36:30 +05:30
*sign(1.0_pReal,1.0_pReal-state(instance)%s_slip(j,of) / &
(param(instance)%tausat_slip(f)+ssat_offset))
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
right_TwinSlip(j) = 1.0_pReal ! no system-dependent part
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
pre-defined variables seem to work for gfortran
2018-06-25 17:36:13 +05:30
nonSchmidSystems: do k = 1,size(param(instance)%nonSchmidCoeff)
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
tau_slip_pos = tau_slip_pos + param(instance)%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))
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
tau_slip_neg = tau_slip_neg +param(instance)%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
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
gdot_slip(j) = param(instance)%gdot0_slip*0.5_pReal* &
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
((abs(tau_slip_pos)/(state(instance)%s_slip(j,of)))**param(instance)%n_slip &
added missing line continuation
2016-06-15 01:40:24 +05:30
*sign(1.0_pReal,tau_slip_pos) &
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
+(abs(tau_slip_neg)/(state(instance)%s_slip(j,of)))**param(instance)%n_slip &
unified way gamma_dot is calculated
2016-06-15 01:36:04 +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
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
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
twinFamilies1: do f = 1_pInt,size(param(instance)%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
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
twinSystems1: do i = 1_pInt,param(instance)%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
more logical structure when reading in
2015-09-09 01:14:32 +05:30
left_TwinSlip(j) = 1.0_pReal ! no system-dependent left part
left_TwinTwin(j) = 1.0_pReal ! no system-dependent left part
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
right_SlipTwin(j) = 1.0_pReal ! no system-dependent right part
right_TwinTwin(j) = 1.0_pReal ! no system-dependent right part
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))
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
gdot_twin(j) = (1.0_pReal-state(instance)%sumF(of))*& ! 1-F
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%gdot0_twin*&
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
(abs(tau_twin)/state(instance)%s_twin(j,of))**&
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%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
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
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
slipFamilies2: do f = 1_pInt,size(param(instance)%Nslip,1)
slipSystems2: do i = 1_pInt,param(instance)%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
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
dotState(instance)%s_slip(j,of) = & ! evolution of slip resistance j
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
c_SlipSlip * left_SlipSlip(j) * &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
dot_product(param(instance)%matrix_SlipSlip(j,1:nslip), &
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
right_SlipSlip*abs(gdot_slip)) + & ! dot gamma_slip modulated by right-side slip factor
using material.config values from main memory
2018-06-02 02:26:20 +05:30
dot_product(param(instance)%matrix_SlipTwin(j,1:ntwin), &
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
right_SlipTwin*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
dotState(instance)%sumGamma(of) = dotState(instance)%sumGamma(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
abs(gdot_slip(j))
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
dotState(instance)%accshear_slip(j,of) = abs(gdot_slip(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 slipSystems2
enddo slipFamilies2
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
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
twinFamilies2: do f = 1_pInt,size(param(instance)%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
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
twinSystems2: do i = 1_pInt,param(instance)%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
using state pointer increases readability in dotState
2018-04-27 23:23:54 +05:30
dotState(instance)%s_twin(j,of) = & ! evolution of twin resistance j
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
c_TwinSlip * left_TwinSlip(j) * &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
dot_product(param(instance)%matrix_TwinSlip(j,1:nslip), &
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
right_TwinSlip*abs(gdot_slip)) + & ! dot gamma_slip modulated by right-side slip factor
c_TwinTwin * left_TwinTwin(j) * &
using material.config values from main memory
2018-06-02 02:26:20 +05:30
dot_product(param(instance)%matrix_TwinTwin(j,1:ntwin), &
switched matrix indices in SlipSlip, SlipTwin, TwinSlip, and TwinTwin such that first index refers to first name and second to second... (used to be transposed for memory efficiency)
2012-11-14 15:52:34 +05:30
right_TwinTwin*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
nSlip,nTwin, &
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
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)
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
nSlip= sum(param(instance)%nslip)
nTwin= sum(param(instance)%nTwin)
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
using material.config values from main memory
2018-06-02 02:26:20 +05:30
outputsLoop: do o = 1_pInt,size(param(instance)%outputID)
select case(param(instance)%outputID(o))
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (resistance_slip_ID)
using state pointers increases readability in postResults
2018-05-02 21:03:42 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt:c+nSlip) = state(instance)%s_slip(1:nSlip,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
c = c + nSlip
added ID (integer, enum) case switching for phenopowerlaw and isostrain
2013-11-27 17:09:28 +05:30
case (accumulatedshear_slip_ID)
using state pointers increases readability in postResults
2018-05-02 21:03:42 +05:30
plastic_phenopowerlaw_postResults(c+1_pInt:c+nSlip) = state(instance)%accshear_slip(1:nSlip,of)
added output capabilities for accumulated shears on slip and twin systems.
2013-02-06 23:39:11 +05:30
c = c + nSlip
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
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
slipFamilies1: do f = 1_pInt,size(param(instance)%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
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
slipSystems1: do i = 1_pInt,param(instance)%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)
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
tau_slip_pos = tau_slip_pos +param(instance)%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))
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
tau_slip_neg = tau_slip_neg +param(instance)%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
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
plastic_phenopowerlaw_postResults(c+j) = param(instance)%gdot0_slip*0.5_pReal* &
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
((abs(tau_slip_pos)/state(instance)%s_slip(j,of))**param(instance)%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) &
using state pointers increases readability in constitutive results
2018-05-01 01:00:53 +05:30
+(abs(tau_slip_neg)/(state(instance)%s_slip(j,of)))**param(instance)%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
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 = c + nSlip
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
should loop over slip systems
2018-04-26 22:05:49 +05:30
slipFamilies2: do f = 1_pInt,size(param(instance)%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
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
slipSystems2: do i = 1_pInt,param(instance)%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
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 = c + nSlip
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)
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:c+nTwin) = &
using state pointers increases readability in postResults
2018-05-02 21:03:42 +05:30
state(instance)%s_twin(1:nTwin,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
c = c + nTwin
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)
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:c+nTwin) = &
using state pointers increases readability in postResults
2018-05-02 21:03:42 +05:30
state(instance)%accshear_twin(1:nTwin,of)
added output capabilities for accumulated shears on slip and twin systems.
2013-02-06 23:39:11 +05:30
c = c + nTwin
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
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
twinFamilies1: do f = 1_pInt,size(param(instance)%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
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
twinSystems1: do i = 1_pInt,param(instance)%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
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%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))**&
Ntrans not needed/used. Simplified storage of parameters
2018-04-24 21:01:05 +05:30
param(instance)%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
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 = c + nTwin
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
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
twinFamilies2: do f = 1_pInt,size(param(instance)%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
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
twinSystems2: do i = 1_pInt,param(instance)%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
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 = c + nTwin
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