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_nonlocal.f90

2613 lines
140 KiB
Fortran
Raw Normal View History

introduced named constants for homogenization_type, phase_plasticitiy, and phase_elasticity to replace expensive string comparison. Labels for different schemes need to be stored in material.f90 because they are needed when parsing the config file
2013-11-27 13:34:05 +05:30
!--------------------------------------------------------------------------------------------------
!> @author Christoph Kords, Max-Planck-Institut für Eisenforschung GmbH
!> @author Franz Roters, Max-Planck-Institut für Eisenforschung GmbH
!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH
!> @brief material subroutine for plasticity including dislocation flux
!--------------------------------------------------------------------------------------------------
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_nonlocal
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
use prec, only: &
pReal, &
removed old state pointer (p_vec)
2014-10-13 18:01:04 +05:30
pInt
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
implicit none
private
real(pReal), parameter, private :: &
KB = 1.38e-23_pReal !< Physical parameter, Boltzmann constant in J/Kelvin
all constitutive modules now contain a new function "deltaState", which in the future allows to have an instantaneous and incremental change of the state (additional to the rate based evolution with dotState).
2012-05-16 20:13:26 +05:30
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
integer(pInt), dimension(:,:), allocatable, target, 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_nonlocal_sizePostResult !< size of each post result output
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
character(len=64), dimension(:,:), allocatable, target, 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_nonlocal_output !< name of each post result output
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
integer, dimension(8), parameter :: &
sgl = [1,2,3,4,5,6,7,8]
integer, dimension(2), parameter :: &
dip = [9,10]
integer, dimension(5), parameter :: &
edg = [1,2,5,6,9], &
scr = [3,4,7,8,10]
integer, dimension(4), parameter :: &
mob = [1,2,3,4], &
imm = [5,6,7,8], &
pos = sgl(1:7:2), &
neg = sgl(2:8:2), &
sgl_edg = edg(1:4), &
sgl_scr = scr(1:4)
integer, parameter :: &
mob_edg_pos = 1, &
mob_edg_neg = 2, &
mob_scr_pos = 3, &
mob_scr_neg = 4
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
integer(pInt), dimension(:,:), allocatable, private :: &
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
iRhoF !< state indices for forest density
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
integer(pInt), dimension(:,:,:), allocatable, private :: &
iRhoU, & !< state indices for unblocked density
iRhoB, & !< state indices for blocked density
iRhoD, & !< state indices for dipole density
iV, & !< state indices for dislcation velocities
iD !< state indices for stable dipole height
cleaner interface for ductile damage models
2014-10-28 08:12:25 +05:30
integer(pInt), dimension(:), allocatable, public, protected :: &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
totalNslip !< total number of active slip systems for each instance
real(pReal), dimension(:,:,:,:,:,:), allocatable, private :: &
compatibility !< slip system compatibility between me and my neighbors
enum, bind(c)
enumerator :: undefined_ID, &
more systematic names
2019-03-16 13:25:25 +05:30
rho_sgl_mob_edg_pos_ID, &
rho_sgl_mob_edg_neg_ID, &
rho_sgl_mob_scr_pos_ID, &
rho_sgl_mob_scr_neg_ID, &
rho_sgl_imm_edg_pos_ID, &
rho_sgl_imm_edg_neg_ID, &
rho_sgl_imm_scr_pos_ID, &
rho_sgl_imm_scr_neg_ID, &
rho_dip_edg_ID, &
rho_dip_scr_ID, &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
rho_forest_ID, &
shearrate_ID, &
resolvedstress_ID, &
resolvedstress_external_ID, &
resolvedstress_back_ID, &
resistance_ID, &
rho_dot_sgl_ID, &
rho_dot_sgl_mobile_ID, &
rho_dot_dip_ID, &
rho_dot_gen_ID, &
rho_dot_gen_edge_ID, &
rho_dot_gen_screw_ID, &
rho_dot_sgl2dip_edge_ID, &
rho_dot_sgl2dip_screw_ID, &
rho_dot_ann_ath_ID, &
rho_dot_ann_the_edge_ID, &
rho_dot_ann_the_screw_ID, &
rho_dot_edgejogs_ID, &
rho_dot_flux_mobile_ID, &
rho_dot_flux_edge_ID, &
rho_dot_flux_screw_ID, &
velocity_edge_pos_ID, &
velocity_edge_neg_ID, &
velocity_screw_pos_ID, &
velocity_screw_neg_ID, &
maximumdipoleheight_edge_ID, &
maximumdipoleheight_screw_ID, &
only output direct quantities derived quantities can be easily calculated during post processing
2019-01-15 09:25:40 +05:30
accumulatedshear_ID
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
end enum
simplified output
2019-02-15 11:55:25 +05:30
type, private :: tParameters !< container type for internal constitutive parameters
real(pReal) :: &
atomicVolume, & !< atomic volume
Dsd0, & !< prefactor for self-diffusion coefficient
selfDiffusionEnergy, & !< activation enthalpy for diffusion
aTolRho, & !< absolute tolerance for dislocation density in state integration
aTolShear, & !< absolute tolerance for accumulated shear in state integration
significantRho, & !< density considered significant
significantN, & !< number of dislocations considered significant
doublekinkwidth, & !< width of a doubkle kink in multiples of the burgers vector length b
solidSolutionEnergy, & !< activation energy for solid solution in J
solidSolutionSize, & !< solid solution obstacle size in multiples of the burgers vector length
solidSolutionConcentration, & !< concentration of solid solution in atomic parts
p, & !< parameter for kinetic law (Kocks,Argon,Ashby)
q, & !< parameter for kinetic law (Kocks,Argon,Ashby)
viscosity, & !< viscosity for dislocation glide in Pa s
fattack, & !< attack frequency in Hz
rhoSglScatter, & !< standard deviation of scatter in initial dislocation density
surfaceTransmissivity, & !< transmissivity at free surface
grainboundaryTransmissivity, & !< transmissivity at grain boundary (identified by different texture)
CFLfactor, & !< safety factor for CFL flux condition
fEdgeMultiplication, & !< factor that determines how much edge dislocations contribute to multiplication (0...1)
rhoSglRandom, &
rhoSglRandomBinning, &
linetensionEffect, &
edgeJogFactor, &
mu, &
nu
real(pReal), dimension(:), allocatable :: &
transition to param structure
2019-02-20 13:43:50 +05:30
minDipoleHeight_edge, & !< minimum stable edge dipole height
minDipoleHeight_screw, & !< minimum stable screw dipole height
peierlsstress_edge, &
peierlsstress_screw, &
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
rhoSglEdgePos0, & !< initial edge_pos dislocation density
rhoSglEdgeNeg0, & !< initial edge_neg dislocation density
rhoSglScrewPos0, & !< initial screw_pos dislocation density
rhoSglScrewNeg0, & !< initial screw_neg dislocation density
rhoDipEdge0, & !< initial edge dipole dislocation density
rhoDipScrew0,& !< initial screw dipole dislocation density
lambda0, & !< mean free path prefactor for each
burgers !< absolute length of burgers vector [m]
simplified output
2019-02-15 11:55:25 +05:30
real(pReal), dimension(:,:), allocatable :: &
don't parse material.config any more
2019-02-20 23:33:20 +05:30
slip_normal, &
slip_direction, &
slip_transverse, &
transition to param structure
2019-02-20 13:43:50 +05:30
minDipoleHeight, & ! edge and screw
peierlsstress, & ! edge and screw
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
interactionSlipSlip ,& !< coefficients for slip-slip interaction
forestProjection_Edge, & !< matrix of forest projections of edge dislocations
forestProjection_Screw !< matrix of forest projections of screw dislocations
simplified output
2019-02-15 11:55:25 +05:30
real(pReal), dimension(:), allocatable, private :: &
nonSchmidCoeff
integer(pInt) :: totalNslip
real(pReal), dimension(:,:,:), allocatable, private :: &
Schmid, & !< Schmid contribution
nonSchmid_pos, &
nonSchmid_neg !< combined projection of Schmid and non-Schmid contributions to the resolved shear stress (only for screws)
integer(pInt) , dimension(:) ,allocatable , public:: &
Nslip,&
colinearSystem !< colinear system to the active slip system (only valid for fcc!)
logical, private :: &
shortRangeStressCorrection, & !< flag indicating the use of the short range stress correction by a excess density gradient term
probabilisticMultiplication
integer(kind(undefined_ID)), dimension(:), allocatable :: &
outputID !< ID of each post result output
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
simplified output
2019-02-15 11:55:25 +05:30
end type tParameters
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
type, private :: tNonlocalMicrostructure
real(pReal), allocatable, dimension(:,:) :: &
tau_Threshold, &
tau_Back
end type tNonlocalMicrostructure
simplified output
2019-02-15 11:55:25 +05:30
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
type, private :: tOutput !< container type for storage of output results
real(pReal), dimension(:,:), allocatable, private :: &
rhoDotEdgeJogs
real(pReal), dimension(:,:,:), allocatable, private :: &
rhoDotFlux, &
rhoDotMultiplication, &
rhoDotSingle2DipoleGlide, &
rhoDotAthermalAnnihilation, &
rhoDotThermalAnnihilation
end type
complex pointer structure for state
2019-02-19 14:13:48 +05:30
type, private :: tNonlocalState
real(pReal), pointer, dimension(:,:) :: &
rho, & ! < all dislocations
rhoSgl, &
rhoSglMobile, & ! iRhoU
rhoSglEdgeMobile, &
more systematic names
2019-03-16 13:25:25 +05:30
rho_sgl_mob_edg_pos, &
rho_sgl_mob_edg_neg, &
complex pointer structure for state
2019-02-19 14:13:48 +05:30
rhoSglScrewMobile, &
more systematic names
2019-03-16 13:25:25 +05:30
rho_sgl_mob_scr_pos, &
rho_sgl_mob_scr_neg, &
complex pointer structure for state
2019-02-19 14:13:48 +05:30
rhoSglImmobile, & ! iRhoB
rhoSglEdgeImmobile, &
more systematic names
2019-03-16 13:25:25 +05:30
rho_sgl_imm_edg_pos, &
rho_sgl_imm_edg_neg, &
complex pointer structure for state
2019-02-19 14:13:48 +05:30
rhoSglScrewImmobile, &
more systematic names
2019-03-16 13:25:25 +05:30
rho_sgl_imm_scr_pos, &
rho_sgl_imm_scr_neg, &
complex pointer structure for state
2019-02-19 14:13:48 +05:30
rhoSglPos, &
rhoSglMobilePos, &
rhoSglImmobilePos, &
rhoSglNeg, &
rhoSglMobileNeg, &
rhoSglImmobileNeg, &
rhoDip, & ! iRhoD
more systematic names
2019-03-16 13:25:25 +05:30
rho_dip_edg, &
rho_dip_scr, &
complex pointer structure for state
2019-02-19 14:13:48 +05:30
rhoSglScrew, &
rhoSglEdge, &
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
rho_forest, &
complex pointer structure for state
2019-02-19 14:13:48 +05:30
accumulatedshear
end type tNonlocalState
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
complex pointer structure for state
2019-02-19 14:13:48 +05:30
type(tNonlocalState), allocatable, dimension(:), private :: &
deltaState, &
dotState, &
state
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
type(tParameters), dimension(:), allocatable, private :: param !< containers of constitutive parameters (len Ninstance)
simplified output
2019-02-15 11:55:25 +05:30
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
type(tOutput), dimension(:), allocatable, private :: results
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
type(tNonlocalMicrostructure), dimension(:), allocatable, private :: microstructure
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
integer(kind(undefined_ID)), dimension(:,:), allocatable, private :: &
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_nonlocal_outputID !< ID of each post result output
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +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_nonlocal_init, &
same name in all models
2019-02-20 19:24:26 +05:30
plastic_nonlocal_dependentState, &
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_nonlocal_LpAndItsTangent, &
plastic_nonlocal_dotState, &
plastic_nonlocal_deltaState, &
plastic_nonlocal_updateCompatibility, &
dummy HDF5 output for all plasticity laws
2019-03-10 01:13:31 +05:30
plastic_nonlocal_postResults, &
plastic_nonlocal_results
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
private :: &
was not used
2019-02-15 11:33:52 +05:30
plastic_nonlocal_kinetics
cleaning
2019-02-18 14:58:08 +05:30
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
introduced named constants for homogenization_type, phase_plasticitiy, and phase_elasticity to replace expensive string comparison. Labels for different schemes need to be stored in material.f90 because they are needed when parsing the config file
2013-11-27 13:34:05 +05:30
contains
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
remove dotTemperature (returned always 0 anyway) to make it easier to replace it with a heating rate funtction remove potentially dangerous short circuiting in homogenization files added doxygen comment for nonlocal (giving the functions a name) fixed wrong definition of maxnchungs introcuded into dislotwin with last commit, causes trouble with hex
2013-10-09 11:42:16 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief module initialization
!> @details reads in material parameters, allocates arrays, and does sanity checks
!--------------------------------------------------------------------------------------------------
don't parse material.config any more
2019-02-20 23:33:20 +05:30
subroutine plastic_nonlocal_init
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
use prec, only: &
dEq0, dNeq0, dEq
use math, only: &
math_expand, math_cross
use IO, only: &
IO_error
use debug, only: &
debug_level, &
debug_constitutive, &
debug_levelBasic
use mesh, only: &
theMesh
use material, only: &
phase_plasticity, &
phase_plasticityInstance, &
phase_Noutput, &
PLASTICITY_NONLOCAL_label, &
PLASTICITY_NONLOCAL_ID, &
plasticState, &
material_phase, &
material_allocatePlasticState
use config
use lattice
implicit none
character(len=65536), dimension(0), parameter :: emptyStringArray = [character(len=65536)::]
integer(pInt), dimension(0), parameter :: emptyIntArray = [integer(pInt)::]
real(pReal), dimension(0), parameter :: emptyRealArray = [real(pReal)::]
integer(pInt) :: &
maxNinstances, &
avoid use of new variables in deprecated code
2019-02-22 13:02:12 +05:30
p, i, &
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
l, &
better readable
2019-02-22 13:51:04 +05:30
s1, s2, &
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
s, & ! index of my slip system
t, & ! index of dislocation type
c ! index of dislocation character
integer(pInt) :: sizeState, sizeDotState,sizeDependentState, sizeDeltaState
integer(kind(undefined_ID)) :: &
outputID
character(len=512) :: &
extmsg = '', &
structure
character(len=65536), dimension(:), allocatable :: outputs
integer(pInt) :: NofMyPhase
remove omp statements during initialization, "line" for reading in from material.config now has a default (empty) value to prevent conditional jump depend on this value
2013-01-09 03:41:59 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
write(6,'(/,a)') ' <<<+- constitutive_'//PLASTICITY_NONLOCAL_label//' init -+>>>'
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
polishing and extending citations
2019-03-09 15:32:12 +05:30
write(6,'(/,a)') ' Reuber et al., Acta Materialia 71:333–348, 2014'
write(6,'(a)') ' https://doi.org/10.1016/j.actamat.2014.03.012'
write(6,'(/,a)') ' Kords, Dissertation RWTH Aachen, 2014'
write(6,'(a)') ' http://publications.rwth-aachen.de/record/229993'
maxNinstances = count(phase_plasticity == PLASTICITY_NONLOCAL_ID)
if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) &
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
write(6,'(a16,1x,i5,/)') '# instances:',maxNinstances
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
allocate(param(maxNinstances))
allocate(state(maxNinstances))
allocate(dotState(maxNinstances))
allocate(deltaState(maxNinstances))
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
allocate(microstructure(maxNinstances))
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
allocate(results(maxNinstances))
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
allocate(plastic_nonlocal_sizePostResult(maxval(phase_Noutput), maxNinstances), source=0_pInt)
allocate(plastic_nonlocal_output(maxval(phase_Noutput), maxNinstances))
plastic_nonlocal_output = ''
allocate(plastic_nonlocal_outputID(maxval(phase_Noutput), maxNinstances), source=undefined_ID)
allocate(totalNslip(maxNinstances), source=0_pInt)
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
added non-schmid structure
2013-01-22 05:20:28 +05:30
don't parse material.config any more
2019-02-20 23:33:20 +05:30
do p=1_pInt, size(config_phase)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if (phase_plasticity(p) /= PLASTICITY_NONLOCAL_ID) cycle
associate(prm => param(phase_plasticityInstance(p)), &
dot => dotState(phase_plasticityInstance(p)), &
stt => state(phase_plasticityInstance(p)), &
del => deltaState(phase_plasticityInstance(p)), &
res => results(phase_plasticityInstance(p)), &
leaner interface
2019-02-22 02:02:22 +05:30
dst => microstructure(phase_plasticityInstance(p)), &
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
config => config_phase(p))
prm%aTolRho = config%getFloat('atol_rho', defaultVal=0.0_pReal)
prm%aTolShear = config%getFloat('atol_shear', defaultVal=0.0_pReal)
structure = config%getString('lattice_structure')
central function for less depencies
2019-01-31 18:30:26 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
! This data is read in already in lattice
prm%mu = lattice_mu(p)
prm%nu = lattice_nu(p)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
prm%Nslip = config%getInts('nslip',defaultVal=emptyIntArray)
prm%totalNslip = sum(prm%Nslip)
slipActive: if (prm%totalNslip > 0_pInt) then
prm%Schmid = lattice_SchmidMatrix_slip(prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if(trim(config%getString('lattice_structure')) == 'bcc') then
prm%nonSchmidCoeff = config%getFloats('nonschmid_coefficients',&
defaultVal = emptyRealArray)
prm%nonSchmid_pos = lattice_nonSchmidMatrix(prm%Nslip,prm%nonSchmidCoeff,+1_pInt)
prm%nonSchmid_neg = lattice_nonSchmidMatrix(prm%Nslip,prm%nonSchmidCoeff,-1_pInt)
else
prm%nonSchmid_pos = prm%Schmid
prm%nonSchmid_neg = prm%Schmid
endif
fortran fast storage of interaction matrices
2019-03-12 03:11:59 +05:30
prm%interactionSlipSlip = lattice_interaction_SlipBySlip(prm%Nslip, &
config%getFloats('interaction_slipslip'), &
config%getString('lattice_structure'))
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
prm%forestProjection_edge = lattice_forestProjection_edge (prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
prm%forestProjection_screw = lattice_forestProjection_screw(prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
prm%slip_direction = lattice_slip_direction (prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
prm%slip_transverse = lattice_slip_transverse(prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
prm%slip_normal = lattice_slip_normal (prm%Nslip,config%getString('lattice_structure'),&
config%getFloat('c/a',defaultVal=0.0_pReal))
! collinear systems (only for octahedral slip systems in fcc)
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
allocate(prm%colinearSystem(prm%totalNslip), source = -1_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
do s1 = 1_pInt, prm%totalNslip
do s2 = 1_pInt, prm%totalNslip
if (all(dEq0 (math_cross(prm%slip_direction(1:3,s1),prm%slip_direction(1:3,s2)))) .and. &
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
any(dNeq0(math_cross(prm%slip_normal (1:3,s1),prm%slip_normal (1:3,s2))))) &
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
prm%colinearSystem(s1) = s2
enddo
enddo
prm%rhoSglEdgePos0 = config%getFloats('rhosgledgepos0', requiredSize=size(prm%Nslip))
prm%rhoSglEdgeNeg0 = config%getFloats('rhosgledgeneg0', requiredSize=size(prm%Nslip))
prm%rhoSglScrewPos0 = config%getFloats('rhosglscrewpos0', requiredSize=size(prm%Nslip))
prm%rhoSglScrewNeg0 = config%getFloats('rhosglscrewneg0', requiredSize=size(prm%Nslip))
prm%rhoDipEdge0 = config%getFloats('rhodipedge0', requiredSize=size(prm%Nslip))
prm%rhoDipScrew0 = config%getFloats('rhodipscrew0', requiredSize=size(prm%Nslip))
prm%lambda0 = config%getFloats('lambda0', requiredSize=size(prm%Nslip))
prm%burgers = config%getFloats('burgers', requiredSize=size(prm%Nslip))
prm%lambda0 = math_expand(prm%lambda0,prm%Nslip)
prm%burgers = math_expand(prm%burgers,prm%Nslip)
prm%minDipoleHeight_edge = config%getFloats('minimumdipoleheightedge', requiredSize=size(prm%Nslip))
prm%minDipoleHeight_screw = config%getFloats('minimumdipoleheightscrew', requiredSize=size(prm%Nslip))
prm%minDipoleHeight_edge = math_expand(prm%minDipoleHeight_edge,prm%Nslip)
prm%minDipoleHeight_screw = math_expand(prm%minDipoleHeight_screw,prm%Nslip)
allocate(prm%minDipoleHeight(prm%totalNslip,2))
prm%minDipoleHeight(:,1) = prm%minDipoleHeight_edge
prm%minDipoleHeight(:,2) = prm%minDipoleHeight_screw
prm%peierlsstress_edge = config%getFloats('peierlsstressedge', requiredSize=size(prm%Nslip))
prm%peierlsstress_screw = config%getFloats('peierlsstressscrew', requiredSize=size(prm%Nslip))
prm%peierlsstress_edge = math_expand(prm%peierlsstress_edge,prm%Nslip)
prm%peierlsstress_screw = math_expand(prm%peierlsstress_screw,prm%Nslip)
allocate(prm%peierlsstress(prm%totalNslip,2))
prm%peierlsstress(:,1) = prm%peierlsstress_edge
prm%peierlsstress(:,2) = prm%peierlsstress_screw
prm%significantRho = config%getFloat('significantrho')
prm%significantN = config%getFloat('significantn', 0.0_pReal)
prm%CFLfactor = config%getFloat('cflfactor',defaultVal=2.0_pReal)
prm%atomicVolume = config%getFloat('atomicvolume')
prm%Dsd0 = config%getFloat('selfdiffusionprefactor') !,'dsd0')
prm%selfDiffusionEnergy = config%getFloat('selfdiffusionenergy') !,'qsd')
prm%linetensionEffect = config%getFloat('linetension')
prm%edgeJogFactor = config%getFloat('edgejog')!,'edgejogs'
prm%doublekinkwidth = config%getFloat('doublekinkwidth')
prm%solidSolutionEnergy = config%getFloat('solidsolutionenergy')
prm%solidSolutionSize = config%getFloat('solidsolutionsize')
prm%solidSolutionConcentration = config%getFloat('solidsolutionconcentration')
prm%p = config%getFloat('p')
prm%q = config%getFloat('q')
prm%viscosity = config%getFloat('viscosity')
prm%fattack = config%getFloat('attackfrequency')
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
! ToDo: discuss logic
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
prm%rhoSglScatter = config%getFloat('rhosglscatter')
prm%rhoSglRandom = config%getFloat('rhosglrandom',0.0_pReal)
if (config%keyExists('rhosglrandom')) &
prm%rhoSglRandomBinning = config%getFloat('rhosglrandombinning',0.0_pReal) !ToDo: useful default?
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
! if (rhoSglRandom(instance) < 0.0_pReal) &
! if (rhoSglRandomBinning(instance) <= 0.0_pReal) &
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
prm%surfaceTransmissivity = config%getFloat('surfacetransmissivity',defaultVal=1.0_pReal)
prm%grainboundaryTransmissivity = config%getFloat('grainboundarytransmissivity',defaultVal=-1.0_pReal)
prm%fEdgeMultiplication = config%getFloat('edgemultiplication')
prm%shortRangeStressCorrection = config%getInt('shortrangestresscorrection',defaultVal=0_pInt ) > 0_pInt ! ToDo: use /flag/ type key
!--------------------------------------------------------------------------------------------------
! sanity checks
if (any(prm%burgers < 0.0_pReal)) extmsg = trim(extmsg)//' burgers'
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
if (any(prm%lambda0 <= 0.0_pReal)) extmsg = trim(extmsg)//' lambda0'
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if (any(prm%rhoSglEdgePos0 < 0.0_pReal)) extmsg = trim(extmsg)//' rhoSglEdgePos0'
if (any(prm%rhoSglEdgeNeg0 < 0.0_pReal)) extmsg = trim(extmsg)//' rhoSglEdgeNeg0'
if (any(prm%rhoSglScrewPos0 < 0.0_pReal)) extmsg = trim(extmsg)//' rhoSglScrewPos0'
if (any(prm%rhoSglScrewNeg0 < 0.0_pReal)) extmsg = trim(extmsg)//' rhoSglScrewNeg0'
if (any(prm%rhoDipEdge0 < 0.0_pReal)) extmsg = trim(extmsg)//' rhoDipEdge0'
if (any(prm%rhoDipScrew0 < 0.0_pReal)) extmsg = trim(extmsg)//' rhoDipScrew0'
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if (any(prm%peierlsstress < 0.0_pReal)) extmsg = trim(extmsg)//' peierlsstress'
if (any(prm%minDipoleHeight < 0.0_pReal)) extmsg = trim(extmsg)//' minDipoleHeight'
if (prm%viscosity <= 0.0_pReal) extmsg = trim(extmsg)//' viscosity'
if (prm%selfDiffusionEnergy <= 0.0_pReal) extmsg = trim(extmsg)//' selfDiffusionEnergy'
if (prm%fattack <= 0.0_pReal) extmsg = trim(extmsg)//' fattack'
if (prm%doublekinkwidth <= 0.0_pReal) extmsg = trim(extmsg)//' doublekinkwidth'
if (prm%Dsd0 < 0.0_pReal) extmsg = trim(extmsg)//' Dsd0'
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
if (prm%atomicVolume <= 0.0_pReal) extmsg = trim(extmsg)//' atomicVolume' ! ToDo: in disloUCLA/dislotwin, the atomic volume is given as a factor
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if (prm%significantN < 0.0_pReal) extmsg = trim(extmsg)//' significantN'
if (prm%significantrho < 0.0_pReal) extmsg = trim(extmsg)//' significantrho'
if (prm%atolshear <= 0.0_pReal) extmsg = trim(extmsg)//' atolshear'
if (prm%atolrho <= 0.0_pReal) extmsg = trim(extmsg)//' atolrho'
if (prm%CFLfactor < 0.0_pReal) extmsg = trim(extmsg)//' CFLfactor'
if (prm%p <= 0.0_pReal .or. prm%p > 1.0_pReal) extmsg = trim(extmsg)//' p'
if (prm%q < 1.0_pReal .or. prm%q > 2.0_pReal) extmsg = trim(extmsg)//' q'
if (prm%linetensionEffect < 0.0_pReal .or. prm%linetensionEffect > 1.0_pReal) &
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
extmsg = trim(extmsg)//' linetensionEffect'
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if (prm%edgeJogFactor < 0.0_pReal .or. prm%edgeJogFactor > 1.0_pReal) &
extmsg = trim(extmsg)//' edgeJogFactor'
if (prm%solidSolutionEnergy <= 0.0_pReal) extmsg = trim(extmsg)//' solidSolutionEnergy'
if (prm%solidSolutionSize <= 0.0_pReal) extmsg = trim(extmsg)//' solidSolutionSize'
if (prm%solidSolutionConcentration <= 0.0_pReal) extmsg = trim(extmsg)//' solidSolutionConcentration'
if (prm%grainboundaryTransmissivity > 1.0_pReal) extmsg = trim(extmsg)//' grainboundaryTransmissivity'
if (prm%surfaceTransmissivity < 0.0_pReal .or. prm%surfaceTransmissivity > 1.0_pReal) &
extmsg = trim(extmsg)//' surfaceTransmissivity'
remove omp statements during initialization, "line" for reading in from material.config now has a default (empty) value to prevent conditional jump depend on this value
2013-01-09 03:41:59 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
if (prm%fEdgeMultiplication < 0.0_pReal .or. prm%fEdgeMultiplication > 1.0_pReal) &
extmsg = trim(extmsg)//' fEdgeMultiplication'
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
endif slipActive
using more parameters from smart structure
2019-02-19 15:01:14 +05:30
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
!--------------------------------------------------------------------------------------------------
! output pararameters
outputs = config%getStrings('(output)',defaultVal=emptyStringArray)
allocate(prm%outputID(0))
do i=1_pInt, size(outputs)
outputID = undefined_ID
select case(trim(outputs(i)))
case ('rho_sgl_edge_pos_mobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_mob_edg_pos_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_edge_neg_mobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_mob_edg_neg_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_screw_pos_mobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_mob_scr_pos_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_screw_neg_mobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_mob_scr_neg_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_edge_pos_immobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_imm_edg_pos_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_edge_neg_immobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_imm_edg_neg_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_screw_pos_immobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_imm_scr_pos_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_sgl_screw_neg_immobile')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_sgl_imm_scr_neg_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_dip_edge')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_dip_edg_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_dip_screw')
more systematic names
2019-03-16 13:25:25 +05:30
outputID = merge(rho_dip_scr_ID,undefined_ID,prm%totalNslip>0_pInt)
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
case ('rho_forest')
outputID = merge(rho_forest_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('shearrate')
outputID = merge(shearrate_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('resolvedstress')
outputID = merge(resolvedstress_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('resolvedstress_external')
outputID = merge(resolvedstress_external_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('resolvedstress_back')
outputID = merge(resolvedstress_back_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('resistance')
outputID = merge(resistance_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_sgl')
outputID = merge(rho_dot_sgl_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_sgl_mobile')
outputID = merge(rho_dot_sgl_mobile_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_dip')
outputID = merge(rho_dot_dip_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_gen')
outputID = merge(rho_dot_gen_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_gen_edge')
outputID = merge(rho_dot_gen_edge_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_gen_screw')
outputID = merge(rho_dot_gen_screw_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_sgl2dip_edge')
outputID = merge(rho_dot_sgl2dip_edge_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_sgl2dip_screw')
outputID = merge(rho_dot_sgl2dip_screw_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_ann_ath')
outputID = merge(rho_dot_ann_ath_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_ann_the_edge')
outputID = merge(rho_dot_ann_the_edge_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_ann_the_screw')
outputID = merge(rho_dot_ann_the_screw_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_edgejogs')
outputID = merge(rho_dot_edgejogs_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_flux_mobile')
outputID = merge(rho_dot_flux_mobile_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_flux_edge')
outputID = merge(rho_dot_flux_edge_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('rho_dot_flux_screw')
outputID = merge(rho_dot_flux_screw_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('velocity_edge_pos')
outputID = merge(velocity_edge_pos_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('velocity_edge_neg')
outputID = merge(velocity_edge_neg_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('velocity_screw_pos')
outputID = merge(velocity_screw_pos_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('velocity_screw_neg')
outputID = merge(velocity_screw_neg_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('maximumdipoleheight_edge')
outputID = merge(maximumdipoleheight_edge_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('maximumdipoleheight_screw')
outputID = merge(maximumdipoleheight_screw_ID,undefined_ID,prm%totalNslip>0_pInt)
case ('accumulatedshear','accumulated_shear')
outputID = merge(accumulatedshear_ID,undefined_ID,prm%totalNslip>0_pInt)
end select
if (outputID /= undefined_ID) then
plastic_nonlocal_output(i,phase_plasticityInstance(p)) = outputs(i)
plastic_nonlocal_sizePostResult(i,phase_plasticityInstance(p)) = prm%totalNslip
prm%outputID = [prm%outputID , outputID]
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
endif
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
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
enddo
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
!--------------------------------------------------------------------------------------------------
! allocate state arrays
NofMyPhase=count(material_phase==p)
sizeDotState = int(size([ 'rhoSglEdgePosMobile ','rhoSglEdgeNegMobile ', &
'rhoSglScrewPosMobile ','rhoSglScrewNegMobile ', &
'rhoSglEdgePosImmobile ','rhoSglEdgeNegImmobile ', &
'rhoSglScrewPosImmobile','rhoSglScrewNegImmobile', &
'rhoDipEdge ','rhoDipScrew ', &
'accumulatedshear ' ]),pInt) * prm%totalNslip !< "basic" microstructural state variables that are independent from other state variables
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
sizeDependentState = int(size([ 'rhoForest ']),pInt) * prm%totalNslip !< microstructural state variables that depend on other state variables
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
sizeState = sizeDotState + sizeDependentState &
+ int(size([ 'velocityEdgePos ','velocityEdgeNeg ', &
'velocityScrewPos ','velocityScrewNeg ', &
'maxDipoleHeightEdge ','maxDipoleHeightScrew' ]),pInt) * prm%totalNslip !< other dependent state variables that are not updated by microstructure
sizeDeltaState = sizeDotState
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
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
call material_allocatePlasticState(p,NofMyPhase,sizeState,sizeDotState,sizeDeltaState, &
prm%totalNslip,0_pInt,0_pInt)
plasticState(p)%nonlocal = .true.
plasticState(p)%offsetDeltaState = 0_pInt ! ToDo: state structure does not follow convention
leaner interface
2019-02-22 02:02:22 +05:30
plasticState(p)%sizePostResults = sum(plastic_nonlocal_sizePostResult(:,phase_plasticityInstance(p)))
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
not needed anymore
2019-03-09 17:18:43 +05:30
totalNslip(phase_plasticityInstance(p)) = prm%totalNslip
re-ordered and cleaned
2019-02-21 04:54:35 +05:30
avoid repeated loops
2019-02-22 14:32:43 +05:30
! ToDo: Not really sure if this large number of mostly overlapping pointers is useful
leaner interface
2019-02-22 02:02:22 +05:30
stt%rho => plasticState(p)%state (0_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
dot%rho => plasticState(p)%dotState (0_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
del%rho => plasticState(p)%deltaState (0_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
plasticState(p)%aTolState(1:10_pInt*prm%totalNslip) = prm%aTolRho
stt%rhoSglEdge => plasticState(p)%state (0_pInt*prm%totalNslip+1_pInt:06_pInt*prm%totalNslip:2*prm%totalNslip,:)
stt%rhoSglScrew => plasticState(p)%state (2_pInt*prm%totalNslip+1_pInt:08_pInt*prm%totalNslip:2*prm%totalNslip,:)
stt%rhoSgl => plasticState(p)%state (0_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
dot%rhoSgl => plasticState(p)%dotState (0_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
del%rhoSgl => plasticState(p)%deltaState (0_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
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
complex pointer structure for state
2019-02-19 14:13:48 +05:30
stt%rhoSglMobile => plasticState(p)%state (0_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
dot%rhoSglMobile => plasticState(p)%dotState (0_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
del%rhoSglMobile => plasticState(p)%deltaState (0_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
simplified output
2019-02-15 11:55:25 +05:30
complex pointer structure for state
2019-02-19 14:13:48 +05:30
stt%rhoSglEdgeMobile => plasticState(p)%state (0_pInt*prm%totalNslip+1_pInt: 2_pInt*prm%totalNslip,:)
dot%rhoSglEdgeMobile => plasticState(p)%dotState (0_pInt*prm%totalNslip+1_pInt: 2_pInt*prm%totalNslip,:)
del%rhoSglEdgeMobile => plasticState(p)%deltaState (0_pInt*prm%totalNslip+1_pInt: 2_pInt*prm%totalNslip,:)
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_mob_edg_pos => plasticState(p)%state (0_pInt*prm%totalNslip+1_pInt: 1_pInt*prm%totalNslip,:)
dot%rho_sgl_mob_edg_pos => plasticState(p)%dotState (0_pInt*prm%totalNslip+1_pInt: 1_pInt*prm%totalNslip,:)
del%rho_sgl_mob_edg_pos => plasticState(p)%deltaState (0_pInt*prm%totalNslip+1_pInt: 1_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_mob_edg_neg => plasticState(p)%state (1_pInt*prm%totalNslip+1_pInt: 2_pInt*prm%totalNslip,:)
dot%rho_sgl_mob_edg_neg => plasticState(p)%dotState (1_pInt*prm%totalNslip+1_pInt: 2_pInt*prm%totalNslip,:)
del%rho_sgl_mob_edg_neg => plasticState(p)%deltaState (1_pInt*prm%totalNslip+1_pInt: 2_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
stt%rhoSglScrewMobile => plasticState(p)%state (2_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
dot%rhoSglScrewMobile => plasticState(p)%dotState (2_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
del%rhoSglScrewMobile => plasticState(p)%deltaState (2_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_mob_scr_pos => plasticState(p)%state (2_pInt*prm%totalNslip+1_pInt: 3_pInt*prm%totalNslip,:)
dot%rho_sgl_mob_scr_pos => plasticState(p)%dotState (2_pInt*prm%totalNslip+1_pInt: 3_pInt*prm%totalNslip,:)
del%rho_sgl_mob_scr_pos => plasticState(p)%deltaState (2_pInt*prm%totalNslip+1_pInt: 3_pInt*prm%totalNslip,:)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_mob_scr_neg => plasticState(p)%state (3_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
dot%rho_sgl_mob_scr_neg => plasticState(p)%dotState (3_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
del%rho_sgl_mob_scr_neg => plasticState(p)%deltaState (3_pInt*prm%totalNslip+1_pInt: 4_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
stt%rhoSglImmobile => plasticState(p)%state (4_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
dot%rhoSglImmobile => plasticState(p)%dotState (4_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
del%rhoSglImmobile => plasticState(p)%deltaState (4_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
stt%rhoSglEdgeImmobile => plasticState(p)%state (4_pInt*prm%totalNslip+1_pInt: 6_pInt*prm%totalNslip,:)
dot%rhoSglEdgeImmobile => plasticState(p)%dotState (4_pInt*prm%totalNslip+1_pInt: 6_pInt*prm%totalNslip,:)
del%rhoSglEdgeImmobile => plasticState(p)%deltaState (4_pInt*prm%totalNslip+1_pInt: 6_pInt*prm%totalNslip,:)
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_imm_edg_pos => plasticState(p)%state (4_pInt*prm%totalNslip+1_pInt: 5_pInt*prm%totalNslip,:)
dot%rho_sgl_imm_edg_pos => plasticState(p)%dotState (4_pInt*prm%totalNslip+1_pInt: 5_pInt*prm%totalNslip,:)
del%rho_sgl_imm_edg_pos => plasticState(p)%deltaState (4_pInt*prm%totalNslip+1_pInt: 5_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_imm_edg_neg => plasticState(p)%state (5_pInt*prm%totalNslip+1_pInt: 6_pInt*prm%totalNslip,:)
dot%rho_sgl_imm_edg_neg => plasticState(p)%dotState (5_pInt*prm%totalNslip+1_pInt: 6_pInt*prm%totalNslip,:)
del%rho_sgl_imm_edg_neg => plasticState(p)%deltaState (5_pInt*prm%totalNslip+1_pInt: 6_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
stt%rhoSglScrewImmobile => plasticState(p)%state (6_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
dot%rhoSglScrewImmobile => plasticState(p)%dotState (6_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
del%rhoSglScrewImmobile => plasticState(p)%deltaState (6_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_imm_scr_pos => plasticState(p)%state (6_pInt*prm%totalNslip+1_pInt: 7_pInt*prm%totalNslip,:)
dot%rho_sgl_imm_scr_pos => plasticState(p)%dotState(6_pInt*prm%totalNslip+1_pInt: 7_pInt*prm%totalNslip,:)
del%rho_sgl_imm_scr_pos => plasticState(p)%deltaState(6_pInt*prm%totalNslip+1_pInt: 7_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_imm_scr_neg => plasticState(p)%state (7_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
dot%rho_sgl_imm_scr_neg => plasticState(p)%dotState(7_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
del%rho_sgl_imm_scr_neg => plasticState(p)%deltaState(7_pInt*prm%totalNslip+1_pInt: 8_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
stt%rhoDip => plasticState(p)%state (8_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
dot%rhoDip => plasticState(p)%dotState (8_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
del%rhoDip => plasticState(p)%deltaState (8_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
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
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_dip_edg => plasticState(p)%state (8_pInt*prm%totalNslip+1_pInt: 9_pInt*prm%totalNslip,:)
dot%rho_dip_edg => plasticState(p)%dotState (8_pInt*prm%totalNslip+1_pInt: 9_pInt*prm%totalNslip,:)
del%rho_dip_edg => plasticState(p)%deltaState (8_pInt*prm%totalNslip+1_pInt: 9_pInt*prm%totalNslip,:)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_dip_scr => plasticState(p)%state (9_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
dot%rho_dip_scr => plasticState(p)%dotState (9_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
del%rho_dip_scr => plasticState(p)%deltaState (9_pInt*prm%totalNslip+1_pInt:10_pInt*prm%totalNslip,:)
pointers allow easier access to state variables
2019-02-22 01:07:49 +05:30
better readable
2019-02-22 13:51:04 +05:30
stt%accumulatedshear => plasticState(p)%state (10_pInt*prm%totalNslip + 1_pInt:11_pInt*prm%totalNslip ,1:NofMyPhase)
dot%accumulatedshear => plasticState(p)%dotState (10_pInt*prm%totalNslip + 1_pInt:11_pInt*prm%totalNslip ,1:NofMyPhase)
del%accumulatedshear => plasticState(p)%deltaState (10_pInt*prm%totalNslip + 1_pInt:11_pInt*prm%totalNslip ,1:NofMyPhase)
plasticState(p)%aTolState(10_pInt*prm%totalNslip + 1_pInt:11_pInt*prm%totalNslip ) = prm%aTolShear
plasticState(p)%slipRate => plasticState(p)%dotState(10_pInt*prm%totalNslip + 1_pInt:11_pInt*prm%totalNslip ,1:NofMyPhase)
plasticState(p)%accumulatedSlip => plasticState(p)%state (10_pInt*prm%totalNslip + 1_pInt:11_pInt*prm%totalNslip ,1:NofMyPhase)
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
stt%rho_forest => plasticState(p)%state (11_pInt*prm%totalNslip + 1_pInt:12_pInt*prm%totalNslip ,1:NofMyPhase)
removed some redundant parts
2014-07-08 20:28:23 +05:30
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
allocate(dst%tau_Threshold(prm%totalNslip,NofMyPhase),source=0.0_pReal)
allocate(dst%tau_Back(prm%totalNslip,NofMyPhase),source=0.0_pReal)
pointers allow easier access to state variables
2019-02-22 01:07:49 +05:30
allocate(res%rhoDotFlux(prm%totalNslip,8,NofMyPhase),source=0.0_pReal)
allocate(res%rhoDotMultiplication(prm%totalNslip,2,NofMyPhase),source=0.0_pReal)
allocate(res%rhoDotSingle2DipoleGlide(prm%totalNslip,2,NofMyPhase),source=0.0_pReal)
allocate(res%rhoDotAthermalAnnihilation(prm%totalNslip,2,NofMyPhase),source=0.0_pReal)
allocate(res%rhoDotThermalAnnihilation(prm%totalNslip,2,NofMyPhase),source=0.0_pReal)
allocate(res%rhoDotEdgeJogs(prm%totalNslip,NofMyPhase),source=0.0_pReal)
complex pointer structure for state
2019-02-19 14:13:48 +05:30
end associate
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
initialization can be done internally
2019-02-20 22:20:26 +05:30
if (NofMyPhase > 0_pInt) call stateInit(p,NofMyPhase)
plasticState(p)%state0 = plasticState(p)%state
avoid repeated loops
2019-02-22 14:32:43 +05:30
enddo
! BEGIN DEPRECATED----------------------------------------------------------------------------------
allocate(iRhoU(maxval(totalNslip),4,maxNinstances), source=0_pInt)
allocate(iRhoB(maxval(totalNslip),4,maxNinstances), source=0_pInt)
allocate(iRhoD(maxval(totalNslip),2,maxNinstances), source=0_pInt)
allocate(iV(maxval(totalNslip),4,maxNinstances), source=0_pInt)
allocate(iD(maxval(totalNslip),2,maxNinstances), source=0_pInt)
allocate(iRhoF(maxval(totalNslip),maxNinstances), source=0_pInt)
! END DEPRECATED------------------------------------------------------------------------------------
allocate(compatibility(2,maxval(totalNslip),maxval(totalNslip),theMesh%elem%nIPneighbors,theMesh%elem%nIPs,theMesh%nElems), &
source=0.0_pReal)
initializeInstances: do p = 1_pInt, size(phase_plasticity)
NofMyPhase=count(material_phase==p)
myPhase2: if (phase_plasticity(p) == PLASTICITY_NONLOCAL_ID) then
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
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
!*** determine indices to state array
removed some redundant parts
2014-07-08 20:28:23 +05:30
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
l = 0_pInt
do t = 1_pInt,4_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
do s = 1_pInt,param(phase_plasticityInstance(p))%totalNslip
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
l = l + 1_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
iRhoU(s,t,phase_plasticityInstance(p)) = l
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
enddo
enddo
do t = 1_pInt,4_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
do s = 1_pInt,param(phase_plasticityInstance(p))%totalNslip
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
l = l + 1_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
iRhoB(s,t,phase_plasticityInstance(p)) = l
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
enddo
enddo
do c = 1_pInt,2_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
do s = 1_pInt,param(phase_plasticityInstance(p))%totalNslip
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
l = l + 1_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
iRhoD(s,c,phase_plasticityInstance(p)) = l
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
enddo
enddo
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
l = l + param(phase_plasticityInstance(p))%totalNslip ! shear(rates)
avoid repeated loops
2019-02-22 14:32:43 +05:30
do s = 1_pInt,param(phase_plasticityInstance(p))%totalNslip
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
l = l + 1_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
iRhoF(s,phase_plasticityInstance(p)) = l
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
enddo
do t = 1_pInt,4_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
do s = 1_pInt,param(phase_plasticityInstance(p))%totalNslip
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
l = l + 1_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
iV(s,t,phase_plasticityInstance(p)) = l
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
enddo
enddo
do c = 1_pInt,2_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
do s = 1_pInt,param(phase_plasticityInstance(p))%totalNslip
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
l = l + 1_pInt
avoid repeated loops
2019-02-22 14:32:43 +05:30
iD(s,c,phase_plasticityInstance(p)) = l
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
enddo
enddo
avoid repeated loops
2019-02-22 14:32:43 +05:30
if (iD(param(phase_plasticityInstance(p))%totalNslip,2,phase_plasticityInstance(p)) /= plasticState(p)%sizeState) & ! check if last index is equal to size of state
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
call IO_error(0_pInt, ext_msg = 'state indices not properly set ('//PLASTICITY_NONLOCAL_label//')')
wrong initialization order, thanks to N Grilli for reporting the bug
2016-01-06 22:16:37 +05:30
endif myPhase2
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
enddo initializeInstances
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
initialization can be done internally
2019-02-20 22:20:26 +05:30
contains
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
initialization can be done internally
2019-02-20 22:20:26 +05:30
subroutine stateInit(phase,NofMyPhase)
use math, only: &
math_sampleGaussVar
use mesh, only: &
theMesh, &
mesh_ipVolume
use material, only: &
material_phase, &
phase_plasticityInstance, &
phasememberAt
implicit none
integer(pInt),intent(in) ::&
phase, &
NofMyPhase
integer(pInt) :: &
e, &
i, &
f, &
from, &
upto, &
s, &
instance, &
phasemember
real(pReal), dimension(2) :: &
noise, &
rnd
real(pReal) :: &
meanDensity, &
totalVolume, &
densityBinning, &
minimumIpVolume
real(pReal), dimension(NofMyPhase) :: &
volume
instance = phase_plasticityInstance(phase)
associate(prm => param(instance), stt => state(instance))
! randomly distribute dislocation segments on random slip system and of random type in the volume
if (prm%rhoSglRandom > 0.0_pReal) then
! get the total volume of the instance
do e = 1_pInt,theMesh%nElems
do i = 1_pInt,theMesh%elem%nIPs
if (material_phase(1,i,e) == phase) volume(phasememberAt(1,i,e)) = mesh_ipVolume(i,e)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
enddo
initialization can be done internally
2019-02-20 22:20:26 +05:30
enddo
totalVolume = sum(volume)
minimumIPVolume = minval(volume)
densityBinning = prm%rhoSglRandomBinning / minimumIpVolume ** (2.0_pReal / 3.0_pReal)
! subsequently fill random ips with dislocation segments until we reach the desired overall density
meanDensity = 0.0_pReal
do while(meanDensity < prm%rhoSglRandom)
call random_number(rnd)
phasemember = nint(rnd(1)*real(NofMyPhase,pReal) + 0.5_pReal,pInt)
s = nint(rnd(2)*real(prm%totalNslip,pReal)*4.0_pReal + 0.5_pReal,pInt)
meanDensity = meanDensity + densityBinning * volume(phasemember) / totalVolume
stt%rhoSglMobile(s,phasemember) = densityBinning
enddo
! homogeneous distribution of density with some noise
else
do e = 1_pInt, NofMyPhase
do f = 1_pInt,size(prm%Nslip,1)
from = 1_pInt + sum(prm%Nslip(1:f-1_pInt))
upto = sum(prm%Nslip(1:f))
do s = from,upto
noise = [math_sampleGaussVar(0.0_pReal, prm%rhoSglScatter), &
math_sampleGaussVar(0.0_pReal, prm%rhoSglScatter)]
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_sgl_mob_edg_pos(s,e) = prm%rhoSglEdgePos0(f) + noise(1)
stt%rho_sgl_mob_edg_neg(s,e) = prm%rhoSglEdgeNeg0(f) + noise(1)
stt%rho_sgl_mob_scr_pos(s,e) = prm%rhoSglScrewPos0(f) + noise(2)
stt%rho_sgl_mob_scr_neg(s,e) = prm%rhoSglScrewNeg0(f) + noise(2)
initialization can be done internally
2019-02-20 22:20:26 +05:30
enddo
more systematic names
2019-03-16 13:25:25 +05:30
stt%rho_dip_edg(from:upto,e) = prm%rhoDipEdge0(f)
stt%rho_dip_scr(from:upto,e) = prm%rhoDipScrew0(f)
initialization can be done internally
2019-02-20 22:20:26 +05:30
enddo
enddo
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
endif
initialization can be done internally
2019-02-20 22:20:26 +05:30
end associate
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
initialization can be done internally
2019-02-20 22:20:26 +05:30
end subroutine stateInit
convergence of state in crystallite is now tested as follows: (state < relevant state) or (residuum < relative tolerance * state) since the relevant value for the state variables depend on their nature and can vary by large scales (e.g. volume fraction: 1e-10, dislocation density: 1e5) it is not possible to set a unique value. instead the constitutive law has to decide what is relevant. therefore, all constitutive laws now read in parameters from the material.config that determine the values for relevantState [@luc: in dislobased law relevant State is for the moment generally set to 1e-200, so no additional parameters necessary in material.config. if you also want this feature, we can still implement it, no big deal] - added sanity checks in constitutive_nonlocal.f90 - corrected coordinate transformation for backstress calculation in constitutive_nonlocal.f90 - corrected equations for evolution of dipole dislocation densities (athermal annihilation and formation by glide)
2009-09-18 21:07:14 +05:30
initialization can be done internally
2019-02-20 22:20:26 +05:30
end subroutine plastic_nonlocal_init
convergence of state in crystallite is now tested as follows: (state < relevant state) or (residuum < relative tolerance * state) since the relevant value for the state variables depend on their nature and can vary by large scales (e.g. volume fraction: 1e-10, dislocation density: 1e5) it is not possible to set a unique value. instead the constitutive law has to decide what is relevant. therefore, all constitutive laws now read in parameters from the material.config that determine the values for relevantState [@luc: in dislobased law relevant State is for the moment generally set to 1e-200, so no additional parameters necessary in material.config. if you also want this feature, we can still implement it, no big deal] - added sanity checks in constitutive_nonlocal.f90 - corrected coordinate transformation for backstress calculation in constitutive_nonlocal.f90 - corrected equations for evolution of dipole dislocation densities (athermal annihilation and formation by glide)
2009-09-18 21:07:14 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
remove dotTemperature (returned always 0 anyway) to make it easier to replace it with a heating rate funtction remove potentially dangerous short circuiting in homogenization files added doxygen comment for nonlocal (giving the functions a name) fixed wrong definition of maxnchungs introcuded into dislotwin with last commit, causes trouble with hex
2013-10-09 11:42:16 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief calculates quantities characterizing the microstructure
!--------------------------------------------------------------------------------------------------
same name in all models
2019-02-20 19:24:26 +05:30
subroutine plastic_nonlocal_dependentState(Fe, Fp, 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
dEq0
polishing
2013-05-23 17:55:56 +05:30
use IO, only: &
IO_error
use math, only: &
pi, &
math_mul33x3, &
math_mul3x3, &
was not needed
2019-02-17 02:39:06 +05:30
math_inv33
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
#ifdef DEBUG
polishing
2013-05-23 17:55:56 +05:30
use debug, only: &
debug_level, &
debug_constitutive, &
debug_levelExtensive, &
debug_levelSelective, &
debug_i, &
debug_e
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
#endif
polishing
2013-05-23 17:55:56 +05:30
use mesh, only: &
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
theMesh, &
polishing
2013-05-23 17:55:56 +05:30
mesh_ipNeighborhood, &
mesh_ipCoordinates, &
mesh_ipVolume, &
mesh_ipAreaNormal, &
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
mesh_ipArea
polishing
2013-05-23 17:55:56 +05:30
use material, only: &
material_phase, &
phase_localPlasticity, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
plasticState, &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt, &
polishing
2013-05-23 17:55:56 +05:30
phase_plasticityInstance
use lattice, only: &
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
LATTICE_bcc_ID, &
don't parse material.config any more
2019-02-20 23:33:20 +05:30
LATTICE_fcc_ID, &
lattice_structure
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
implicit none
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
integer(pInt), intent(in) :: ip, & ! current integration point
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
el ! current element
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
real(pReal), dimension(3,3), intent(in) :: &
Fe, & ! elastic deformation gradient
Fp ! elastic deformation gradient
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
integer(pInt) :: &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph, & !< phase
of, & !< offset
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
np, & !< neighbor phase
no !< nieghbor offset
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
don't parse material.config any more
2019-02-20 23:33:20 +05:30
integer(pInt) ns, neighbor_el, & ! element number of neighboring material point
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbor_ip, & ! integration point of neighboring material point
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
instance, & ! my instance of this plasticity
neighbor_instance, & ! instance of this plasticity of neighboring material point
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
c, & ! index of dilsocation character (edge, screw)
s, & ! slip system index
t, & ! index of dilsocation type (e+, e-, s+, s-, used e+, used e-, used s+, used s-)
dir, &
hardening coefficients for fcc are density dependent (line tension effect, Devincre, Kubin, Hoc; 2006; Physical analyses of crystal plasticity by DD simulations) fixed bug with thermal annihilation producing negative density in case of very small dipole density and high climb velocity
2012-10-04 23:38:40 +05:30
n, &
correction of hardening coefficients also enabled for bcc for fcc: now applied to all hardening coefficients, not only hirth, lomer, and glissile
2013-08-14 17:14:30 +05:30
nRealNeighbors ! number of really existing neighbors
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
integer(pInt), dimension(2) :: neighbors
gfortran complaint about implicit casting,floating point comparison, and unused imported variables. additionally changed use of math_invert33 to math_inv33 if det is not needed
2015-04-11 00:39:26 +05:30
real(pReal) FVsize, &
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
correction
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
real(pReal), dimension(2) :: rhoExcessGradient, &
rhoExcessGradient_over_rho, &
rhoTotal
fixed bug in backstress calculation for elements with periodic neighbors
2013-05-23 18:06:48 +05:30
real(pReal), dimension(3) :: rhoExcessDifferences, &
normal_latticeConf
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
real(pReal), dimension(3,3) :: invFe, & ! inverse of elastic deformation gradient
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
invFp, & ! inverse of plastic deformation gradient
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
connections, &
invConnections
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
real(pReal), dimension(3,theMesh%elem%nIPneighbors) :: &
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
connection_latticeConf
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(2,totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el)))) :: &
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
rhoExcess
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el)))) :: &
rho_edg_delta, &
rho_scr_delta
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),10) :: &
rho, &
rho_neighbor
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),2) :: &
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
rhoDip ! dipole dislocation density (edge, screw)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),8) :: &
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
rhoSgl ! single dislocation density (edge+, edge-, screw+, screw-, used edge+, used edge-, used screw+, used screw-)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))), &
totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el)))) :: &
make correction of hardening coefficients thread safe
2012-10-05 21:35:51 +05:30
myInteractionMatrix ! corrected slip interaction matrix
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),theMesh%elem%nIPneighbors) :: &
rho_edg_delta_neighbor, &
rho_scr_delta_neighbor, &
rho_edg_sum_neighbor, &
rho_scr_sum_neighbor
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
real(pReal), dimension(2,maxval(totalNslip),theMesh%elem%nIPneighbors) :: &
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
neighbor_rhoExcess, & ! excess density at neighboring material point
neighbor_rhoTotal ! total density at neighboring material point
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(3,totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),2) :: &
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
m ! direction of dislocation motion
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
ph = phaseAt(1,ip,el)
of = phasememberAt(1,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)
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
associate(prm => param(instance),dst => microstructure(instance), stt => state(instance))
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
ns = prm%totalNslip
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
rho = getRho(instance,of,ip,el)
using new funtionality to get rho
2019-03-16 19:38:50 +05:30
rhoSgl = rho(:,sgl)
rhoDip = rho(:,dip)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
stt%rho_forest(:,of) = matmul(prm%forestProjection_Edge, sum(abs(rho(:,edg)),2)) &
+ matmul(prm%forestProjection_Screw,sum(abs(rho(:,scr)),2))
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
!*** calculate the threshold shear stress for dislocation slip
correction of hardening coefficients also enabled for bcc for fcc: now applied to all hardening coefficients, not only hirth, lomer, and glissile
2013-08-14 17:14:30 +05:30
!*** coefficients are corrected for the line tension effect
!*** (see Kubin,Devincre,Hoc; 2008; Modeling dislocation storage rates and mean free paths in face-centered cubic crystals)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
if (lattice_structure(ph) == LATTICE_bcc_ID .or. lattice_structure(ph) == LATTICE_fcc_ID) then ! only fcc and bcc
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
do s = 1_pInt,ns
cleaning
2019-02-18 14:58:08 +05:30
correction = ( 1.0_pReal - prm%linetensionEffect &
+ prm%linetensionEffect &
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
* log(0.35_pReal * prm%burgers(s) * sqrt(max(stt%rho_forest(s,of),prm%significantRho))) &
cleaning
2019-02-18 14:58:08 +05:30
/ log(0.35_pReal * prm%burgers(s) * 1e6_pReal)) ** 2.0_pReal
bugfix
2019-03-12 04:25:04 +05:30
myInteractionMatrix(1:ns,s) = correction * prm%interactionSlipSlip(1:ns,s)
hardening coefficients for fcc are density dependent (line tension effect, Devincre, Kubin, Hoc; 2006; Physical analyses of crystal plasticity by DD simulations) fixed bug with thermal annihilation producing negative density in case of very small dipole density and high climb velocity
2012-10-04 23:38:40 +05:30
enddo
bugfix
2019-03-12 04:25:04 +05:30
else
myInteractionMatrix = prm%interactionSlipSlip
hardening coefficients for fcc are density dependent (line tension effect, Devincre, Kubin, Hoc; 2006; Physical analyses of crystal plasticity by DD simulations) fixed bug with thermal annihilation producing negative density in case of very small dipole density and high climb velocity
2012-10-04 23:38:40 +05:30
endif
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
forall (s = 1_pInt:ns) &
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
dst%tau_threshold(s,of) = prm%mu * prm%burgers(s) &
more functions relying on getRho
2019-03-16 20:16:39 +05:30
* sqrt(dot_product(sum(abs(rho),2), myInteractionMatrix(1:ns,s)))
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
!*** calculate the dislocation stress of the neighboring excess dislocation densities
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
!*** zero for material points of local plasticity
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
dst%tau_back(:,of) = 0.0_pReal
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
same name in all models
2019-02-20 19:24:26 +05:30
!#################################################################################################
!#################################################################################################
! ToDo: MD: this is most likely only correct for F_i = I
!#################################################################################################
!#################################################################################################
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
if (.not. phase_localPlasticity(ph) .and. prm%shortRangeStressCorrection) then
gfortran complaint about implicit casting,floating point comparison, and unused imported variables. additionally changed use of math_invert33 to math_inv33 if det is not needed
2015-04-11 00:39:26 +05:30
invFe = math_inv33(Fe)
invFp = math_inv33(Fp)
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
rho_edg_delta = rho(:,mob_edg_pos) - rho(:,mob_edg_neg)
rho_scr_delta = rho(:,mob_scr_pos) - rho(:,mob_scr_neg)
rhoExcess(1,1:ns) = rho_edg_delta
rhoExcess(2,1:ns) = rho_scr_delta
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
FVsize = mesh_ipVolume(ip,el) ** (1.0_pReal/3.0_pReal)
* now able to introduce some scatter in the initial single dislocation density (only for nonlocal model!) ; setting the parameter "rhoSglScatter" to a positive value generates a gauss distribution for the dislocation density with standard deviation equal to "rhoSglScatter" * dislocation stress calculation is only done for nonlocal constitution ("/nonlocal/" keyword is present in material.config)
2011-02-04 21:11:32 +05:30
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
!* loop through my neighborhood and get the connection vectors (in lattice frame) and the excess densities
total density used in backstress calculation now based on average of neighborhood fixed small bug in state_init: random distribution of density was probably not working correctly, as some variables were not properly initialized
2013-03-27 18:34:01 +05:30
nRealNeighbors = 0_pInt
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbor_rhoTotal = 0.0_pReal
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
do n = 1_pInt,theMesh%elem%nIPneighbors
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbor_el = mesh_ipNeighborhood(1,n,ip,el)
neighbor_ip = mesh_ipNeighborhood(2,n,ip,el)
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
np = phaseAt(1,neighbor_ip,neighbor_el)
no = phasememberAt(1,neighbor_ip,neighbor_el)
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
if (neighbor_el > 0 .and. neighbor_ip > 0) then
cleaning
2019-02-18 14:58:08 +05:30
neighbor_instance = phase_plasticityInstance(material_phase(1,neighbor_ip,neighbor_el))
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
if (neighbor_instance == instance) then
fixed bug in backstress calculation for elements with periodic neighbors
2013-05-23 18:06:48 +05:30
nRealNeighbors = nRealNeighbors + 1_pInt
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
rho_neighbor = getRho(instance,no,neighbor_ip,neighbor_el)
rho_edg_delta_neighbor(:,n) = rho_neighbor(:,mob_edg_pos) - rho_neighbor(:,mob_edg_neg)
rho_scr_delta_neighbor(:,n) = rho_neighbor(:,mob_scr_pos) - rho_neighbor(:,mob_scr_neg)
combined some state indices to an array with a more generic name
2013-05-24 14:32:30 +05:30
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbor_rhoExcess(c,s,n) = &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
max(plasticState(np)%state(iRhoU(s,2*c-1,neighbor_instance),no), 0.0_pReal) & ! positive mobiles
- max(plasticState(np)%state(iRhoU(s,2*c,neighbor_instance), no), 0.0_pReal) ! negative mobiles
removed few bugs from nonlocal (newstate)
2014-06-24 14:54:19 +05:30
neighbor_rhoTotal(c,s,n) = &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
max(plasticState(np)%state(iRhoU(s,2*c-1,neighbor_instance),no), 0.0_pReal) & ! positive mobiles
+ max(plasticState(np)%state(iRhoU(s,2*c,neighbor_instance), no), 0.0_pReal) & ! negative mobiles
+ abs(plasticState(np)%state(iRhoB(s,2*c-1,neighbor_instance),no)) & ! positive deads
+ abs(plasticState(np)%state(iRhoB(s,2*c,neighbor_instance), no)) & ! negative deads
+ max(plasticState(np)%state(iRhoD(s,c,neighbor_instance), no), 0.0_pReal) ! dipoles
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
fixed bug in backstress calculation for elements with periodic neighbors
2013-05-23 18:06:48 +05:30
endforall
connection_latticeConf(1:3,n) = &
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
math_mul33x3(invFe, mesh_ipCoordinates(1:3,neighbor_ip,neighbor_el) &
fixed bug in backstress calculation for elements with periodic neighbors
2013-05-23 18:06:48 +05:30
- mesh_ipCoordinates(1:3,ip,el))
was not needed
2019-02-17 02:39:06 +05:30
normal_latticeConf = math_mul33x3(transpose(invFp), mesh_ipAreaNormal(1:3,n,ip,el))
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
if (math_mul3x3(normal_latticeConf,connection_latticeConf(1:3,n)) < 0.0_pReal) & ! neighboring connection points in opposite direction to face normal: must be periodic image
fixed bug in backstress calculation for elements with periodic neighbors
2013-05-23 18:06:48 +05:30
connection_latticeConf(1:3,n) = normal_latticeConf * mesh_ipVolume(ip,el) &
/ mesh_ipArea(n,ip,el) ! instead take the surface normal scaled with the diameter of the cell
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
else
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
! local neighbor or different lattice structure or different constitution instance -> use central values instead
connection_latticeConf(1:3,n) = 0.0_pReal
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbor_rhoExcess(1:2,1:ns,n) = rhoExcess
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
rho_edg_delta_neighbor(:,n) = rho_scr_delta
rho_scr_delta_neighbor(:,n) = rho_scr_delta
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
endif
else
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
! free surface -> use central values instead
connection_latticeConf(1:3,n) = 0.0_pReal
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbor_rhoExcess(1:2,1:ns,n) = rhoExcess
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
rho_edg_delta_neighbor(:,n) = rho_scr_delta
rho_scr_delta_neighbor(:,n) = rho_scr_delta
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
endif
enddo
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
!* loop through the slip systems and calculate the dislocation gradient by
!* 1. interpolation of the excess density in the neighorhood
!* 2. interpolation of the dead dislocation density in the central volume
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
don't parse material.config any more
2019-02-20 23:33:20 +05:30
m(1:3,1:ns,1) = prm%slip_direction
m(1:3,1:ns,2) = -prm%slip_transverse
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
do s = 1_pInt,ns
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
! gradient from interpolation of neighboring excess density ...
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
do c = 1_pInt,2_pInt
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
do dir = 1_pInt,3_pInt
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
neighbors(1) = 2_pInt * dir - 1_pInt
neighbors(2) = 2_pInt * dir
connections(dir,1:3) = connection_latticeConf(1:3,neighbors(1)) &
- connection_latticeConf(1:3,neighbors(2))
rhoExcessDifferences(dir) = neighbor_rhoExcess(c,s,neighbors(1)) &
- neighbor_rhoExcess(c,s,neighbors(2))
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
enddo
gfortran complaint about implicit casting,floating point comparison, and unused imported variables. additionally changed use of math_invert33 to math_inv33 if det is not needed
2015-04-11 00:39:26 +05:30
invConnections = math_inv33(connections)
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
if (all(dEq0(invConnections))) &
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
call IO_error(-1_pInt,ext_msg='back stress calculation: inversion error')
polishing
2013-05-23 17:55:56 +05:30
rhoExcessGradient(c) = math_mul3x3(m(1:3,s,c), &
math_mul33x3(invConnections,rhoExcessDifferences))
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
enddo
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
! ... plus gradient from deads ...
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
do t = 1_pInt,4_pInt
c = (t - 1_pInt) / 2_pInt + 1_pInt
rhoExcessGradient(c) = rhoExcessGradient(c) + rhoSgl(s,t+4_pInt) / FVsize
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
enddo
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
! ... normalized with the total density ...
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
rhoExcessGradient_over_rho = 0.0_pReal
total density used in backstress calculation now based on average of neighborhood fixed small bug in state_init: random distribution of density was probably not working correctly, as some variables were not properly initialized
2013-03-27 18:34:01 +05:30
forall (c = 1_pInt:2_pInt) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
rhoTotal(c) = (sum(abs(rhoSgl(s,[2*c-1,2*c,2*c+3,2*c+4]))) + rhoDip(s,c) &
+ sum(neighbor_rhoTotal(c,s,:))) / real(1_pInt + nRealNeighbors,pReal)
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
forall (c = 1_pInt:2_pInt, rhoTotal(c) > 0.0_pReal) &
rhoExcessGradient_over_rho(c) = rhoExcessGradient(c) / rhoTotal(c)
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
! ... gives the local stress correction when multiplied with a factor
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
dst%tau_back(s,of) = - prm%mu * prm%burgers(s) / (2.0_pReal * pi) &
cleaning
2019-02-18 14:58:08 +05:30
* (rhoExcessGradient_over_rho(1) / (1.0_pReal - prm%nu) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
+ rhoExcessGradient_over_rho(2))
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
enddo
endif
Internal stress calculation in nonlocal model: instead of integration of excess gradients (->Bayley) we now sum up contributions from adjacent superdislocations within a certain radius R. When periodicity is used, also periodic images are considered in stress evaluation.
2011-03-29 13:04:33 +05:30
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
In crystallite: for state integrators 2 and 3 the deltaState always has to be done at the beginning of the integration, not at the end; otherwise the stiffness calculation can be completely wrong, when the state is changed after the stress integration for the central solution. Also changed some debugging levels in crystallite and mainly in constitutive_nonlocal
2012-10-22 13:29:35 +05:30
if (iand(debug_level(debug_constitutive),debug_levelExtensive) /= 0_pInt &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
.and. ((debug_e == el .and. debug_i == ip)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_constitutive),debug_levelSelective) /= 0_pInt)) then
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
write(6,'(/,a,i8,1x,i2,1x,i1,/)') '<< CONST >> nonlocal_microstructure at el ip ',el,ip
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
write(6,'(a,/,12x,12(e10.3,1x))') '<< CONST >> rhoForest', stt%rho_forest(:,of)
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
write(6,'(a,/,12x,12(f10.5,1x))') '<< CONST >> tauThreshold / MPa', dst%tau_threshold(:,of)*1e-6
write(6,'(a,/,12x,12(f10.5,1x),/)') '<< CONST >> tauBack / MPa', dst%tau_back(:,of)*1e-6
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
endif
#endif
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
end associate
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
same name in all models
2019-02-20 19:24:26 +05:30
end subroutine plastic_nonlocal_dependentState
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
remove dotTemperature (returned always 0 anyway) to make it easier to replace it with a heating rate funtction remove potentially dangerous short circuiting in homogenization files added doxygen comment for nonlocal (giving the functions a name) fixed wrong definition of maxnchungs introcuded into dislotwin with last commit, causes trouble with hex
2013-10-09 11:42:16 +05:30
!--------------------------------------------------------------------------------------------------
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!> @brief calculates kinetics
remove dotTemperature (returned always 0 anyway) to make it easier to replace it with a heating rate funtction remove potentially dangerous short circuiting in homogenization files added doxygen comment for nonlocal (giving the functions a name) fixed wrong definition of maxnchungs introcuded into dislotwin with last commit, causes trouble with hex
2013-10-09 11:42:16 +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
subroutine plastic_nonlocal_kinetics(v, dv_dtau, dv_dtauNS, tau, tauNS, &
leaner interface
2019-02-22 02:02:22 +05:30
tauThreshold, c, Temperature, instance, of)
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
implicit none
leaner interface
2019-02-22 02:02:22 +05:30
integer(pInt), intent(in) :: c, & !< dislocation character (1:edge, 2:screw)
instance, of
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), intent(in) :: Temperature !< temperature
leaner interface
2019-02-22 02:02:22 +05:30
real(pReal), dimension(param(instance)%totalNslip), &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
intent(in) :: tau, & !< resolved external shear stress (without non Schmid effects)
tauNS, & !< resolved external shear stress (including non Schmid effects)
tauThreshold !< threshold shear stress
constitutive_nonlocal: dislocation velocities are stored in the state, so we actually now have three "parts" of the state, the basic states that are updated by "constitutive_dotState" come first, then the dependent states that are calculated by "constitutive_microstructure" follow, and finally we have a last part reserved for other variables that just use the memory reserved by the state array and are updated somewhere else. constitutive: LpAndItsTangent does not need the full state, but only the local state, so changed that at least for the nonlocal constitutive law
2011-11-04 18:42:17 +05:30
leaner interface
2019-02-22 02:02:22 +05:30
real(pReal), dimension(param(instance)%totalNslip), &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
intent(out) :: v, & !< velocity
dv_dtau, & !< velocity derivative with respect to resolved shear stress (without non Schmid contributions)
dv_dtauNS !< velocity derivative with respect to resolved shear stress (including non Schmid contributions)
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
leaner interface
2019-02-22 02:02:22 +05:30
integer(pInt) :: ns, & !< short notation for the total number of active slip systems
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
s !< index of my current slip system
real(pReal) tauRel_P, &
tauRel_S, &
tauEff, & !< effective shear stress
tPeierls, & !< waiting time in front of a peierls barriers
tSolidSolution, & !< waiting time in front of a solid solution obstacle
vViscous, & !< viscous glide velocity
dtPeierls_dtau, & !< derivative with respect to resolved shear stress
dtSolidSolution_dtau, & !< derivative with respect to resolved shear stress
meanfreepath_S, & !< mean free travel distance for dislocations between two solid solution obstacles
meanfreepath_P, & !< mean free travel distance for dislocations between two Peierls barriers
jumpWidth_P, & !< depth of activated area
jumpWidth_S, & !< depth of activated area
activationLength_P, & !< length of activated dislocation line
activationLength_S, & !< length of activated dislocation line
activationVolume_P, & !< volume that needs to be activated to overcome barrier
activationVolume_S, & !< volume that needs to be activated to overcome barrier
activationEnergy_P, & !< energy that is needed to overcome barrier
activationEnergy_S, & !< energy that is needed to overcome barrier
criticalStress_P, & !< maximum obstacle strength
criticalStress_S, & !< maximum obstacle strength
mobility !< dislocation mobility
corrected kinetics law and changed parameters. For solid solution hardening there are 3 parameters: the activation energy, the concentration of obstacles that determines the activation length and meanfreepath, and the obstacle size that determines the activation volume. For the Peierls mechanism there is: the width of doublekinks that determines the activation volume and the Peierls stress for edge and screw. Still testing needed to check whether the current formulation makes sense or not.
2012-02-03 18:20:54 +05:30
cleaning
2019-02-18 14:58:08 +05:30
associate(prm => param(instance))
leaner interface
2019-02-22 02:02:22 +05:30
ns = prm%totalNslip
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
v = 0.0_pReal
dv_dtau = 0.0_pReal
dv_dtauNS = 0.0_pReal
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
if (Temperature > 0.0_pReal) then
do s = 1_pInt,ns
if (abs(tau(s)) > tauThreshold(s)) then
in kinetics: non schmid stresses only influence peierls mechanism, but not solid solution hardening; as a result the derivative of the velocity with respect to the resolved stress has to be split into a Schmid and a non-Schmid part
2013-08-21 17:51:52 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* Peierls contribution
!* Effective stress includes non Schmid constributions
!* The derivative only gives absolute values; the correct sign is taken care of in the formula for the derivative of the velocity
tauEff = max(0.0_pReal, abs(tauNS(s)) - tauThreshold(s)) ! ensure that the effective stress is positive
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
meanfreepath_P = prm%burgers(s)
jumpWidth_P = prm%burgers(s)
activationLength_P = prm%doublekinkwidth *prm%burgers(s)
activationVolume_P = activationLength_P * jumpWidth_P * prm%burgers(s)
transition to param structure
2019-02-20 13:43:50 +05:30
criticalStress_P = prm%peierlsStress(s,c)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
activationEnergy_P = criticalStress_P * activationVolume_P
tauRel_P = min(1.0_pReal, tauEff / criticalStress_P) ! ensure that the activation probability cannot become greater than one
cleaning
2019-02-18 14:58:08 +05:30
tPeierls = 1.0_pReal / prm%fattack &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
* exp(activationEnergy_P / (KB * Temperature) &
using more parameters from smart structure
2019-02-19 15:01:14 +05:30
* (1.0_pReal - tauRel_P**prm%p)**prm%q)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
if (tauEff < criticalStress_P) then
using more parameters from smart structure
2019-02-19 15:01:14 +05:30
dtPeierls_dtau = tPeierls * prm%p * prm%q * activationVolume_P / (KB * Temperature) &
* (1.0_pReal - tauRel_P**prm%p)**(prm%q-1.0_pReal) &
* tauRel_P**(prm%p-1.0_pReal)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
else
dtPeierls_dtau = 0.0_pReal
endif
Reworked kinetics. Now there is a universal law which can be used for both fcc and bcc (and probably even hcp). It mainly consists of an athermal forest cutting part , solid solution and peierls as thermally activated processes, and viscous glide. Therefore, lots of new parameters in the material.config. Not sure yet if the values make sense though. Also renamed some of the old parameters. Unknown constitutive output raises error.
2012-01-25 22:34:37 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* Contribution from solid solution strengthening
!* The derivative only gives absolute values; the correct sign is taken care of in the formula for the derivative of the velocity
Reworked kinetics. Now there is a universal law which can be used for both fcc and bcc (and probably even hcp). It mainly consists of an athermal forest cutting part , solid solution and peierls as thermally activated processes, and viscous glide. Therefore, lots of new parameters in the material.config. Not sure yet if the values make sense though. Also renamed some of the old parameters. Unknown constitutive output raises error.
2012-01-25 22:34:37 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
tauEff = abs(tau(s)) - tauThreshold(s)
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
meanfreepath_S = prm%burgers(s) / sqrt(prm%solidSolutionConcentration)
jumpWidth_S = prm%solidSolutionSize * prm%burgers(s)
activationLength_S = prm%burgers(s) / sqrt(prm%solidSolutionConcentration)
activationVolume_S = activationLength_S * jumpWidth_S * prm%burgers(s)
activationEnergy_S = prm%solidSolutionEnergy
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
criticalStress_S = activationEnergy_S / activationVolume_S
tauRel_S = min(1.0_pReal, tauEff / criticalStress_S) ! ensure that the activation probability cannot become greater than one
cleaning
2019-02-18 14:58:08 +05:30
tSolidSolution = 1.0_pReal / prm%fattack &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
* exp(activationEnergy_S / (KB * Temperature) &
using more parameters from smart structure
2019-02-19 15:01:14 +05:30
* (1.0_pReal - tauRel_S**prm%p)**prm%q)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
if (tauEff < criticalStress_S) then
using more parameters from smart structure
2019-02-19 15:01:14 +05:30
dtSolidSolution_dtau = tSolidSolution * prm%p * prm%q &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
* activationVolume_S / (KB * Temperature) &
using more parameters from smart structure
2019-02-19 15:01:14 +05:30
* (1.0_pReal - tauRel_S**prm%p)**(prm%q-1.0_pReal) &
* tauRel_S**(prm%p-1.0_pReal)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
else
dtSolidSolution_dtau = 0.0_pReal
endif
Reworked kinetics. Now there is a universal law which can be used for both fcc and bcc (and probably even hcp). It mainly consists of an athermal forest cutting part , solid solution and peierls as thermally activated processes, and viscous glide. Therefore, lots of new parameters in the material.config. Not sure yet if the values make sense though. Also renamed some of the old parameters. Unknown constitutive output raises error.
2012-01-25 22:34:37 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* viscous glide velocity
tauEff = abs(tau(s)) - tauThreshold(s)
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
mobility = prm%burgers(s) / prm%viscosity
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
vViscous = mobility * tauEff
Reworked kinetics. Now there is a universal law which can be used for both fcc and bcc (and probably even hcp). It mainly consists of an athermal forest cutting part , solid solution and peierls as thermally activated processes, and viscous glide. Therefore, lots of new parameters in the material.config. Not sure yet if the values make sense though. Also renamed some of the old parameters. Unknown constitutive output raises error.
2012-01-25 22:34:37 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* Mean velocity results from waiting time at peierls barriers and solid solution obstacles with respective meanfreepath of
!* free flight at glide velocity in between.
!* adopt sign from resolved stress
added relativistic correction of velocity (maximum velocity given by parameter in material.config); probability of thermal activation in velocity law not allowed to be greater than one. output of creation rate for edge jogs now for own system, not collinear. check for negative densities in dotState now uses absoluteToleranceRho instead of significantRho.
2012-08-30 13:03:13 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
v(s) = sign(1.0_pReal,tau(s)) &
/ (tPeierls / meanfreepath_P + tSolidSolution / meanfreepath_S + 1.0_pReal / vViscous)
dv_dtau(s) = v(s) * v(s) * (dtSolidSolution_dtau / meanfreepath_S &
+ mobility / (vViscous * vViscous))
dv_dtauNS(s) = v(s) * v(s) * dtPeierls_dtau / meanfreepath_P
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
#ifdef DEBUGTODO
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> tauThreshold / MPa', tauThreshold * 1e-6_pReal
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> tau / MPa', tau * 1e-6_pReal
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> tauNS / MPa', tauNS * 1e-6_pReal
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> v / mm/s', v * 1e3
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
write(6,'(a,/,12x,12(e12.5,1x))') '<< CONST >> dv_dtau', dv_dtau
write(6,'(a,/,12x,12(e12.5,1x))') '<< CONST >> dv_dtauNS', dv_dtauNS
endif
#endif
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
cleaning
2019-02-18 14:58:08 +05:30
end associate
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_nonlocal_kinetics
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
remove dotTemperature (returned always 0 anyway) to make it easier to replace it with a heating rate funtction remove potentially dangerous short circuiting in homogenization files added doxygen comment for nonlocal (giving the functions a name) fixed wrong definition of maxnchungs introcuded into dislotwin with last commit, causes trouble with hex
2013-10-09 11:42:16 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief calculates plastic velocity gradient and its tangent
!--------------------------------------------------------------------------------------------------
only used internally
2019-02-17 19:00:58 +05:30
subroutine plastic_nonlocal_LpAndItsTangent(Lp, dLp_dMp, &
limiting inter-module dependencies
2019-02-19 15:13:04 +05:30
Mp, Temperature, volume, ip, el)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
use math, only: &
math_mul33xx33
use material, only: &
material_phase, &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
plasticState, &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt,&
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
phase_plasticityInstance
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
implicit none
took some gfortran complaints serious (unused imports, implicit castings)
2015-04-11 17:17:33 +05:30
integer(pInt), intent(in) :: ip, & !< current integration point
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
el !< current element number
limiting inter-module dependencies
2019-02-19 15:13:04 +05:30
real(pReal), intent(in) :: Temperature, & !< temperature
volume !< volume of the materialpoint
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
real(pReal), dimension(3,3), intent(in) :: Mp
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), dimension(3,3), intent(out) :: Lp !< plastic velocity gradient
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
real(pReal), dimension(3,3,3,3), intent(out) :: dLp_dMp !< derivative of Lp with respect to Tstar (9x9 matrix)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
integer(pInt) instance, & !< current instance of this plasticity
ns, & !< short notation for the total number of active slip systems
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
i, &
j, &
k, &
l, &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph, & !phase number
of, & !offset
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
t, & !< dislocation type
cleaning
2019-02-18 14:58:08 +05:30
s !< index of my current slip system
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),8) :: &
using new funtionality to get rho
2019-03-16 19:38:50 +05:30
rhoSgl !< single dislocation densities (including blocked)
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),10) :: &
rho
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),4) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
v, & !< velocity
tauNS, & !< resolved shear stress including non Schmid and backstress terms
dv_dtau, & !< velocity derivative with respect to the shear stress
dv_dtauNS !< velocity derivative with respect to the shear stress
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el)))) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
tau, & !< resolved shear stress including backstress terms
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
gdotTotal !< shear rate
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!*** shortcut for mapping
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
ph = phaseAt(1_pInt,ip,el)
of = phasememberAt(1_pInt,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)
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
associate(prm => param(instance),dst=>microstructure(instance))
was not needed
2019-02-17 02:39:06 +05:30
ns = prm%totalNslip
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
!*** shortcut to state variables
using new funtionality to get rho
2019-03-16 19:38:50 +05:30
rho = getRho(instance,of,ip,el)
rhoSgl = rho(:,sgl)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!*** get resolved shear stress
!*** for screws possible non-schmid contributions are also taken into account
do s = 1_pInt,ns
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
tau(s) = math_mul33xx33(Mp, prm%Schmid(1:3,1:3,s))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
tauNS(s,1) = tau(s)
tauNS(s,2) = tau(s)
if (tau(s) > 0.0_pReal) then
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
tauNS(s,3) = math_mul33xx33(Mp, +prm%nonSchmid_pos(1:3,1:3,s))
tauNS(s,4) = math_mul33xx33(Mp, -prm%nonSchmid_neg(1:3,1:3,s))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
else
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
tauNS(s,3) = math_mul33xx33(Mp, +prm%nonSchmid_neg(1:3,1:3,s))
tauNS(s,4) = math_mul33xx33(Mp, -prm%nonSchmid_pos(1:3,1:3,s))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
endif
enddo
forall (t = 1_pInt:4_pInt) &
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tauNS(1:ns,t) = tauNS(1:ns,t) + dst%tau_back(:,of)
tau = tau + dst%tau_back(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!*** get dislocation velocity and its tangent and store the velocity in the state array
! edges
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
call plastic_nonlocal_kinetics(v(1:ns,1), dv_dtau(1:ns,1), dv_dtauNS(1:ns,1), &
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau(1:ns), tauNS(1:ns,1), dst%tau_Threshold(1:ns,of), &
leaner interface
2019-02-22 02:02:22 +05:30
1_pInt, Temperature, instance, of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
v(1:ns,2) = v(1:ns,1)
dv_dtau(1:ns,2) = dv_dtau(1:ns,1)
dv_dtauNS(1:ns,2) = dv_dtauNS(1:ns,1)
!screws
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
if (size(prm%nonSchmidCoeff) == 0_pInt) then ! no non-Schmid contributions
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
forall(t = 3_pInt:4_pInt)
v(1:ns,t) = v(1:ns,1)
dv_dtau(1:ns,t) = dv_dtau(1:ns,1)
dv_dtauNS(1:ns,t) = dv_dtauNS(1:ns,1)
endforall
else ! take non-Schmid contributions into account
do t = 3_pInt,4_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
call plastic_nonlocal_kinetics(v(1:ns,t), dv_dtau(1:ns,t), dv_dtauNS(1:ns,t), &
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau(1:ns), tauNS(1:ns,t), dst%tau_Threshold(1:ns,of), &
leaner interface
2019-02-22 02:02:22 +05:30
2_pInt , Temperature, instance, of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
enddo
endif
!*** store velocity in state
forall (t = 1_pInt:4_pInt) &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(ph)%state(iV(1:ns,t,instance),of) = v(1:ns,t)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!*** Bauschinger effect
forall (s = 1_pInt:ns, t = 5_pInt:8_pInt, rhoSgl(s,t) * v(s,t-4_pInt) < 0.0_pReal) &
rhoSgl(s,t-4_pInt) = rhoSgl(s,t-4_pInt) + abs(rhoSgl(s,t))
!*** Calculation of Lp and its tangent
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
gdotTotal = sum(rhoSgl(1:ns,1:4) * v, 2) * prm%burgers(1:ns)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
only used internally
2019-02-17 19:00:58 +05:30
Lp = 0.0_pReal
dLp_dMp = 0.0_pReal
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
do s = 1_pInt,ns
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
Lp = Lp + gdotTotal(s) * prm%Schmid(1:3,1:3,s)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
forall (i=1_pInt:3_pInt,j=1_pInt:3_pInt,k=1_pInt:3_pInt,l=1_pInt:3_pInt) &
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
dLp_dMp(i,j,k,l) = dLp_dMp(i,j,k,l) &
+ prm%Schmid(i,j,s) * prm%Schmid(k,l,s) &
simplified
2019-02-20 05:11:44 +05:30
* sum(rhoSgl(s,1:4) * dv_dtau(s,1:4)) * prm%burgers(s) &
+ prm%Schmid(i,j,s) &
* ( prm%nonSchmid_pos(k,l,s) * rhoSgl(s,3) * dv_dtauNS(s,3) &
- prm%nonSchmid_neg(k,l,s) * rhoSgl(s,4) * dv_dtauNS(s,4)) * prm%burgers(s)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
enddo
was not needed
2019-02-17 02:39:06 +05:30
end associate
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +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_nonlocal_LpAndItsTangent
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief (instantaneous) incremental change of microstructure
!--------------------------------------------------------------------------------------------------
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
subroutine plastic_nonlocal_deltaState(Mp,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
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
use debug, only: debug_level, &
debug_constitutive, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
debug_i, &
debug_e
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
use math, only: PI, &
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
math_mul33xx33
gfortran complaint about implicit casting,floating point comparison, and unused imported variables. additionally changed use of math_invert33 to math_inv33 if det is not needed
2015-04-11 00:39:26 +05:30
use mesh, only: mesh_ipVolume
use material, only: material_phase, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
plasticState, &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
phase_plasticityInstance
all constitutive modules now contain a new function "deltaState", which in the future allows to have an instantaneous and incremental change of the state (additional to the rate based evolution with dotState).
2012-05-16 20:13:26 +05:30
implicit none
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
integer(pInt), intent(in) :: ip, & ! current grain number
all constitutive modules now contain a new function "deltaState", which in the future allows to have an instantaneous and incremental change of the state (additional to the rate based evolution with dotState).
2012-05-16 20:13:26 +05:30
el ! current element number
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
real(pReal), dimension(3,3), intent(in) :: Mp !< MandelStress
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
integer(pInt) :: &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph, & !< phase
of !< offset
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
integer(pInt) ::instance, & ! current instance of this plasticity
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
ns, & ! short notation for the total number of active slip systems
c, & ! character of dislocation
t, & ! type of dislocation
don't parse material.config any more
2019-02-20 23:33:20 +05:30
s ! index of my current slip system
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),10) :: &
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
deltaRho, & ! density increment
deltaRhoRemobilization, & ! density increment by remobilization
deltaRhoDipole2SingleStress ! density increment by dipole dissociation (by stress change)
using new funtionality to get rho
2019-03-16 19:38:50 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),10) :: &
rho ! current dislocation densities
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),8) :: &
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
rhoSgl ! current single dislocation densities (positive/negative screw and edge without dipoles)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),4) :: &
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
v ! dislocation glide velocity
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el)))) :: &
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau ! current resolved shear stress
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1,ip,el))),2) :: &
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
rhoDip, & ! current dipole dislocation densities (screw and edge dipoles)
dLower, & ! minimum stable dipole distance for edges and screws
dUpper, & ! current maximum stable dipole distance for edges and screws
dUpperOld, & ! old maximum stable dipole distance for edges and screws
deltaDUpper ! change in maximum stable dipole distance for edges and screws
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0_pInt &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
.and. ((debug_e == el .and. debug_i == ip)&
fixed floating point exception in nonlocal (calculation of dUpper at several places)
2014-06-27 01:31:38 +05:30
.or. .not. iand(debug_level(debug_constitutive),debug_levelSelective) /= 0_pInt)) &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
write(6,'(/,a,i8,1x,i2,1x,i1,/)') '<< CONST >> nonlocal_deltaState at el ip ',el,ip
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
#endif
all constitutive modules now contain a new function "deltaState", which in the future allows to have an instantaneous and incremental change of the state (additional to the rate based evolution with dotState).
2012-05-16 20:13:26 +05:30
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
ph = phaseAt(1,ip,el)
of = phasememberAt(1,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)
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
associate(prm => param(instance),dst => microstructure(instance))
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ns = totalNslip(instance)
using new funtionality to get rho
2019-03-16 19:38:50 +05:30
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
!*** shortcut to state variables
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
v(s,t) = plasticState(ph)%state(iV(s,t,instance),of)
use named state variable indices in "deltaState"
2013-05-24 03:16:15 +05:30
endforall
combined some state indices to an array with a more generic name
2013-05-24 14:32:30 +05:30
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
dUpperOld(s,c) = plasticState(ph)%state(iD(s,c,instance),of)
use named state variable indices in "deltaState"
2013-05-24 03:16:15 +05:30
endforall
using new funtionality to get rho
2019-03-16 19:38:50 +05:30
rho = getRho(instance,of,ip,el)
rhoSgl = rho(:,sgl)
rhoDip = rho(:,dip)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
!****************************************************************************
!*** dislocation remobilization (bauschinger effect)
deltaRhoRemobilization = 0.0_pReal
do t = 1_pInt,4_pInt
do s = 1_pInt,ns
if (rhoSgl(s,t+4_pInt) * v(s,t) < 0.0_pReal) then
deltaRhoRemobilization(s,t) = abs(rhoSgl(s,t+4_pInt))
rhoSgl(s,t) = rhoSgl(s,t) + abs(rhoSgl(s,t+4_pInt))
deltaRhoRemobilization(s,t+4_pInt) = - rhoSgl(s,t+4_pInt)
rhoSgl(s,t+4_pInt) = 0.0_pReal
endif
enddo
enddo
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
!****************************************************************************
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
!*** calculate dipole formation and dissociation by stress change
!*** calculate limits for stable dipole height
cleaning
2019-02-18 14:58:08 +05:30
do s = 1_pInt,prm%totalNslip
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau(s) = math_mul33xx33(Mp, prm%Schmid(1:3,1:3,s)) +dst%tau_back(s,of)
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
if (abs(tau(s)) < 1.0e-15_pReal) tau(s) = 1.0e-15_pReal
enddo
transition to param structure
2019-02-20 13:43:50 +05:30
dLower = prm%minDipoleHeight(1:ns,1:2)
cleaning
2019-02-18 14:58:08 +05:30
dUpper(1:ns,1) = prm%mu * prm%burgers &
/ (8.0_pReal * PI * (1.0_pReal - prm%nu) * abs(tau))
dUpper(1:ns,2) = prm%mu * prm%burgers / (4.0_pReal * PI * abs(tau))
fixed bug introduced with lattice_structure change nonlocal, but with DEBUG=ON OPTIMIZATION=OFF there is an FPE. Division by zero? Marked in the code forgot to commit dislotwin last time, now seems to work
2014-03-12 05:25:40 +05:30
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
do c = 1, 2
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
where(dNeq0(sqrt(rhoSgl(1:ns,2*c-1)+rhoSgl(1:ns,2*c)+abs(rhoSgl(1:ns,2*c+3))&
+abs(rhoSgl(1:ns,2*c+4))+rhoDip(1:ns,c)))) &
fixed floating point exception in nonlocal (calculation of dUpper at several places)
2014-06-27 01:31:38 +05:30
dUpper(1:ns,c) = min(1.0_pReal / sqrt(rhoSgl(1:ns,2*c-1) + rhoSgl(1:ns,2*c) &
removed prefix "constitutive_nonlocal_" from all private variables
2013-05-24 01:26:36 +05:30
+ abs(rhoSgl(1:ns,2*c+3)) + abs(rhoSgl(1:ns,2*c+4)) + rhoDip(1:ns,c)), &
corrected limit for upper stable dipole distance; fixed a bug in the postResults where division by zero might happen
2012-10-29 18:32:01 +05:30
dUpper(1:ns,c))
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
enddo
allow minimum stable dipole height equal to zero; ensure that maximum stable dipole height is not smaller than the minimum value
2012-05-20 19:27:35 +05:30
dUpper = max(dUpper,dLower)
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
deltaDUpper = dUpper - dUpperOld
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
!*** dissociation by stress increase
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
deltaRhoDipole2SingleStress = 0.0_pReal
fixed floating point exception in nonlocal (calculation of dUpper at several places)
2014-06-27 01:31:38 +05:30
forall (c=1_pInt:2_pInt, s=1_pInt:ns, deltaDUpper(s,c) < 0.0_pReal .and. &
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
dNeq0(dUpperOld(s,c) - dLower(s,c))) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
deltaRhoDipole2SingleStress(s,8_pInt+c) = rhoDip(s,c) * deltaDUpper(s,c) &
/ (dUpperOld(s,c) - dLower(s,c))
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
forall (t=1_pInt:4_pInt) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
deltaRhoDipole2SingleStress(1_pInt:ns,t) = -0.5_pReal &
* deltaRhoDipole2SingleStress(1_pInt:ns,(t-1_pInt)/2_pInt+9_pInt)
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
!*** store new maximum dipole height in state
combined some state indices to an array with a more generic name
2013-05-24 14:32:30 +05:30
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt) &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(ph)%state(iD(s,c,instance),of) = dUpper(s,c)
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
!****************************************************************************
introduced annihilation of screw dipoles; so far no thermal activation, but immediate annihilation; each annihilated screw dipole leaves behind an edge jog of same length as the dipole height on the collinear system
2012-08-14 17:56:20 +05:30
!*** assign the changes in the dislocation densities to deltaState
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
dipole dissociation and formation by change in stress as new mechanism in deltaState; had to add dipole height to state variables, which is however updated by deltaState instead of microstructure; alternatively microstructure had to know the current stress state
2012-05-18 20:05:52 +05:30
deltaRho = deltaRhoRemobilization &
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
+ deltaRhoDipole2SingleStress
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(ph)%deltaState(:,of) = 0.0_pReal
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
forall (s = 1:ns, t = 1_pInt:4_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(ph)%deltaState(iRhoU(s,t,instance),of)= deltaRho(s,t)
plasticState(ph)%deltaState(iRhoB(s,t,instance),of) = deltaRho(s,t+4_pInt)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
endforall
forall (s = 1:ns, c = 1_pInt:2_pInt) &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(ph)%deltaState(iRhoD(s,c,instance),of) = deltaRho(s,c+8_pInt)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
if (iand(debug_level(debug_constitutive),debug_levelExtensive) /= 0_pInt &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
.and. ((debug_e == el .and. debug_i == ip)&
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
.or. .not. iand(debug_level(debug_constitutive),debug_levelSelective) /= 0_pInt )) then
write(6,'(a,/,8(12x,12(e12.5,1x),/))') '<< CONST >> dislocation remobilization', deltaRhoRemobilization(1:ns,1:8)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
write(6,'(a,/,10(12x,12(e12.5,1x),/),/)') '<< CONST >> dipole dissociation by stress increase', deltaRhoDipole2SingleStress
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
endif
#endif
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
end associate
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +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_nonlocal_deltaState
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
simplified
2019-02-20 05:11:44 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!---------------------------------------------------------------------------------------------------
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!> @brief calculates the rate of change of microstructure
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!---------------------------------------------------------------------------------------------------
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
subroutine plastic_nonlocal_dotState(Mp, Fe, Fp, Temperature, &
not needed
2019-02-22 12:07:08 +05:30
timestep,ip,el)
using IEEE_is_NAN and IEEE_quiet_NaN instead of hand-written solution, will not work for gfortran < 5
2017-05-04 04:02:44 +05:30
use, intrinsic :: &
IEEE_arithmetic
use prec, only: dNeq0, &
using dEq, dNeq, cEq, dEq
2016-05-29 14:15:03 +05:30
dNeq, &
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
dEq0
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
use IO, only: IO_error
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
#ifdef DEBUG
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
use debug, only: debug_level, &
debug_constitutive, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
debug_i, &
debug_e
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
#endif
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
use math, only: math_mul3x3, &
norm2 is (yet) not available in PGI
2019-03-10 13:12:50 +05:30
#ifdef __PGI
norm2, &
#endif
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
math_mul33x3, &
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
math_mul33xx33, &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
math_mul33x33, &
math_inv33, &
math_det33, &
pi
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
use mesh, only: theMesh, &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
mesh_ipNeighborhood, &
mesh_ipVolume, &
mesh_ipArea, &
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
mesh_ipAreaNormal
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
use material, only: homogenization_maxNgrains, &
material_phase, &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
phase_plasticityInstance, &
phase_localPlasticity, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
plasticState, &
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
phaseAt, phasememberAt, &
introduced named constants for homogenization_type, phase_plasticitiy, and phase_elasticity to replace expensive string comparison. Labels for different schemes need to be stored in material.f90 because they are needed when parsing the config file
2013-11-27 13:34:05 +05:30
phase_plasticity ,&
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
PLASTICITY_NONLOCAL_ID
don't parse material.config any more
2019-02-20 23:33:20 +05:30
use lattice, only: lattice_structure, &
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
LATTICE_bcc_ID, &
LATTICE_fcc_ID
* corrected compatibility for screws (always positive) * detection of grain boundary in constitutive_nonlocal_microstructure with the help of transmissivity * enforce positive densities in constitutive_nonlocal_microstructure (needed because dotState does not create cutbacks for negative densities anymore) * reset single mobile densities below certain threshold to zero (also done in constitutive_nonlocal_microstructure) * constitutive_nonlocal_kinetics only gets local state variable as input, no need for the entire array here * dv_dtau is always positive * multiplication is only active when there is already some initial density of the respective type
2010-10-26 19:12:18 +05:30
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
implicit none
!*** input variables
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
integer(pInt), intent(in) :: ip, & !< current integration point
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
el !< current element number
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
real(pReal), intent(in) :: Temperature, & !< temperature
timestep !< substepped crystallite time increment
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
real(pReal), dimension(3,3), intent(in) :: Mp !< MandelStress
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
real(pReal), dimension(3,3,homogenization_maxNgrains,theMesh%elem%nIPs,theMesh%nElems), intent(in) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
Fe, & !< elastic deformation gradient
Fp !< plastic deformation gradient
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
!*** local variables
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
integer(pInt) :: ph, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
instance, & !< current instance of this plasticity
neighbor_instance, & !< instance of my neighbor's plasticity
ns, & !< short notation for the total number of active slip systems
c, & !< character of dislocation
n, & !< index of my current neighbor
neighbor_el, & !< element number of my neighbor
neighbor_ip, & !< integration point of my neighbor
neighbor_n, & !< neighbor index pointing to me when looking from my neighbor
opposite_neighbor, & !< index of my opposite neighbor
opposite_ip, & !< ip of my opposite neighbor
opposite_el, & !< element index of my opposite neighbor
opposite_n, & !< neighbor index pointing to me when looking from my opposite neighbor
t, & !< type of dislocation
o,& !< offset shortcut
no,& !< neighbour offset shortcut
p,& !< phase shortcut
np,& !< neighbour phase shortcut
topp, & !< type of dislocation with opposite sign to t
cleaning
2019-02-18 14:58:08 +05:30
s !< index of my current slip system
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),10) :: &
more functions relying on getRho
2019-03-16 20:16:39 +05:30
rho, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
rhoDot, & !< density evolution
rhoDotMultiplication, & !< density evolution by multiplication
rhoDotFlux, & !< density evolution by flux
rhoDotSingle2DipoleGlide, & !< density evolution by dipole formation (by glide)
rhoDotAthermalAnnihilation, & !< density evolution by athermal annihilation
rhoDotThermalAnnihilation !< density evolution by thermal annihilation
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),8) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
rhoSgl, & !< current single dislocation densities (positive/negative screw and edge without dipoles)
neighbor_rhoSgl, & !< current single dislocation densities of neighboring ip (positive/negative screw and edge without dipoles)
my_rhoSgl !< single dislocation densities of central ip (positive/negative screw and edge without dipoles)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),4) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
v, & !< current dislocation glide velocity
my_v, & !< dislocation glide velocity of central ip
neighbor_v, & !< dislocation glide velocity of enighboring ip
gdot !< shear rates
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el)))) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
tau, & !< current resolved shear stress
don't parse material.config any more
2019-02-20 23:33:20 +05:30
vClimb !< climb velocity of edge dipoles
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),2) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
rhoDip, & !< current dipole dislocation densities (screw and edge dipoles)
dLower, & !< minimum stable dipole distance for edges and screws
dUpper !< current maximum stable dipole distance for edges and screws
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(3,totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),4) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
m !< direction of dislocation motion
real(pReal), dimension(3,3) :: my_F, & !< my total deformation gradient
neighbor_F, & !< total deformation gradient of my neighbor
my_Fe, & !< my elastic deformation gradient
neighbor_Fe, & !< elastic deformation gradient of my neighbor
Favg !< average total deformation gradient of me and my neighbor
real(pReal), dimension(3) :: normal_neighbor2me, & !< interface normal pointing from my neighbor to me in neighbor's lattice configuration
normal_neighbor2me_defConf, & !< interface normal pointing from my neighbor to me in shared deformed configuration
normal_me2neighbor, & !< interface normal pointing from me to my neighbor in my lattice configuration
normal_me2neighbor_defConf !< interface normal pointing from me to my neighbor in shared deformed configuration
real(pReal) area, & !< area of the current interface
transmissivity, & !< overall transmissivity of dislocation flux to neighboring material point
lineLength, & !< dislocation line length leaving the current interface
don't parse material.config any more
2019-02-20 23:33:20 +05:30
selfDiffusion !< self diffusion
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
logical considerEnteringFlux, &
slightly changed the multiplication term in the nonlocal model for the starvation case
2012-11-30 00:20:25 +05:30
considerLeavingFlux
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
p = phaseAt(1,ip,el)
o = phasememberAt(1,ip,el)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
more functions relying on getRho
2019-03-16 20:16:39 +05:30
if (timestep <= 0.0_pReal) then ! if illegal timestep...
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
plasticState(p)%dotState = 0.0_pReal ! ...return without doing anything (-> zero dotState)
return
endif
- flux calculation is now also compatible to neighborhood of local constitution - flux density interpolation now depends on the position of the interface between ttwo neighboring material points - simplified flux calculation scheme - introduced sanity check for dislocation velocity to ensure v*dt< cellsize
2010-03-04 22:44:47 +05:30
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0_pInt &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
.and. ((debug_e == el .and. debug_i == ip)&
fixed floating point exception in nonlocal (calculation of dUpper at several places)
2014-06-27 01:31:38 +05:30
.or. .not. iand(debug_level(debug_constitutive),debug_levelSelective) /= 0_pInt)) &
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
write(6,'(/,a,i8,1x,i2,/)') '<< CONST >> nonlocal_dotState at el ip ',el,ip
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph = material_phase(1_pInt,ip,el)
instance = phase_plasticityInstance(ph)
more functions relying on getRho
2019-03-16 20:16:39 +05:30
associate(prm => param(instance),dst => microstructure(instance),dot => dotState(instance),stt => state(instance))
also rename matID/i to instance like in the other constitutive models
2014-02-28 18:33:21 +05:30
ns = totalNslip(instance)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
tau = 0.0_pReal
added dislocation multiplication to dotState in constitutive_nonlocal.f90 cleaned up debugging output statements to *.out file
2009-08-12 16:52:02 +05:30
gdot = 0.0_pReal
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
more functions relying on getRho
2019-03-16 20:16:39 +05:30
rho = getRho(instance,o,ip,el)
rhoSgl = rho(:,sgl)
rhoDip = rho(:,dip)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
v(s,t) = plasticState(p)%state(iV (s,t,instance),o)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
endforall
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
added dislocation multiplication to dotState in constitutive_nonlocal.f90 cleaned up debugging output statements to *.out file
2009-08-12 16:52:02 +05:30
!****************************************************************************
!*** Calculate shear rate
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
forall (t = 1_pInt:4_pInt) &
cleaning
2019-02-18 14:58:08 +05:30
gdot(1_pInt:ns,t) = rhoSgl(1_pInt:ns,t) * prm%burgers(1:ns) * v(1:ns,t)
- introduction of immobile (used) single dislocation densities as new state variables - changed nomenclature (rho -> rhoSgl) to distinguish precisely between single dislocation density and total dislocation density - changed material.config accordingly
2010-01-05 21:37:24 +05:30
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0_pInt &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
.and. ((debug_e == el .and. debug_i == ip)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_constitutive),debug_levelSelective) /= 0_pInt )) then
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,/,10(12x,12(e12.5,1x),/))') '<< CONST >> rho / 1/m^2', rhoSgl, rhoDip
write(6,'(a,/,4(12x,12(e12.5,1x),/))') '<< CONST >> gdot / 1/s',gdot
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
endif
#endif
* corrected compatibility for screws (always positive) * detection of grain boundary in constitutive_nonlocal_microstructure with the help of transmissivity * enforce positive densities in constitutive_nonlocal_microstructure (needed because dotState does not create cutbacks for negative densities anymore) * reset single mobile densities below certain threshold to zero (also done in constitutive_nonlocal_microstructure) * constitutive_nonlocal_kinetics only gets local state variable as input, no need for the entire array here * dv_dtau is always positive * multiplication is only active when there is already some initial density of the respective type
2010-10-26 19:12:18 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
added dislocation multiplication to dotState in constitutive_nonlocal.f90 cleaned up debugging output statements to *.out file
2009-08-12 16:52:02 +05:30
!****************************************************************************
* removed calculations for dipole formation/dissociation by stress change, since it is not used anyways; also removed associated constitutive outputs from material.config * removed input variables in constitutive_collectDotState and constitutive_postResults that are not needed anymore (because of recent changes in constitutive_nonlocal)
2011-02-25 15:23:20 +05:30
!*** calculate limits for stable dipole height
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
do s = 1_pInt,ns ! loop over slip systems
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau(s) = math_mul33xx33(Mp, prm%Schmid(1:3,1:3,s)) + dst%tau_back(s,o)
fixed potential division by zero error discovered by our American friends
2012-05-08 12:46:00 +05:30
if (abs(tau(s)) < 1.0e-15_pReal) tau(s) = 1.0e-15_pReal
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
enddo
transition to param structure
2019-02-20 13:43:50 +05:30
dLower = prm%minDipoleHeight(1:ns,1:2)
simplified/not needed
2019-02-20 12:03:19 +05:30
dUpper(1:ns,1) = prm%mu * prm%burgers(1:ns) &
/ (8.0_pReal * pi * (1.0_pReal - prm%nu) * abs(tau))
dUpper(1:ns,2) = prm%mu * prm%burgers(1:ns) &
corrected formulation of maximum height of screw dislocation dipoles
2012-07-24 20:20:11 +05:30
/ (4.0_pReal * pi * abs(tau))
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
do c = 1, 2
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
where(dNeq0(sqrt(rhoSgl(1:ns,2*c-1)+rhoSgl(1:ns,2*c)+abs(rhoSgl(1:ns,2*c+3))&
+abs(rhoSgl(1:ns,2*c+4))+rhoDip(1:ns,c)))) &
fixed floating point exception in nonlocal (calculation of dUpper at several places)
2014-06-27 01:31:38 +05:30
dUpper(1:ns,c) = min(1.0_pReal / sqrt(rhoSgl(1:ns,2*c-1) + rhoSgl(1:ns,2*c) &
removed prefix "constitutive_nonlocal_" from all private variables
2013-05-24 01:26:36 +05:30
+ abs(rhoSgl(1:ns,2*c+3)) + abs(rhoSgl(1:ns,2*c+4)) + rhoDip(1:ns,c)), &
corrected limit for upper stable dipole distance; fixed a bug in the postResults where division by zero might happen
2012-10-29 18:32:01 +05:30
dUpper(1:ns,c))
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
enddo
allow minimum stable dipole height equal to zero; ensure that maximum stable dipole height is not smaller than the minimum value
2012-05-20 19:27:35 +05:30
dUpper = max(dUpper,dLower)
constitutive_nonlocal: - read in activation energy for dislocation glide from material.config - changed naming of dDipMin/Max to dLower/dUpper - added new outputs: rho_dot, rho_dot_dip, rho_dot_gen, rho_dot_sgl2dip, rho_dot_dip2sgl, rho_dot_ann_ath, rho_dot_ann_the, rho_dot_flux, d_upper_edge, d_upper_screw, d_upper_dot_edge, d_upper_dot_screw - poisson's ratio is now calculated from elastic constants - microstrucutre has state as first argument, since this is our output variable - periodic boundary conditions are taken into account for fluxes and internal stresses. for the moment, flag has to be set in constitutive_nonlocal. - corrected calculation for dipole formation by glide - added terms for dipole formation/annihilation by stress decrease/increase constitutive: - passing of arguments is adapted for constitutive_nonlocal model crystallite: - in stiffness calculation: call to collect_dotState used wrong arguments - crystallite_postResults uses own Tstar_v and temperature, no need for passing them from materialpoint_postResults homogenization: - crystallite_postResults uses own Tstar_v and temperature, no need for passing them from materialpoint_postResults IO: - changed error message 229 material.config: - changed example for nonlocal constitution according to constitutive_nonlocal all: - added some flush statements
2009-10-20 20:06:03 +05:30
!****************************************************************************
!*** calculate dislocation multiplication
* corrected compatibility for screws (always positive) * detection of grain boundary in constitutive_nonlocal_microstructure with the help of transmissivity * enforce positive densities in constitutive_nonlocal_microstructure (needed because dotState does not create cutbacks for negative densities anymore) * reset single mobile densities below certain threshold to zero (also done in constitutive_nonlocal_microstructure) * constitutive_nonlocal_kinetics only gets local state variable as input, no need for the entire array here * dv_dtau is always positive * multiplication is only active when there is already some initial density of the respective type
2010-10-26 19:12:18 +05:30
rhoDotMultiplication = 0.0_pReal
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
if (lattice_structure(ph) == LATTICE_bcc_ID) then ! BCC
multiplication now sensitive of crystal structure, yet multiplication in bcc identical to fcc except for the contribution of edges which is completely dropped for bcc
2013-08-05 14:56:37 +05:30
forall (s = 1:ns, sum(abs(v(s,1:4))) > 0.0_pReal)
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
rhoDotMultiplication(s,1:2) = sum(abs(gdot(s,3:4))) / prm%burgers(s) & ! assuming double-cross-slip of screws to be decisive for multiplication
more functions relying on getRho
2019-03-16 20:16:39 +05:30
* sqrt(stt%rho_forest(s,o)) / prm%lambda0(s) ! & ! mean free path
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
! * 2.0_pReal * sum(abs(v(s,3:4))) / sum(abs(v(s,1:4))) ! ratio of screw to overall velocity determines edge generation
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
rhoDotMultiplication(s,3:4) = sum(abs(gdot(s,3:4))) /prm%burgers(s) & ! assuming double-cross-slip of screws to be decisive for multiplication
more functions relying on getRho
2019-03-16 20:16:39 +05:30
* sqrt(stt%rho_forest(s,o)) / prm%lambda0(s) ! & ! mean free path
renaming of "instance" and thelike to be consistent with naming scheme introduced in rev2662
2013-11-21 19:05:43 +05:30
! * 2.0_pReal * sum(abs(v(s,1:2))) / sum(abs(v(s,1:4))) ! ratio of edge to overall velocity determines screw generation
multiplication now sensitive of crystal structure, yet multiplication in bcc identical to fcc except for the contribution of edges which is completely dropped for bcc
2013-08-05 14:56:37 +05:30
endforall
else ! ALL OTHER STRUCTURES
no random-multiplication anymore from our current understanding, the implementation of random nucleation was strongly dependent on the numerical method and the time stepping
2019-02-20 22:28:11 +05:30
rhoDotMultiplication(1:ns,1:4) = spread( &
limiting inter-module dependencies
2019-02-19 15:13:04 +05:30
(sum(abs(gdot(1:ns,1:2)),2) * prm%fEdgeMultiplication + sum(abs(gdot(1:ns,3:4)),2)) &
more functions relying on getRho
2019-03-16 20:16:39 +05:30
* sqrt(stt%rho_forest(:,o)) / prm%lambda0 / prm%burgers(1:ns), 2, 4)
made random multiplication switchable via material.config
2012-12-03 18:29:38 +05:30
endif
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
added dislocation multiplication to dotState in constitutive_nonlocal.f90 cleaned up debugging output statements to *.out file
2009-08-12 16:52:02 +05:30
!****************************************************************************
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
!*** calculate dislocation fluxes (only for nonlocal plasticity)
added dislocation multiplication to dotState in constitutive_nonlocal.f90 cleaned up debugging output statements to *.out file
2009-08-12 16:52:02 +05:30
in nonlocal_microstructure: at the model surface the excess density is now extrapolated from opposite neighbor instead of assuming zero density; this results in better modeling of the dislocation stress at the surface restructured nonlocal_dotstate, to be able to easily switch on and off particular effects in the microstructure evolution nonlocal_dotstate now enforces a cutback when single density runs the risk of becoming negative; in the case of a state already below the relevantState dotState is set to zero introduced two new output variables: rho_dot_edge and rho_dot_screw
2010-05-21 14:21:15 +05:30
rhoDotFlux = 0.0_pReal
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
!? why needed here
if (.not. phase_localPlasticity(material_phase(1_pInt,ip,el))) then ! only for nonlocal plasticity
corrected debug output of evolution rates; added possibility to change the safety factor for the CFL flux condition via the material.config file; updated the example material.config due to recent changes in nonlocal constitutive
2012-08-16 14:43:38 +05:30
!*** check CFL (Courant-Friedrichs-Lewy) condition for flux
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
if (any( abs(gdot) > 0.0_pReal & ! any active slip system ...
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
.and. prm%CFLfactor * abs(v) * timestep &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
> mesh_ipVolume(ip,el) / maxval(mesh_ipArea(:,ip,el)))) then ! ...with velocity above critical value (we use the reference volume and area for simplicity here)
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
made random multiplication switchable via material.config
2012-12-03 18:29:38 +05:30
if (iand(debug_level(debug_constitutive),debug_levelExtensive) /= 0_pInt) then
corrected debug output of evolution rates; added possibility to change the safety factor for the CFL flux condition via the material.config file; updated the example material.config due to recent changes in nonlocal constitutive
2012-08-16 14:43:38 +05:30
write(6,'(a,i5,a,i2)') '<< CONST >> CFL condition not fullfilled at el ',el,' ip ',ip
minor correction of debugging output
2012-09-05 16:49:46 +05:30
write(6,'(a,e10.3,a,e10.3)') '<< CONST >> velocity is at ', &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
maxval(abs(v), abs(gdot) > 0.0_pReal &
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
.and. prm%CFLfactor * abs(v) * timestep &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
> mesh_ipVolume(ip,el) / maxval(mesh_ipArea(:,ip,el))), &
' at a timestep of ',timestep
corrected debug output of evolution rates; added possibility to change the safety factor for the CFL flux condition via the material.config file; updated the example material.config due to recent changes in nonlocal constitutive
2012-08-16 14:43:38 +05:30
write(6,'(a)') '<< CONST >> enforcing cutback !!!'
endif
#endif
using IEEE_is_NAN and IEEE_quiet_NaN instead of hand-written solution, will not work for gfortran < 5
2017-05-04 04:02:44 +05:30
plasticState(p)%dotState = IEEE_value(1.0_pReal,IEEE_quiet_NaN) ! -> return NaN and, hence, enforce cutback
corrected debug output of evolution rates; added possibility to change the safety factor for the CFL flux condition via the material.config file; updated the example material.config due to recent changes in nonlocal constitutive
2012-08-16 14:43:38 +05:30
return
endif
Introduced an alternative cutback scheme for the nonlocal model, that allows to keep the results of most of the ips that immediately converged, and only do cutbacks in regions where some ips are in big trouble. Only works for nonlocal model and state integrator 2.
2012-11-28 00:06:55 +05:30
not needed anymore
2019-03-09 17:18:43 +05:30
!*** be aware of the definition of slip_transverse = slip_direction x slip_normal !!!
* "constitutive_nonlocal_flux" is set to zero in "constitutive_nonlocal_dotState", not in "constitutive_nonlocal_microstructure" * dislocation flux and internal stress calculation now consistent with new definition of slip system lattice according to paper (polarity of screws inverted)
2011-02-23 13:38:06 +05:30
!*** opposite sign to our p vector in the (s,p,n) triplet !!!
don't parse material.config any more
2019-02-20 23:33:20 +05:30
m(1:3,1:ns,1) = prm%slip_direction
m(1:3,1:ns,2) = -prm%slip_direction
m(1:3,1:ns,3) = -prm%slip_transverse
m(1:3,1:ns,4) = prm%slip_transverse
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
my_Fe = Fe(1:3,1:3,1_pInt,ip,el)
my_F = math_mul33x33(my_Fe, Fp(1:3,1:3,1_pInt,ip,el))
constitutive_nonlocal: - read in activation energy for dislocation glide from material.config - changed naming of dDipMin/Max to dLower/dUpper - added new outputs: rho_dot, rho_dot_dip, rho_dot_gen, rho_dot_sgl2dip, rho_dot_dip2sgl, rho_dot_ann_ath, rho_dot_ann_the, rho_dot_flux, d_upper_edge, d_upper_screw, d_upper_dot_edge, d_upper_dot_screw - poisson's ratio is now calculated from elastic constants - microstrucutre has state as first argument, since this is our output variable - periodic boundary conditions are taken into account for fluxes and internal stresses. for the moment, flag has to be set in constitutive_nonlocal. - corrected calculation for dipole formation by glide - added terms for dipole formation/annihilation by stress decrease/increase constitutive: - passing of arguments is adapted for constitutive_nonlocal model crystallite: - in stiffness calculation: call to collect_dotState used wrong arguments - crystallite_postResults uses own Tstar_v and temperature, no need for passing them from materialpoint_postResults homogenization: - crystallite_postResults uses own Tstar_v and temperature, no need for passing them from materialpoint_postResults IO: - changed error message 229 material.config: - changed example for nonlocal constitution according to constitutive_nonlocal all: - added some flush statements
2009-10-20 20:06:03 +05:30
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
do n = 1_pInt,theMesh%elem%nIPneighbors
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
neighbor_el = mesh_ipNeighborhood(1,n,ip,el)
neighbor_ip = mesh_ipNeighborhood(2,n,ip,el)
neighbor_n = mesh_ipNeighborhood(3,n,ip,el)
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
np = phaseAt(1,neighbor_ip,neighbor_el)
no = phasememberAt(1,neighbor_ip,neighbor_el)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
added possibility to scale the plastic shearrate by the ratio of mobile to total density; keyword in material.config is "deadZone"
2012-10-29 18:19:28 +05:30
opposite_neighbor = n + mod(n,2_pInt) - mod(n+1_pInt,2_pInt)
opposite_el = mesh_ipNeighborhood(1,opposite_neighbor,ip,el)
opposite_ip = mesh_ipNeighborhood(2,opposite_neighbor,ip,el)
opposite_n = mesh_ipNeighborhood(3,opposite_neighbor,ip,el)
fluxes are disabled when keyword "/nonlocal/" is omitted in the material.config (this is a way to use the constitutive_nonlocal model as a local dislocation based model)
2011-01-11 20:25:36 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
if (neighbor_n > 0_pInt) then ! if neighbor exists, average deformation gradient
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
neighbor_instance = phase_plasticityInstance(material_phase(1_pInt,neighbor_ip,neighbor_el))
neighbor_Fe = Fe(1:3,1:3,1_pInt,neighbor_ip,neighbor_el)
neighbor_F = math_mul33x33(neighbor_Fe, Fp(1:3,1:3,1_pInt,neighbor_ip,neighbor_el))
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
Favg = 0.5_pReal * (my_F + neighbor_F)
else ! if no neighbor, take my value as average
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
Favg = my_F
fluxes are disabled when keyword "/nonlocal/" is omitted in the material.config (this is a way to use the constitutive_nonlocal model as a local dislocation based model)
2011-01-11 20:25:36 +05:30
endif
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
!* FLUX FROM MY NEIGHBOR TO ME
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* This is only considered, if I have a neighbor of nonlocal plasticity
!* (also nonlocal constitutive law with local properties) that is at least a little bit
!* compatible.
!* If it's not at all compatible, no flux is arriving, because everything is dammed in front of
!* my neighbor's interface.
!* The entering flux from my neighbor will be distributed on my slip systems according to the
!*compatibility
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
considerEnteringFlux = .false.
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
neighbor_v = 0.0_pReal ! needed for check of sign change in flux density below
neighbor_rhoSgl = 0.0_pReal
if (neighbor_n > 0_pInt) then
introduced named constants for homogenization_type, phase_plasticitiy, and phase_elasticity to replace expensive string comparison. Labels for different schemes need to be stored in material.f90 because they are needed when parsing the config file
2013-11-27 13:34:05 +05:30
if (phase_plasticity(material_phase(1,neighbor_ip,neighbor_el)) == PLASTICITY_NONLOCAL_ID &
removed prefix "constitutive_nonlocal_" from all private variables
2013-05-24 01:26:36 +05:30
.and. any(compatibility(:,:,:,n,ip,el) > 0.0_pReal)) &
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
considerEnteringFlux = .true.
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
endif
if (considerEnteringFlux) then
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
forall (s = 1:ns, t = 1_pInt:4_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
neighbor_v(s,t) = plasticState(np)%state(iV (s,t,neighbor_instance),no)
neighbor_rhoSgl(s,t) = max(plasticState(np)%state(iRhoU(s,t,neighbor_instance),no), &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
0.0_pReal)
small changes in nonlocal constitutive model: - make sure neighboring density is always greater equal zero - no extra Bauschinger in postResults
2013-04-03 21:52:55 +05:30
endforall
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
cleaning
2019-02-18 14:58:08 +05:30
where (neighbor_rhoSgl * mesh_ipVolume(neighbor_ip,neighbor_el) ** 0.667_pReal < prm%significantN &
.or. neighbor_rhoSgl < prm%significantRho) &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
neighbor_rhoSgl = 0.0_pReal
removed prefix "constitutive_nonlocal_" from all private variables
2013-05-24 01:26:36 +05:30
normal_neighbor2me_defConf = math_det33(Favg) * math_mul33x3(math_inv33(transpose(Favg)), &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
mesh_ipAreaNormal(1:3,neighbor_n,neighbor_ip,neighbor_el)) ! calculate the normal of the interface in (average) deformed configuration (now pointing from my neighbor to me!!!)
normal_neighbor2me = math_mul33x3(transpose(neighbor_Fe), normal_neighbor2me_defConf) &
/ math_det33(neighbor_Fe) ! interface normal in the lattice configuration of my neighbor
using norm2 function as L2 norm (vector, math_norm3) and Frobenius norm (tensor, math_norm33)
2016-01-09 21:31:30 +05:30
area = mesh_ipArea(neighbor_n,neighbor_ip,neighbor_el) * norm2(normal_neighbor2me)
normal_neighbor2me = normal_neighbor2me / norm2(normal_neighbor2me) ! normalize the surface normal to unit length
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
do s = 1_pInt,ns
do t = 1_pInt,4_pInt
c = (t + 1_pInt) / 2
topp = t + mod(t,2_pInt) - mod(t+1_pInt,2_pInt)
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
if (neighbor_v(s,t) * math_mul3x3(m(1:3,s,t), normal_neighbor2me) > 0.0_pReal & ! flux from my neighbor to me == entering flux for me
allow flux between neighboring material points if one of both got a velocity of zero
2014-01-08 22:05:10 +05:30
.and. v(s,t) * neighbor_v(s,t) >= 0.0_pReal ) then ! ... only if no sign change in flux density
blocked density does no longer contribute to dislocation flux; used to generate source term for mobile density if burgers vector had any non-zero component perpendicular to blocking boundary.
2014-01-08 22:01:50 +05:30
lineLength = neighbor_rhoSgl(s,t) * neighbor_v(s,t) &
* math_mul3x3(m(1:3,s,t), normal_neighbor2me) * area ! positive line length that wants to enter through this interface
where (compatibility(c,1_pInt:ns,s,n,ip,el) > 0.0_pReal) & ! positive compatibility...
rhoDotFlux(1_pInt:ns,t) = rhoDotFlux(1_pInt:ns,t) &
+ lineLength / mesh_ipVolume(ip,el) & ! ... transferring to equally signed mobile dislocation type
* compatibility(c,1_pInt:ns,s,n,ip,el) ** 2.0_pReal
where (compatibility(c,1_pInt:ns,s,n,ip,el) < 0.0_pReal) & ! ..negative compatibility...
rhoDotFlux(1_pInt:ns,topp) = rhoDotFlux(1_pInt:ns,topp) &
+ lineLength / mesh_ipVolume(ip,el) & ! ... transferring to opposite signed mobile dislocation type
* compatibility(c,1_pInt:ns,s,n,ip,el) ** 2.0_pReal
fluxes are disabled when keyword "/nonlocal/" is omitted in the material.config (this is a way to use the constitutive_nonlocal model as a local dislocation based model)
2011-01-11 20:25:36 +05:30
endif
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
enddo
enddo
fluxes are disabled when keyword "/nonlocal/" is omitted in the material.config (this is a way to use the constitutive_nonlocal model as a local dislocation based model)
2011-01-11 20:25:36 +05:30
endif
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
!* FLUX FROM ME TO MY NEIGHBOR
parameters are stored in parameter structure
2019-02-16 23:08:13 +05:30
!* This is not considered, if my opposite neighbor has a different constitutive law than nonlocal (still considered for nonlocal law with local properties).
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
!* Then, we assume, that the opposite(!) neighbor sends an equal amount of dislocations to me.
!* So the net flux in the direction of my neighbor is equal to zero:
!* leaving flux to neighbor == entering flux from opposite neighbor
!* In case of reduced transmissivity, part of the leaving flux is stored as dead dislocation density.
!* That means for an interface of zero transmissivity the leaving flux is fully converted to dead dislocations.
considerLeavingFlux = .true.
added possibility to scale the plastic shearrate by the ratio of mobile to total density; keyword in material.config is "deadZone"
2012-10-29 18:19:28 +05:30
if (opposite_n > 0_pInt) then
introduced named constants for homogenization_type, phase_plasticitiy, and phase_elasticity to replace expensive string comparison. Labels for different schemes need to be stored in material.f90 because they are needed when parsing the config file
2013-11-27 13:34:05 +05:30
if (phase_plasticity(material_phase(1,opposite_ip,opposite_el)) /= PLASTICITY_NONLOCAL_ID) &
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
considerLeavingFlux = .false.
endif
if (considerLeavingFlux) then
fixed timesyncing for special case of ip that synchronizes its time step, but does not have a neighbor
2012-12-11 19:08:36 +05:30
!* timeSyncing mode: If the central ip has zero subfraction, always use "state0". This is needed in case of
!* a synchronization step for the central ip, because then "state" contains the values at the end of the
!* previously converged full time step. Also, if either me or my neighbor has zero subfraction, we have to
!* use "state0" to make sure that fluxes on both sides of the (potential) timestep are equal.
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
my_rhoSgl = rhoSgl
my_v = v
fixed timesyncing for special case of ip that synchronizes its time step, but does not have a neighbor
2012-12-11 19:08:36 +05:30
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
normal_me2neighbor_defConf = math_det33(Favg) &
parameters are stored in parameter structure
2019-02-16 23:08:13 +05:30
* math_mul33x3(math_inv33(transpose(Favg)), &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
mesh_ipAreaNormal(1:3,n,ip,el)) ! calculate the normal of the interface in (average) deformed configuration (pointing from me to my neighbor!!!)
parameters are stored in parameter structure
2019-02-16 23:08:13 +05:30
normal_me2neighbor = math_mul33x3(transpose(my_Fe), normal_me2neighbor_defConf) &
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
/ math_det33(my_Fe) ! interface normal in my lattice configuration
using norm2 function as L2 norm (vector, math_norm3) and Frobenius norm (tensor, math_norm33)
2016-01-09 21:31:30 +05:30
area = mesh_ipArea(n,ip,el) * norm2(normal_me2neighbor)
normal_me2neighbor = normal_me2neighbor / norm2(normal_me2neighbor) ! normalize the surface normal to unit length
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
do s = 1_pInt,ns
do t = 1_pInt,4_pInt
Introduced an alternative cutback scheme for the nonlocal model, that allows to keep the results of most of the ips that immediately converged, and only do cutbacks in regions where some ips are in big trouble. Only works for nonlocal model and state integrator 2.
2012-11-28 00:06:55 +05:30
c = (t + 1_pInt) / 2_pInt
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
if (my_v(s,t) * math_mul3x3(m(1:3,s,t), normal_me2neighbor) > 0.0_pReal ) then ! flux from me to my neighbor == leaving flux for me (might also be a pure flux from my mobile density to dead density if interface not at all transmissive)
allow flux between neighboring material points if one of both got a velocity of zero
2014-01-08 22:05:10 +05:30
if (my_v(s,t) * neighbor_v(s,t) >= 0.0_pReal) then ! no sign change in flux density
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
transmissivity = sum(compatibility(c,1_pInt:ns,s,n,ip,el)**2.0_pReal) ! overall transmissivity from this slip system to my neighbor
else ! sign change in flux density means sign change in stress which does not allow for dislocations to arive at the neighbor
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
transmissivity = 0.0_pReal
endif
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
lineLength = my_rhoSgl(s,t) * my_v(s,t) &
* math_mul3x3(m(1:3,s,t), normal_me2neighbor) * area ! positive line length of mobiles that wants to leave through this interface
rhoDotFlux(s,t) = rhoDotFlux(s,t) - lineLength / mesh_ipVolume(ip,el) ! subtract dislocation flux from current type
rhoDotFlux(s,t+4_pInt) = rhoDotFlux(s,t+4_pInt) &
+ lineLength / mesh_ipVolume(ip,el) * (1.0_pReal - transmissivity) &
* sign(1.0_pReal, my_v(s,t)) ! dislocation flux that is not able to leave through interface (because of low transmissivity) will remain as immobile single density at the material point
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
endif
enddo
enddo
endif
* added a new material parameter "surfaceTransmissivity" (default value 1.0) which allows to change the transmissivity of the material surface between 0 and 1 * now complaining when encountering an unknown nonlocal parameter in material.config * use same error ID for all material parameters out of bounds * symmetric flux calculation in side dotState can now be omitted (because of new treatment of periodicity) * switching back to "local flux balance" (add leaving and entering fluxes at central MP, don't touch neighbor) instead of "flux distribution" (subtract leaving fluxes from central MP and add them at neighboring MP). This has the advantage that there is almost no need for CRITICAL statements in parallelization, so hopefully this results in some speed up.
2011-02-16 22:05:38 +05:30
* in flux calculation: take care of special case for single element model * do not overwrite "constitutive_nonlocal_rhoDotFlux" when doing a state perturbation, so we can use it for output
2011-02-24 15:31:41 +05:30
enddo ! neighbor loop
* corrected compatibility for screws (always positive) * detection of grain boundary in constitutive_nonlocal_microstructure with the help of transmissivity * enforce positive densities in constitutive_nonlocal_microstructure (needed because dotState does not create cutbacks for negative densities anymore) * reset single mobile densities below certain threshold to zero (also done in constitutive_nonlocal_microstructure) * constitutive_nonlocal_kinetics only gets local state variable as input, no need for the entire array here * dv_dtau is always positive * multiplication is only active when there is already some initial density of the respective type
2010-10-26 19:12:18 +05:30
endif
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
!****************************************************************************
!*** calculate dipole formation and annihilation
!*** formation by glide
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
do c = 1_pInt,2_pInt
cleaning
2019-02-18 14:58:08 +05:30
rhoDotSingle2DipoleGlide(1:ns,2*c-1) = -2.0_pReal * dUpper(1:ns,c) / prm%burgers(1:ns) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
* (rhoSgl(1:ns,2*c-1) * abs(gdot(1:ns,2*c)) & ! negative mobile --> positive mobile
+ rhoSgl(1:ns,2*c) * abs(gdot(1:ns,2*c-1)) & ! positive mobile --> negative mobile
+ abs(rhoSgl(1:ns,2*c+4)) * abs(gdot(1:ns,2*c-1))) ! positive mobile --> negative immobile
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
cleaning
2019-02-18 14:58:08 +05:30
rhoDotSingle2DipoleGlide(1:ns,2*c) = -2.0_pReal * dUpper(1:ns,c) / prm%burgers(1:ns) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
* (rhoSgl(1:ns,2*c-1) * abs(gdot(1:ns,2*c)) & ! negative mobile --> positive mobile
+ rhoSgl(1:ns,2*c) * abs(gdot(1:ns,2*c-1)) & ! positive mobile --> negative mobile
+ abs(rhoSgl(1:ns,2*c+3)) * abs(gdot(1:ns,2*c))) ! negative mobile --> positive immobile
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
cleaning
2019-02-18 14:58:08 +05:30
rhoDotSingle2DipoleGlide(1:ns,2*c+3) = -2.0_pReal * dUpper(1:ns,c) / prm%burgers(1:ns) &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
* rhoSgl(1:ns,2*c+3) * abs(gdot(1:ns,2*c)) ! negative mobile --> positive immobile
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
cleaning
2019-02-18 14:58:08 +05:30
rhoDotSingle2DipoleGlide(1:ns,2*c+4) = -2.0_pReal * dUpper(1:ns,c) / prm%burgers(1:ns)&
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
* rhoSgl(1:ns,2*c+4) * abs(gdot(1:ns,2*c-1)) ! positive mobile --> negative immobile
constitutive_nonlocal: - reworked contribution of immobile dislocation density for rate equations - flux is now calculated on the basis of interpolated velocities and densities at the interface; both incoming and outgoing fluxes are considered, so every material point only changes his own dotState - dislocation velocity is now globally defined and calculated by subroutine constitutive_nonlocal_kinetics; the subroutine is called inside _LpAndItsTangent as well as _microstructure; therefore, microstructure now needs Tstar_v as additional input; in the future one should perhaps create a subroutine constitutive_kinetics that calls constitutive_nonlocal_kinetics separately, to clearly distinguish between microstructural and kinetic variables - better use flux density vector as output variable instead of scalar flux values for each interface - added output variables internal and external resolved stress crystallite: - added flag to force local stiffness calculation in case of nonlocal model - misorientation angle is explicitly set to zero when no neighbor can be found debug: - added flag "selectiveDebugger" that is used when debugging statements should only affect a specific element, ip and grain; these are specified with the new variables debug_e, debug_i and debug_g - debugger can now be used in its original sense
2010-02-17 18:51:36 +05:30
renamed "maxNmatIDs" accordingly to "maxNinstances"
2014-03-04 19:17:04 +05:30
rhoDotSingle2DipoleGlide(1:ns,c+8) = - rhoDotSingle2DipoleGlide(1:ns,2*c-1) &
- rhoDotSingle2DipoleGlide(1:ns,2*c) &
+ abs(rhoDotSingle2DipoleGlide(1:ns,2*c+3)) &
+ abs(rhoDotSingle2DipoleGlide(1:ns,2*c+4))
- introduction of immobile (used) single dislocation densities as new state variables - changed nomenclature (rho -> rhoSgl) to distinguish precisely between single dislocation density and total dislocation density - changed material.config accordingly
2010-01-05 21:37:24 +05:30
enddo
constitutive_nonlocal - take orientation gradients into account when calculating dislocation stress and dislocation fluxes - hard coded value for nu - changed kinetics (parameter G0 is currently defined as a parameter, needs to be read from material.config) - added some output statements constitutive: - some functions and subroutines needed additional input variables for passing to constitutive_nonlocal crystallite: - some functions and subroutines needed additional input variables for passing to constitutive - call microstructure with current temperature, Fp, Fe, not "sub0" values - show number of IPs, that are "onTrack" instead of those not "onTrack" - calculate Fe at beginning of substep, since we need it for state preguess
2009-10-07 21:01:52 +05:30
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
!*** athermal annihilation
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
in nonlocal_microstructure: at the model surface the excess density is now extrapolated from opposite neighbor instead of assuming zero density; this results in better modeling of the dislocation stress at the surface restructured nonlocal_dotstate, to be able to easily switch on and off particular effects in the microstructure evolution nonlocal_dotstate now enforces a cutback when single density runs the risk of becoming negative; in the case of a state already below the relevantState dotState is set to zero introduced two new output variables: rho_dot_edge and rho_dot_screw
2010-05-21 14:21:15 +05:30
rhoDotAthermalAnnihilation = 0.0_pReal
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
forall (c=1_pInt:2_pInt) &
cleaning
2019-02-18 14:58:08 +05:30
rhoDotAthermalAnnihilation(1:ns,c+8_pInt) = -2.0_pReal * dLower(1:ns,c) / prm%burgers(1:ns) &
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
* ( 2.0_pReal * (rhoSgl(1:ns,2*c-1) * abs(gdot(1:ns,2*c)) + rhoSgl(1:ns,2*c) * abs(gdot(1:ns,2*c-1))) & ! was single hitting single
+ 2.0_pReal * (abs(rhoSgl(1:ns,2*c+3)) * abs(gdot(1:ns,2*c)) + abs(rhoSgl(1:ns,2*c+4)) * abs(gdot(1:ns,2*c-1))) & ! was single hitting immobile single or was immobile single hit by single
+ rhoDip(1:ns,c) * (abs(gdot(1:ns,2*c-1)) + abs(gdot(1:ns,2*c)))) ! single knocks dipole constituent
! annihilated screw dipoles leave edge jogs behind on the colinear system
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
if (lattice_structure(ph) == LATTICE_fcc_ID) & ! only fcc
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
forall (s = 1:ns, prm%colinearSystem(s) > 0_pInt) &
rhoDotAthermalAnnihilation(prm%colinearSystem(s),1:2) = - rhoDotAthermalAnnihilation(s,10) &
more functions relying on getRho
2019-03-16 20:16:39 +05:30
* 0.25_pReal * sqrt(stt%rho_forest(s,o)) * (dUpper(s,2) + dLower(s,2)) * prm%edgeJogFactor
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
annihilation of screws
2012-11-17 19:20:20 +05:30
!*** thermally activated annihilation of edge dipoles by climb
constitutive_nonlocal - take orientation gradients into account when calculating dislocation stress and dislocation fluxes - hard coded value for nu - changed kinetics (parameter G0 is currently defined as a parameter, needs to be read from material.config) - added some output statements constitutive: - some functions and subroutines needed additional input variables for passing to constitutive_nonlocal crystallite: - some functions and subroutines needed additional input variables for passing to constitutive - call microstructure with current temperature, Fp, Fe, not "sub0" values - show number of IPs, that are "onTrack" instead of those not "onTrack" - calculate Fe at beginning of substep, since we need it for state preguess
2009-10-07 21:01:52 +05:30
in nonlocal_microstructure: at the model surface the excess density is now extrapolated from opposite neighbor instead of assuming zero density; this results in better modeling of the dislocation stress at the surface restructured nonlocal_dotstate, to be able to easily switch on and off particular effects in the microstructure evolution nonlocal_dotstate now enforces a cutback when single density runs the risk of becoming negative; in the case of a state already below the relevantState dotState is set to zero introduced two new output variables: rho_dot_edge and rho_dot_screw
2010-05-21 14:21:15 +05:30
rhoDotThermalAnnihilation = 0.0_pReal
cleaning
2019-02-18 14:58:08 +05:30
selfDiffusion = prm%Dsd0 * exp(-prm%selfDiffusionEnergy / (KB * Temperature))
vClimb = prm%atomicVolume * selfDiffusion / ( KB * Temperature ) &
* prm%mu / ( 2.0_pReal * PI * (1.0_pReal-prm%nu) ) &
In order to help preventing further memory leaks all array sections now have an explicit instead of assumed shape, e.g. Fe(1:3,1:3) instead of Fe(:,:).
2011-02-09 18:42:46 +05:30
* 2.0_pReal / ( dUpper(1:ns,1) + dLower(1:ns,1) )
hardening coefficients for fcc are density dependent (line tension effect, Devincre, Kubin, Hoc; 2006; Physical analyses of crystal plasticity by DD simulations) fixed bug with thermal annihilation producing negative density in case of very small dipole density and high climb velocity
2012-10-04 23:38:40 +05:30
forall (s = 1_pInt:ns, dUpper(s,1) > dLower(s,1)) &
rhoDotThermalAnnihilation(s,9) = max(- 4.0_pReal * rhoDip(s,1) * vClimb(s) / (dUpper(s,1) - dLower(s,1)), &
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
- rhoDip(s,1) / timestep - rhoDotAthermalAnnihilation(s,9) &
- rhoDotSingle2DipoleGlide(s,9)) ! make sure that we do not annihilate more dipoles than we have
introduced annihilation of screw dipoles; so far no thermal activation, but immediate annihilation; each annihilated screw dipole leaves behind an edge jog of same length as the dipole height on the collinear system
2012-08-14 17:56:20 +05:30
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
!****************************************************************************
!*** assign the rates of dislocation densities to my dotState
dotState=NaN enforces cutback, if evolution rates lead to negative densities
2012-02-22 21:38:22 +05:30
!*** if evolution rates lead to negative densities, a cutback is enforced
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
in nonlocal_microstructure: at the model surface the excess density is now extrapolated from opposite neighbor instead of assuming zero density; this results in better modeling of the dislocation stress at the surface restructured nonlocal_dotstate, to be able to easily switch on and off particular effects in the microstructure evolution nonlocal_dotstate now enforces a cutback when single density runs the risk of becoming negative; in the case of a state already below the relevantState dotState is set to zero introduced two new output variables: rho_dot_edge and rho_dot_screw
2010-05-21 14:21:15 +05:30
rhoDot = 0.0_pReal
* internal stress calculation now considers dead dislocations always at the interface, not at the center of the IP volume; used to merge them together with "normal" dislocations for stress calculation. * dislocation flux is blocked if we encounter a sign change in the resolved shear stress from the central ip to the neighbor * do not set density to zero if below certain threshold; this creates an artificial sink term
2011-08-02 16:47:45 +05:30
rhoDot = rhoDotFlux &
+ rhoDotMultiplication &
+ rhoDotSingle2DipoleGlide &
+ rhoDotAthermalAnnihilation &
+ rhoDotThermalAnnihilation
in nonlocal_microstructure: at the model surface the excess density is now extrapolated from opposite neighbor instead of assuming zero density; this results in better modeling of the dislocation stress at the surface restructured nonlocal_dotstate, to be able to easily switch on and off particular effects in the microstructure evolution nonlocal_dotstate now enforces a cutback when single density runs the risk of becoming negative; in the case of a state already below the relevantState dotState is set to zero introduced two new output variables: rho_dot_edge and rho_dot_screw
2010-05-21 14:21:15 +05:30
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
results(instance)%rhoDotFlux(1:ns,1:8,o) = rhoDotFlux(1:ns,1:8)
results(instance)%rhoDotMultiplication(1:ns,1:2,o) = rhoDotMultiplication(1:ns,[1,3])
results(instance)%rhoDotSingle2DipoleGlide(1:ns,1:2,o) = rhoDotSingle2DipoleGlide(1:ns,9:10)
results(instance)%rhoDotAthermalAnnihilation(1:ns,1:2,o) = rhoDotAthermalAnnihilation(1:ns,9:10)
results(instance)%rhoDotThermalAnnihilation(1:ns,1:2,o) = rhoDotThermalAnnihilation(1:ns,9:10)
results(instance)%rhoDotEdgeJogs(1:ns,o) = 2.0_pReal * rhoDotThermalAnnihilation(1:ns,1)
rates in constitutive_results are taken directly from last converged step and not calculated again; added output of rates for annihilation of screws and deposition of edge jogs on collinear system
2012-08-16 16:33:22 +05:30
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
In crystallite: for state integrators 2 and 3 the deltaState always has to be done at the beginning of the integration, not at the end; otherwise the stiffness calculation can be completely wrong, when the state is changed after the stress integration for the central solution. Also changed some debugging levels in crystallite and mainly in constitutive_nonlocal
2012-10-22 13:29:35 +05:30
if (iand(debug_level(debug_constitutive),debug_levelExtensive) /= 0_pInt &
let lattice.f90 do the job
2019-02-21 23:48:06 +05:30
.and. ((debug_e == el .and. debug_i == ip)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_constitutive),debug_levelSelective) /= 0_pInt )) then
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
write(6,'(a,/,4(12x,12(e12.5,1x),/))') '<< CONST >> dislocation multiplication', &
rhoDotMultiplication(1:ns,1:4) * timestep
write(6,'(a,/,8(12x,12(e12.5,1x),/))') '<< CONST >> dislocation flux', &
rhoDotFlux(1:ns,1:8) * timestep
write(6,'(a,/,10(12x,12(e12.5,1x),/))') '<< CONST >> dipole formation by glide', &
rhoDotSingle2DipoleGlide * timestep
annihilate only part of the screw dipoles (specified by minimumDipoleHeight), not all; moved annihilation of screws from deltaState back to dotState
2012-11-28 17:39:48 +05:30
write(6,'(a,/,10(12x,12(e12.5,1x),/))') '<< CONST >> athermal dipole annihilation', &
rhoDotAthermalAnnihilation * timestep
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
write(6,'(a,/,2(12x,12(e12.5,1x),/))') '<< CONST >> thermally activated dipole annihilation', &
annihilation of screws
2012-11-17 19:20:20 +05:30
rhoDotThermalAnnihilation(1:ns,9:10) * timestep
polishing (partly redoing changes that got lost when going to rev 3000)
2014-05-23 22:43:08 +05:30
write(6,'(a,/,10(12x,12(e12.5,1x),/))') '<< CONST >> total density change', &
rhoDot * timestep
always use the current state for leaving flux calculation when no neighbor is present
2012-12-09 17:54:32 +05:30
write(6,'(a,/,10(12x,12(f12.5,1x),/))') '<< CONST >> relative density change', &
more functions relying on getRho
2019-03-16 20:16:39 +05:30
rhoDot(1:ns,1:8) * timestep / (abs(stt%rho(:,sgl))+1.0e-10), &
rhoDot(1:ns,9:10) * timestep / (stt%rho(:,dip)+1.0e-10)
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
write(6,*)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
endif
#endif
* corrected compatibility for screws (always positive) * detection of grain boundary in constitutive_nonlocal_microstructure with the help of transmissivity * enforce positive densities in constitutive_nonlocal_microstructure (needed because dotState does not create cutbacks for negative densities anymore) * reset single mobile densities below certain threshold to zero (also done in constitutive_nonlocal_microstructure) * constitutive_nonlocal_kinetics only gets local state variable as input, no need for the entire array here * dv_dtau is always positive * multiplication is only active when there is already some initial density of the respective type
2010-10-26 19:12:18 +05:30
new parameter "significantRho" for nonlocal constitutive law ; density below this value will hardly contribute to dislocation glide or any dislocation reaction ; old parameter "absoluteToleranceRho" is now used only for its initial purpose, namely the absolute tolerance in the state integration
2012-08-23 11:18:21 +05:30
more functions relying on getRho
2019-03-16 20:16:39 +05:30
if ( any(stt%rho(:,mob) + rhoDot(1:ns,1:4) * timestep < -prm%aTolRho) &
.or. any(stt%rho(:,dip) + rhoDot(1:ns,9:10) * timestep < -prm%aTolRho)) then
replaced #ifndef _OPENMP with #ifdef DEBUG to trigger inclusion of parallelized debug statements; fixed minor bugs in debug output
2017-10-03 18:50:53 +05:30
#ifdef DEBUG
made random multiplication switchable via material.config
2012-12-03 18:29:38 +05:30
if (iand(debug_level(debug_constitutive),debug_levelExtensive) /= 0_pInt) then
new parameter "significantRho" for nonlocal constitutive law ; density below this value will hardly contribute to dislocation glide or any dislocation reaction ; old parameter "absoluteToleranceRho" is now used only for its initial purpose, namely the absolute tolerance in the state integration
2012-08-23 11:18:21 +05:30
write(6,'(a,i5,a,i2)') '<< CONST >> evolution rate leads to negative density at el ',el,' ip ',ip
write(6,'(a)') '<< CONST >> enforcing cutback !!!'
endif
#endif
using IEEE_is_NAN and IEEE_quiet_NaN instead of hand-written solution, will not work for gfortran < 5
2017-05-04 04:02:44 +05:30
plasticState(p)%dotState = IEEE_value(1.0_pReal,IEEE_quiet_NaN)
new parameter "significantRho" for nonlocal constitutive law ; density below this value will hardly contribute to dislocation glide or any dislocation reaction ; old parameter "absoluteToleranceRho" is now used only for its initial purpose, namely the absolute tolerance in the state integration
2012-08-23 11:18:21 +05:30
return
else
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
forall (s = 1:ns, t = 1_pInt:4_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(p)%dotState(iRhoU(s,t,instance),o) = rhoDot(s,t)
plasticState(p)%dotState(iRhoB(s,t,instance),o) = rhoDot(s,t+4_pInt)
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
endforall
forall (s = 1:ns, c = 1_pInt:2_pInt) &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
plasticState(p)%dotState(iRhoD(s,c,instance),o) = rhoDot(s,c+8_pInt)
replaced all remaining occurrences of state indices
2013-05-24 17:18:34 +05:30
forall (s = 1:ns) &
better readable
2019-02-22 13:51:04 +05:30
dot%accumulatedshear(s,o) = sum(gdot(s,1:4))
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
endif
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
end associate
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_nonlocal_dotState
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!*********************************************************************
!* COMPATIBILITY UPDATE *
!* Compatibility is defined as normalized product of signed cosine *
!* of the angle between the slip plane normals and signed cosine of *
!* the angle between the slip directions. Only the largest values *
!* that sum up to a total of 1 are considered, all others are set to *
!* zero. *
!*********************************************************************
using new rotation class
2019-02-02 00:58:07 +05:30
subroutine plastic_nonlocal_updateCompatibility(orientation,i,e)
use math, only: math_mul3x3, math_qRot
use rotations, only: rotation
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
use material, only: material_phase, &
material_texture, &
phase_localPlasticity, &
not needed anymore
2019-03-09 17:18:43 +05:30
phase_plasticityInstance
cleaning
2019-02-18 14:58:08 +05:30
use mesh, only: mesh_ipNeighborhood, &
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
theMesh
don't parse material.config any more
2019-02-20 23:33:20 +05:30
use lattice, only: lattice_qDisorientation
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
implicit none
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* input variables
integer(pInt), intent(in) :: i, & ! ip index
e ! element index
Merge remote-tracking branch 'origin/development' into 10-consistent-orientation-conversions-3
2019-02-23 03:35:36 +05:30
type(rotation), dimension(1,theMesh%elem%nIPs,theMesh%nElems), intent(in) :: &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
orientation ! crystal orientation in quaternions
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* local variables
integer(pInt) Nneighbors, & ! number of neighbors
n, & ! neighbor index
neighbor_e, & ! element index of my neighbor
neighbor_i, & ! integration point index of my neighbor
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
neighbor_phase, &
textureID, &
neighbor_textureID, &
instance, & ! instance of plasticity
ns, & ! number of active slip systems
s1, & ! slip system index (me)
s2 ! slip system index (my neighbor)
real(pReal), dimension(4) :: absoluteMisorientation ! absolute misorientation (without symmetry) between me and my neighbor
real(pReal), dimension(2,totalNslip(phase_plasticityInstance(material_phase(1,i,e))),&
totalNslip(phase_plasticityInstance(material_phase(1,i,e))),&
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
theMesh%elem%nIPneighbors) :: &
don't parse material.config any more
2019-02-20 23:33:20 +05:30
my_compatibility ! my_compatibility for current element and ip
real(pReal) :: my_compatibilitySum, &
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
thresholdValue, &
nThresholdValues
logical, dimension(totalNslip(phase_plasticityInstance(material_phase(1,i,e)))) :: &
belowThreshold
using new rotation class
2019-02-02 00:58:07 +05:30
type(rotation) :: rot
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
use new elem/mesh variables
2019-02-02 16:20:07 +05:30
Nneighbors = theMesh%elem%nIPneighbors
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph = material_phase(1,i,e)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
textureID = material_texture(1,i,e)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
instance = phase_plasticityInstance(ph)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
ns = totalNslip(instance)
cleaning
2019-02-18 14:58:08 +05:30
associate(prm => param(instance))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!*** start out fully compatible
my_compatibility = 0.0_pReal
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
forall(s1 = 1_pInt:ns) my_compatibility(1:2,s1,s1,1:Nneighbors) = 1.0_pReal
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!*** Loop thrugh neighbors and check whether there is any my_compatibility.
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
neighbors: do n = 1_pInt,Nneighbors
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
neighbor_e = mesh_ipNeighborhood(1,n,i,e)
neighbor_i = mesh_ipNeighborhood(2,n,i,e)
!* FREE SURFACE
!* Set surface transmissivity to the value specified in the material.config
if (neighbor_e <= 0_pInt .or. neighbor_i <= 0_pInt) then
cleaning
2019-02-18 14:58:08 +05:30
forall(s1 = 1_pInt:ns) my_compatibility(1:2,s1,s1,n) = sqrt(prm%surfaceTransmissivity)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
cycle
endif
!* PHASE BOUNDARY
!* If we encounter a different nonlocal "cpfem" phase at the neighbor,
!* we consider this to be a real "physical" phase boundary, so completely incompatible.
!* If one of the two "CPFEM" phases has a local plasticity law,
!* we do not consider this to be a phase boundary, so completely compatible.
neighbor_phase = material_phase(1,neighbor_i,neighbor_e)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
if (neighbor_phase /= ph) then
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
if (.not. phase_localPlasticity(neighbor_phase) .and. .not. phase_localPlasticity(ph))&
forall(s1 = 1_pInt:ns) my_compatibility(1:2,s1,s1,n) = 0.0_pReal
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
cycle
endif
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
!* GRAIN BOUNDARY !
!* fixed transmissivity for adjacent ips with different texture (only if explicitly given in material.config)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cleaning
2019-02-18 14:58:08 +05:30
if (prm%grainboundaryTransmissivity >= 0.0_pReal) then
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
neighbor_textureID = material_texture(1,neighbor_i,neighbor_e)
if (neighbor_textureID /= textureID) then
if (.not. phase_localPlasticity(neighbor_phase)) then
forall(s1 = 1_pInt:ns) &
cleaning
2019-02-18 14:58:08 +05:30
my_compatibility(1:2,s1,s1,n) = sqrt(prm%grainboundaryTransmissivity)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
endif
cycle
endif
!* GRAIN BOUNDARY ?
!* Compatibility defined by relative orientation of slip systems:
!* The my_compatibility value is defined as the product of the slip normal projection and the slip direction projection.
!* Its sign is always positive for screws, for edges it has the same sign as the slip normal projection.
!* Since the sum for each slip system can easily exceed one (which would result in a transmissivity larger than one),
!* only values above or equal to a certain threshold value are considered. This threshold value is chosen, such that
!* the number of compatible slip systems is minimized with the sum of the original my_compatibility values exceeding one.
!* Finally the smallest my_compatibility value is decreased until the sum is exactly equal to one.
!* All values below the threshold are set to zero.
else
using new rotation class
2019-02-02 00:58:07 +05:30
rot = orientation(1,i,e)%misorientation(orientation(1,neighbor_i,neighbor_e))
absoluteMisorientation = rot%asQuaternion()
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
mySlipSystems: do s1 = 1_pInt,ns
neighborSlipSystems: do s2 = 1_pInt,ns
don't parse material.config any more
2019-02-20 23:33:20 +05:30
my_compatibility(1,s2,s1,n) = math_mul3x3(prm%slip_normal(1:3,s1), &
math_qRot(absoluteMisorientation, prm%slip_normal(1:3,s2))) &
* abs(math_mul3x3(prm%slip_direction(1:3,s1), &
math_qRot(absoluteMisorientation, prm%slip_direction(1:3,s2))))
my_compatibility(2,s2,s1,n) = abs(math_mul3x3(prm%slip_normal(1:3,s1), &
math_qRot(absoluteMisorientation, prm%slip_normal(1:3,s2)))) &
* abs(math_mul3x3(prm%slip_direction(1:3,s1), &
math_qRot(absoluteMisorientation, prm%slip_direction(1:3,s2))))
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
enddo neighborSlipSystems
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
my_compatibilitySum = 0.0_pReal
belowThreshold = .true.
do while (my_compatibilitySum < 1.0_pReal .and. any(belowThreshold(1:ns)))
thresholdValue = maxval(my_compatibility(2,1:ns,s1,n), belowThreshold(1:ns)) ! screws always positive
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
nThresholdValues = real(count(my_compatibility(2,1:ns,s1,n) >= thresholdValue),pReal)
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
where (my_compatibility(2,1:ns,s1,n) >= thresholdValue) &
belowThreshold(1:ns) = .false.
if (my_compatibilitySum + thresholdValue * nThresholdValues > 1.0_pReal) &
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
where (abs(my_compatibility(1:2,1:ns,s1,n)) >= thresholdValue) & ! MD: rather check below threshold?
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
my_compatibility(1:2,1:ns,s1,n) = sign((1.0_pReal - my_compatibilitySum) &
/ nThresholdValues, my_compatibility(1:2,1:ns,s1,n))
my_compatibilitySum = my_compatibilitySum + nThresholdValues * thresholdValue
enddo
where (belowThreshold(1:ns)) my_compatibility(1,1:ns,s1,n) = 0.0_pReal
where (belowThreshold(1:ns)) my_compatibility(2,1:ns,s1,n) = 0.0_pReal
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
enddo mySlipSystems
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
endif
removed compiler warnings about conversion and floating point comparison
2016-05-27 15:16:34 +05:30
enddo neighbors
fixed error with Noutput counter and few other newstate related changes (nonlocal)
2014-06-26 19:23:12 +05:30
compatibility(1:2,1:ns,1:ns,1:Nneighbors,i,e) = my_compatibility
cleaning
2019-02-18 14:58:08 +05:30
end associate
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_nonlocal_updateCompatibility
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
- added get slip rate helper function - added vacancy generation rate - cleaned up some bugs
2014-10-11 15:15:30 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief return array of constitutive results
!--------------------------------------------------------------------------------------------------
simplified/not needed
2019-02-20 12:03:19 +05:30
function plastic_nonlocal_postResults(Mp,ip,el) result(postResults)
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
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
use math, only: &
math_mul33x3, &
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
math_mul33xx33, &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
pi
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, &
gfortran complaint about implicit casting,floating point comparison, and unused imported variables. additionally changed use of math_invert33 to math_inv33 if det is not needed
2015-04-11 00:39:26 +05:30
phase_plasticityInstance
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
implicit none
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
real(pReal), dimension(3,3), intent(in) :: Mp !< MandelStress
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
integer(pInt), intent(in) :: &
ip, & !< integration point
el !< element
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
was not used
2019-02-15 11:33:52 +05:30
real(pReal), dimension(sum(plastic_nonlocal_sizePostResult(:,phase_plasticityInstance(material_phase(1_pInt,ip,el))))) :: &
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
integer(pInt) :: &
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
ph, &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
instance, & !< current instance of this plasticity
ns, & !< short notation for the total number of active slip systems
c, & !< character of dislocation
cs, & !< constitutive result index
o, & !< index of current output
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
of,& !< offset shortcut
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
t, & !< type of dislocation
cleaning
2019-02-18 14:58:08 +05:30
s !< index of my current slip system
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),8) :: &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
rhoSgl, & !< current single dislocation densities (positive/negative screw and edge without dipoles)
rhoDotSgl !< evolution rate of single dislocation densities (positive/negative screw and edge without dipoles)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),4) :: &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
gdot, & !< shear rates
v !< velocities
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el)))) :: &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
rhoForest, & !< forest dislocation density
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau !< current resolved shear stress
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
real(pReal), dimension(totalNslip(phase_plasticityInstance(material_phase(1_pInt,ip,el))),2) :: &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
rhoDip, & !< current dipole dislocation densities (screw and edge dipoles)
rhoDotDip, & !< evolution rate of dipole dislocation densities (screw and edge dipoles)
dLower, & !< minimum stable dipole distance for edges and screws
simplified/not needed
2019-02-20 12:03:19 +05:30
dUpper !< current maximum stable dipole distance for edges and screws
exchanged mappingConstitutive array for more descriptive "phaseAt and phasememberAt"
2016-01-15 05:49:44 +05:30
ph = phaseAt(1,ip,el)
of = phasememberAt(1,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)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
ns = totalNslip(instance)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = 0_pInt
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
better readable
2019-02-22 13:51:04 +05:30
associate(prm => param(instance),dst => microstructure(instance),stt=>state(instance))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!* short hand notations for state variables
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
rhoSgl(s,t) = plasticState(ph)%State(iRhoU(s,t,instance),of)
rhoSgl(s,t+4_pInt) = plasticState(ph)%State(iRhoB(s,t,instance),of)
v(s,t) = plasticState(ph)%State(iV(s,t,instance),of)
rhoDotSgl(s,t) = plasticState(ph)%dotState(iRhoU(s,t,instance),of)
rhoDotSgl(s,t+4_pInt) = plasticState(ph)%dotState(iRhoB(s,t,instance),of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
endforall
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
rhoDip(s,c) = plasticState(ph)%State(iRhoD(s,c,instance),of)
rhoDotDip(s,c) = plasticState(ph)%dotState(iRhoD(s,c,instance),of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
endforall
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
rhoForest = plasticState(ph)%State(iRhoF(1:ns,instance),of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!* Calculate shear rate
forall (t = 1_pInt:4_pInt) &
using more parameters from parameter structure
2019-02-19 03:25:31 +05:30
gdot(1:ns,t) = rhoSgl(1:ns,t) * prm%burgers(1:ns) * v(1:ns,t)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
!* calculate limits for stable dipole height
do s = 1_pInt,ns
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
tau(s) = math_mul33xx33(Mp, prm%Schmid(1:3,1:3,s)) + dst%tau_back(s,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
if (abs(tau(s)) < 1.0e-15_pReal) tau(s) = 1.0e-15_pReal
enddo
transition to param structure
2019-02-20 13:43:50 +05:30
dLower = prm%minDipoleHeight(1:ns,1:2)
simplified/not needed
2019-02-20 12:03:19 +05:30
dUpper(1:ns,1) = prm%mu * prm%burgers(1:ns) &
/ (8.0_pReal * pi * (1.0_pReal - prm%nu) * abs(tau))
dUpper(1:ns,2) = prm%mu * prm%burgers(1:ns) &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
/ (4.0_pReal * pi * abs(tau))
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
do c = 1, 2
using improved dEq0/dNeq instead of dEq/dNeq with 0.0 argument
2016-10-29 13:09:08 +05:30
where(dNeq0(sqrt(rhoSgl(1:ns,2*c-1)+rhoSgl(1:ns,2*c)+abs(rhoSgl(1:ns,2*c+3))&
+abs(rhoSgl(1:ns,2*c+4))+rhoDip(1:ns,c)))) &
fixed floating point exception in nonlocal (calculation of dUpper at several places)
2014-06-27 01:31:38 +05:30
dUpper(1:ns,c) = min(1.0_pReal / sqrt(rhoSgl(1:ns,2*c-1) + rhoSgl(1:ns,2*c) &
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
+ abs(rhoSgl(1:ns,2*c+3)) + abs(rhoSgl(1:ns,2*c+4)) + rhoDip(1:ns,c)), &
dUpper(1:ns,c))
where within forall does not work with PGI
2019-03-08 13:17:30 +05:30
enddo
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
dUpper = max(dUpper,dLower)
changed to new state, please report bugs to Luv or Martin
2014-07-02 17:57:39 +05:30
fixed state size and output size
2019-02-17 03:48:53 +05:30
outputsLoop: do o = 1_pInt,size(param(instance)%outputID)
select case(param(instance)%outputID(o))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_mob_edg_pos_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_mob_edg_pos(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_imm_edg_pos_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_imm_edg_pos(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_mob_edg_neg_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_mob_edg_neg(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_imm_edg_neg_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_imm_edg_neg(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_dip_edg_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_dip_edg(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_mob_scr_pos_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_mob_scr_pos(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_imm_scr_pos_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_imm_scr_pos(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_mob_scr_neg_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_mob_scr_neg(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_sgl_imm_scr_neg_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_sgl_imm_scr_neg(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
more systematic names
2019-03-16 13:25:25 +05:30
case (rho_dip_scr_ID)
postResults(cs+1_pInt:cs+ns) = stt%rho_dip_scr(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_forest_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = rhoForest
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (shearrate_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = sum(gdot,2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (resolvedstress_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = tau
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (resolvedstress_back_ID)
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
postResults(cs+1_pInt:cs+ns) = dst%tau_back(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (resolvedstress_external_ID)
do s = 1_pInt,ns
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+s) = math_mul33xx33(Mp, prm%Schmid(1:3,1:3,s))
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
enddo
cs = cs + ns
case (resistance_ID)
use microstructure/dependent state introduced only partly, otherwise the uncommon calling sequence in nonlocal leads to a change in behavior
2019-02-21 10:25:03 +05:30
postResults(cs+1_pInt:cs+ns) = dst%tau_Threshold(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_sgl_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = sum(rhoDotSgl(1:ns,1:4),2) &
+ sum(rhoDotSgl(1:ns,5:8)*sign(1.0_pReal,rhoSgl(1:ns,5:8)),2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_sgl_mobile_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = sum(rhoDotSgl(1:ns,1:4),2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_dip_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = sum(rhoDotDip,2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
only output direct quantities derived quantities can be easily calculated during post processing
2019-01-15 09:25:40 +05:30
case (rho_dot_gen_ID) ! Obsolete
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotMultiplication(1:ns,1,of) &
+ results(instance)%rhoDotMultiplication(1:ns,2,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
introduced itmin parameter for spectral code for defining minimum number of cycles removed simplified_algorthim flag because the basic scheme using the polarization field will not be implemented introduced divergence_correction flag for making divergence criterion resolution-independent (still experimental and not set by default) corrected output and restart frequency (now modulo on incs of current load case)
2012-02-23 22:13:17 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_gen_edge_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotMultiplication(1:ns,1,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_gen_screw_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotMultiplication(1:ns,2,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_sgl2dip_edge_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotSingle2DipoleGlide(1:ns,1,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_sgl2dip_screw_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotSingle2DipoleGlide(1:ns,2,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_ann_ath_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotAthermalAnnihilation(1:ns,1,of) &
+ results(instance)%rhoDotAthermalAnnihilation(1:ns,2,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_ann_the_edge_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotThermalAnnihilation(1:ns,1,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_ann_the_screw_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotThermalAnnihilation(1:ns,2,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_edgejogs_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = results(instance)%rhoDotEdgeJogs(1:ns,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_flux_mobile_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = sum(results(instance)%rhoDotFlux(1:ns,1:4,of),2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case (rho_dot_flux_edge_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = sum(results(instance)%rhoDotFlux(1:ns,1:2,of),2) &
+ sum(results(instance)%rhoDotFlux(1:ns,5:6,of)*sign(1.0_pReal,rhoSgl(1:ns,5:6)),2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (rho_dot_flux_screw_ID)
using structure for output avoids waste of memory in case of multiple instances avoids explicit dependence on ip and el
2019-02-20 18:02:08 +05:30
postResults(cs+1_pInt:cs+ns) = sum(results(instance)%rhoDotFlux(1:ns,3:4,of),2) &
+ sum(results(instance)%rhoDotFlux(1:ns,7:8,of)*sign(1.0_pReal,rhoSgl(1:ns,7:8)),2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (velocity_edge_pos_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = v(1:ns,1)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (velocity_edge_neg_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = v(1:ns,2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (velocity_screw_pos_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = v(1:ns,3)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (velocity_screw_neg_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = v(1:ns,4)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (maximumdipoleheight_edge_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = dUpper(1:ns,1)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
case (maximumdipoleheight_screw_ID)
simplified/not needed
2019-02-20 12:03:19 +05:30
postResults(cs+1_pInt:cs+ns) = dUpper(1:ns,2)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
only output direct quantities derived quantities can be easily calculated during post processing
2019-01-15 09:25:40 +05:30
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
case(accumulatedshear_ID)
better readable
2019-02-22 13:51:04 +05:30
postResults(cs+1_pInt:cs+ns) = stt%accumulatedshear(:,of)
applied new State for nonlocal model and a trivial changes in crystallite
2014-06-14 02:23:17 +05:30
cs = cs + ns
end select
enddo outputsLoop
use parameter structure and avoid conversion 33<->6
2019-02-17 16:45:46 +05:30
end associate
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_nonlocal_postResults
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
dummy HDF5 output for all plasticity laws
2019-03-10 01:13:31 +05:30
improving readability - arrays to access specific dislocation types - function to access and clean rho
2019-03-16 17:43:48 +05:30
function getRho(instance,of,ip,el)
use mesh
implicit none
integer, intent(in) :: instance, of,ip,el
real(pReal), dimension(param(instance)%totalNslip,10) :: getRho
associate(prm => param(instance))
getRho = reshape(state(instance)%rho(:,of),[prm%totalNslip,10])
! ensure mobile densities (not for imm, they have a sign)
getRho(:,mob) = max(getRho(:,mob),0.0_pReal)
getRho(:,dip) = max(getRho(:,dip),0.0_pReal)
where (abs(getRho) * mesh_ipVolume(ip,el) ** 0.667_pReal < prm%significantN &
.or. abs(getRho) < prm%significantRho) &
getRho = 0.0_pReal
end associate
end function getRho
dummy HDF5 output for all plasticity laws
2019-03-10 01:13:31 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief writes results to HDF5 output file
!--------------------------------------------------------------------------------------------------
subroutine plastic_nonlocal_results(instance,group)
#if defined(PETSc) || defined(DAMASKHDF5)
use results
implicit none
integer, intent(in) :: instance
character(len=*) :: group
integer :: o
associate(prm => param(instance), stt => state(instance))
outputsLoop: do o = 1_pInt,size(prm%outputID)
select case(prm%outputID(o))
end select
enddo outputsLoop
end associate
#else
integer, intent(in) :: instance
character(len=*) :: group
#endif
end subroutine plastic_nonlocal_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
end module plastic_nonlocal