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

3238 lines
178 KiB
Fortran
Raw Normal View History

changed enconding of all source files to UTF-8 without BOM (signature) Codepage 65001
2011-04-07 12:50:28 +05:30
! Copyright 2011 Max-Planck-Institut für Eisenforschung GmbH
added copyright text to all f90 (free) format files
2011-04-04 19:39:54 +05:30
!
! This file is part of DAMASK,
changed enconding of all source files to UTF-8 without BOM (signature) Codepage 65001
2011-04-07 12:50:28 +05:30
! the Düsseldorf Advanced MAterial Simulation Kit.
added copyright text to all f90 (free) format files
2011-04-04 19:39:54 +05:30
!
! DAMASK is free software: you can redistribute it and/or modify
! it under the terms of the GNU General Public License as published by
! the Free Software Foundation, either version 3 of the License, or
! (at your option) any later version.
!
! DAMASK is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with DAMASK. If not, see <http://www.gnu.org/licenses/>.
!
!##############################################################
added version information to all files do NOT edit text like this: $Id: constitutive_phenopowerlaw.f90 406 2009-08-31 14:13:10Z MPIE\f.roters $
2009-08-31 20:39:15 +05:30
!* $Id$
no change to previous version, just forget to mention one important change of the last revision: * fluxes are now again calculated and distributed only! by the originating material point. this means that the central MP might change the dotState of its neighbor. have to see whether locks slow down parallel computation
2010-10-26 19:19:58 +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
!* Module: CONSTITUTIVE_NONLOCAL *
!************************************
!* contains: *
!* - constitutive equations *
!* - parameters definition *
!************************************
MODULE constitutive_nonlocal
!* Include other modules
use prec, only: pReal,pInt
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
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
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
private
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
!* Definition of parameters
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
character (len=*), parameter, public :: &
constitutive_nonlocal_label = 'nonlocal'
character(len=22), dimension(10), parameter, private :: &
constitutive_nonlocal_listBasicStates = (/'rhoSglEdgePosMobile ', &
'rhoSglEdgeNegMobile ', &
'rhoSglScrewPosMobile ', &
'rhoSglScrewNegMobile ', &
'rhoSglEdgePosImmobile ', &
'rhoSglEdgeNegImmobile ', &
'rhoSglScrewPosImmobile', &
'rhoSglScrewNegImmobile', &
'rhoDipEdge ', &
'rhoDipScrew ' /)! list of "basic" microstructural state variables that are independent from other state variables
character(len=16), dimension(3), parameter, private :: &
constitutive_nonlocal_listDependentStates = (/'rhoForest ', &
'tauThreshold ', &
'tauBack ' /) ! list of microstructural state variables that depend on other state variables
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
character(len=20), dimension(6), parameter, private :: &
constitutive_nonlocal_listOtherStates = (/'velocityEdgePos ', &
'velocityEdgeNeg ', &
'velocityScrewPos ', &
'velocityScrewNeg ', &
'maxDipoleHeightEdge ', &
'maxDipoleHeightScrew' /) ! list of other dependent state variables that are not updated by microstructure
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
real(pReal), parameter, private :: &
kB = 1.38e-23_pReal ! Physical parameter, Boltzmann constant in J/Kelvin
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
!* Definition of global variables
* 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
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
integer(pInt), dimension(:), allocatable, public :: &
constitutive_nonlocal_sizeDotState, & ! number of dotStates = number of basic state variables
constitutive_nonlocal_sizeDependentState, & ! number of dependent state variables
constitutive_nonlocal_sizeState, & ! total number of state variables
constitutive_nonlocal_sizePostResults ! cumulative size of post results
integer(pInt), dimension(:,:), allocatable, target, public :: &
constitutive_nonlocal_sizePostResult ! size of each post result output
character(len=64), dimension(:,:), allocatable, target, public :: &
constitutive_nonlocal_output ! name of each post result output
integer(pInt), dimension(:), allocatable, private :: &
constitutive_nonlocal_Noutput ! number of outputs per instance of this plasticity
character(len=32), dimension(:), allocatable, private :: &
constitutive_nonlocal_structureName ! name of the lattice structure
integer(pInt), dimension(:), allocatable, public :: &
constitutive_nonlocal_structure ! number representing the kind of lattice structure
integer(pInt), dimension(:), allocatable, private :: &
constitutive_nonlocal_totalNslip ! total number of active slip systems for each instance
integer(pInt), dimension(:,:), allocatable, private :: &
constitutive_nonlocal_Nslip, & ! number of active slip systems for each family and instance
constitutive_nonlocal_slipFamily, & ! lookup table relating active slip system to slip family for each instance
constitutive_nonlocal_slipSystemLattice ! lookup table relating active slip system index to lattice slip system index for each instance
real(pReal), dimension(:), allocatable, private :: &
constitutive_nonlocal_CoverA, & ! c/a ratio for hex type lattice
constitutive_nonlocal_C11, & ! C11 element in elasticity matrix
constitutive_nonlocal_C12, & ! C12 element in elasticity matrix
constitutive_nonlocal_C13, & ! C13 element in elasticity matrix
constitutive_nonlocal_C33, & ! C33 element in elasticity matrix
constitutive_nonlocal_C44, & ! C44 element in elasticity matrix
constitutive_nonlocal_Gmod, & ! shear modulus
constitutive_nonlocal_nu, & ! poisson's ratio
constitutive_nonlocal_atomicVolume, & ! atomic volume
constitutive_nonlocal_Dsd0, & ! prefactor for self-diffusion coefficient
constitutive_nonlocal_Qsd, & ! activation enthalpy for diffusion
constitutive_nonlocal_aTolRho, & ! absolute tolerance for dislocation density in state integration
constitutive_nonlocal_R, & ! cutoff radius for dislocation stress
constitutive_nonlocal_doublekinkwidth, & ! width of a doubkle kink in multiples of the burgers vector length b
constitutive_nonlocal_solidSolutionEnergy, & ! activation energy for solid solution in J
constitutive_nonlocal_solidSolutionSize, & ! solid solution obstacle size in multiples of the burgers vector length
constitutive_nonlocal_solidSolutionConcentration, & ! concentration of solid solution in atomic parts
constitutive_nonlocal_p, & ! parameter for kinetic law (Kocks,Argon,Ashby)
constitutive_nonlocal_q, & ! parameter for kinetic law (Kocks,Argon,Ashby)
constitutive_nonlocal_viscosity, & ! viscosity for dislocation glide in Pa s
constitutive_nonlocal_fattack, & ! attack frequency in Hz
constitutive_nonlocal_rhoSglScatter, & ! standard deviation of scatter in initial dislocation density
constitutive_nonlocal_surfaceTransmissivity ! transmissivity at free surface
real(pReal), dimension(:,:,:), allocatable, private :: &
constitutive_nonlocal_Cslip_66 ! elasticity matrix in Mandel notation for each instance
real(pReal), dimension(:,:,:,:,:), allocatable, private :: &
constitutive_nonlocal_Cslip_3333 ! elasticity matrix for each instance
real(pReal), dimension(:,:), allocatable, private :: &
constitutive_nonlocal_rhoSglEdgePos0, & ! initial edge_pos dislocation density per slip system for each family and instance
constitutive_nonlocal_rhoSglEdgeNeg0, & ! initial edge_neg dislocation density per slip system for each family and instance
constitutive_nonlocal_rhoSglScrewPos0, & ! initial screw_pos dislocation density per slip system for each family and instance
constitutive_nonlocal_rhoSglScrewNeg0, & ! initial screw_neg dislocation density per slip system for each family and instance
constitutive_nonlocal_rhoDipEdge0, & ! initial edge dipole dislocation density per slip system for each family and instance
constitutive_nonlocal_rhoDipScrew0, & ! initial screw dipole dislocation density per slip system for each family and instance
constitutive_nonlocal_lambda0PerSlipFamily, & ! mean free path prefactor for each family and instance
constitutive_nonlocal_lambda0, & ! mean free path prefactor for each slip system and instance
constitutive_nonlocal_burgersPerSlipFamily, & ! absolute length of burgers vector [m] for each family and instance
constitutive_nonlocal_burgers, & ! absolute length of burgers vector [m] for each slip system and instance
constitutive_nonlocal_interactionSlipSlip ! coefficients for slip-slip interaction for each interaction type and instance
real(pReal), dimension(:,:,:), allocatable, private :: &
constitutive_nonlocal_minimumDipoleHeightPerSlipFamily, & ! minimum stable edge/screw dipole height for each family and instance
constitutive_nonlocal_minimumDipoleHeight, & ! minimum stable edge/screw dipole height for each slip system and instance
constitutive_nonlocal_peierlsStressPerSlipFamily, & ! Peierls stress (edge and screw)
constitutive_nonlocal_peierlsStress ! Peierls stress (edge and screw)
real(pReal), dimension(:,:,:,:,:), allocatable, private :: &
constitutive_nonlocal_rhoDotFlux ! dislocation convection term
real(pReal), dimension(:,:,:,:,:,:), allocatable, private :: &
constitutive_nonlocal_compatibility ! slip system compatibility between me and my neighbors
real(pReal), dimension(:,:,:), allocatable, private :: &
constitutive_nonlocal_forestProjectionEdge, & ! matrix of forest projections of edge dislocations for each instance
constitutive_nonlocal_forestProjectionScrew, & ! matrix of forest projections of screw dislocations for each instance
constitutive_nonlocal_interactionMatrixSlipSlip ! interaction matrix of the different slip systems for each instance
real(pReal), dimension(:,:,:,:), allocatable, private :: &
constitutive_nonlocal_lattice2slip, & ! orthogonal transformation matrix from lattice coordinate system to slip coordinate system (passive rotation !!!)
constitutive_nonlocal_accumulatedShear ! accumulated shear per slip system up to the start of the FE increment
logical, dimension(:), allocatable, private :: &
constitutive_nonlocal_shortRangeStressCorrection ! flag indicating the use of the short range stress correction by a excess density gradient term
public :: &
constitutive_nonlocal_init, &
constitutive_nonlocal_stateInit, &
constitutive_nonlocal_aTolState, &
constitutive_nonlocal_homogenizedC, &
constitutive_nonlocal_microstructure, &
constitutive_nonlocal_LpAndItsTangent, &
constitutive_nonlocal_dotState, &
constitutive_nonlocal_deltaState, &
constitutive_nonlocal_dotTemperature, &
constitutive_nonlocal_updateCompatibility, &
constitutive_nonlocal_postResults
private :: &
constitutive_nonlocal_kinetics
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
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
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
!**************************************
!* Module initialization *
!**************************************
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
subroutine constitutive_nonlocal_init(myFile)
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, 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
use, intrinsic :: iso_fortran_env ! to get compiler_version and compiler_options (at least for gfortran 4.6 at the moment)
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 prec, only: pInt, pReal
use math, only: math_Mandel3333to66, &
math_Voigt66to3333, &
* 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
math_mul3x3, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33
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 IO, only: IO_lc, &
IO_getTag, &
IO_isBlank, &
IO_stringPos, &
IO_stringValue, &
IO_floatValue, &
IO_intValue, &
IO_error
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_constitutive, &
debug_levelBasic
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
use mesh, only: mesh_NcpElems, &
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
mesh_maxNips, &
FE_maxNipNeighbors
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
use material, only: homogenization_maxNgrains, &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
phase_plasticity, &
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
phase_Noutput
use lattice, only: lattice_maxNslipFamily, &
lattice_maxNslip, &
lattice_maxNinteraction, &
lattice_NslipSystem, &
lattice_initializeStructure, &
lattice_sd, &
lattice_sn, &
lattice_st, &
lattice_interactionSlipSlip
!*** output variables
!*** input variables
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
integer(pInt), intent(in) :: myFile
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
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
integer(pInt), parameter :: maxNchunks = 21_pInt
integer(pInt), &
dimension(1_pInt+2_pInt*maxNchunks) :: positions
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
integer(pInt) section, &
maxNinstance, &
maxTotalNslip, &
myStructure, &
f, & ! index of my slip family
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
i, & ! index of my instance of this plasticity
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
j, &
k, &
l, &
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
ns, & ! short notation for total number of active slip systems for the current 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
o, & ! index of my output
s, & ! index of my slip system
s1, & ! index of my slip system
s2, & ! index of my slip system
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
it, & ! index of my interaction type
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
mySize
character(len=64) tag
character(len=1024) line
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
!$OMP CRITICAL (write2out)
write(6,*)
homogenization_*, constitutive_*, DAMASK_spectral_interface: did some polishing regarding init output makefile: corrected spelling mistake
2011-08-26 19:27:29 +05:30
write(6,*) '<<<+- constitutive_',trim(constitutive_nonlocal_label),' init -+>>>'
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
write(6,*) '$Id$'
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
#include "compilation_info.f90"
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
!$OMP END CRITICAL (write2out)
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
maxNinstance = int(count(phase_plasticity == constitutive_nonlocal_label),pInt)
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
if (maxNinstance == 0) return ! we don't have to do anything if there's no instance for this constitutive law
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) then
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
!$OMP CRITICAL (write2out)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a16,1x,i5)') '# instances:',maxNinstance
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
!$OMP END CRITICAL (write2out)
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
!*** space allocation for global variables
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
allocate(constitutive_nonlocal_sizeDotState(maxNinstance))
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
allocate(constitutive_nonlocal_sizeDependentState(maxNinstance))
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
allocate(constitutive_nonlocal_sizeState(maxNinstance))
allocate(constitutive_nonlocal_sizePostResults(maxNinstance))
allocate(constitutive_nonlocal_sizePostResult(maxval(phase_Noutput), maxNinstance))
allocate(constitutive_nonlocal_output(maxval(phase_Noutput), maxNinstance))
store number of outputs for each instance of the constitution in constitutive_[j2/titanmod/...]_Nouput and use this value to loop over all valid outputs when determining the size of the outputs array
2012-02-14 20:49:59 +05:30
allocate(constitutive_nonlocal_Noutput(maxNinstance))
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
constitutive_nonlocal_sizeDotState = 0_pInt
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
constitutive_nonlocal_sizeDependentState = 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
constitutive_nonlocal_sizeState = 0_pInt
constitutive_nonlocal_sizePostResults = 0_pInt
constitutive_nonlocal_sizePostResult = 0_pInt
constitutive_nonlocal_output = ''
store number of outputs for each instance of the constitution in constitutive_[j2/titanmod/...]_Nouput and use this value to loop over all valid outputs when determining the size of the outputs array
2012-02-14 20:49:59 +05:30
constitutive_nonlocal_Noutput = 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
allocate(constitutive_nonlocal_structureName(maxNinstance))
allocate(constitutive_nonlocal_structure(maxNinstance))
allocate(constitutive_nonlocal_Nslip(lattice_maxNslipFamily, maxNinstance))
allocate(constitutive_nonlocal_slipFamily(lattice_maxNslip, maxNinstance))
allocate(constitutive_nonlocal_slipSystemLattice(lattice_maxNslip, maxNinstance))
allocate(constitutive_nonlocal_totalNslip(maxNinstance))
constitutive_nonlocal_structureName = ''
constitutive_nonlocal_structure = 0_pInt
constitutive_nonlocal_Nslip = 0_pInt
constitutive_nonlocal_slipFamily = 0_pInt
constitutive_nonlocal_slipSystemLattice = 0_pInt
constitutive_nonlocal_totalNslip = 0_pInt
allocate(constitutive_nonlocal_CoverA(maxNinstance))
allocate(constitutive_nonlocal_C11(maxNinstance))
allocate(constitutive_nonlocal_C12(maxNinstance))
allocate(constitutive_nonlocal_C13(maxNinstance))
allocate(constitutive_nonlocal_C33(maxNinstance))
allocate(constitutive_nonlocal_C44(maxNinstance))
allocate(constitutive_nonlocal_Gmod(maxNinstance))
allocate(constitutive_nonlocal_nu(maxNinstance))
allocate(constitutive_nonlocal_atomicVolume(maxNinstance))
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
allocate(constitutive_nonlocal_Dsd0(maxNinstance))
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
allocate(constitutive_nonlocal_Qsd(maxNinstance))
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
allocate(constitutive_nonlocal_aTolRho(maxNinstance))
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
allocate(constitutive_nonlocal_Cslip_66(6,6,maxNinstance))
allocate(constitutive_nonlocal_Cslip_3333(3,3,3,3,maxNinstance))
dislocation stress now considers dislocation segments of length V^(1/3) and ensures non-singular solution for points that are collinear to the dislocation line by means of a core spreading parameter "a". stress is scaled by a reference cutoff radius "r" to avoid mesh-dependent stress values. corrected formula for conversion of anisotropic elastic constants to isotropic Youngs modulus and poissons ratio
2010-06-07 20:02:23 +05:30
allocate(constitutive_nonlocal_R(maxNinstance))
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
allocate(constitutive_nonlocal_doublekinkwidth(maxNinstance))
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
allocate(constitutive_nonlocal_solidSolutionEnergy(maxNinstance))
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
allocate(constitutive_nonlocal_solidSolutionSize(maxNinstance))
allocate(constitutive_nonlocal_solidSolutionConcentration(maxNinstance))
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
allocate(constitutive_nonlocal_p(maxNinstance))
allocate(constitutive_nonlocal_q(maxNinstance))
allocate(constitutive_nonlocal_viscosity(maxNinstance))
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
allocate(constitutive_nonlocal_fattack(maxNinstance))
* 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
allocate(constitutive_nonlocal_rhoSglScatter(maxNinstance))
* 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
allocate(constitutive_nonlocal_surfaceTransmissivity(maxNinstance))
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
allocate(constitutive_nonlocal_shortRangeStressCorrection(maxNinstance))
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
constitutive_nonlocal_CoverA = 0.0_pReal
constitutive_nonlocal_C11 = 0.0_pReal
constitutive_nonlocal_C12 = 0.0_pReal
constitutive_nonlocal_C13 = 0.0_pReal
constitutive_nonlocal_C33 = 0.0_pReal
constitutive_nonlocal_C44 = 0.0_pReal
constitutive_nonlocal_Gmod = 0.0_pReal
constitutive_nonlocal_atomicVolume = 0.0_pReal
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
constitutive_nonlocal_Dsd0 = 0.0_pReal
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
constitutive_nonlocal_Qsd = 0.0_pReal
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
constitutive_nonlocal_aTolRho = 0.0_pReal
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
constitutive_nonlocal_nu = 0.0_pReal
constitutive_nonlocal_Cslip_66 = 0.0_pReal
constitutive_nonlocal_Cslip_3333 = 0.0_pReal
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
constitutive_nonlocal_R = -1.0_pReal
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
constitutive_nonlocal_doublekinkwidth = 0.0_pReal
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
constitutive_nonlocal_solidSolutionEnergy = 0.0_pReal
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
constitutive_nonlocal_solidSolutionSize = 0.0_pReal
constitutive_nonlocal_solidSolutionConcentration = 0.0_pReal
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
constitutive_nonlocal_p = 1.0_pReal
constitutive_nonlocal_q = 1.0_pReal
constitutive_nonlocal_viscosity = 0.0_pReal
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
constitutive_nonlocal_fattack = 0.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
constitutive_nonlocal_rhoSglScatter = 0.0_pReal
* 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
constitutive_nonlocal_surfaceTransmissivity = 1.0_pReal
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
constitutive_nonlocal_shortRangeStressCorrection = .true.
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
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
allocate(constitutive_nonlocal_rhoSglEdgePos0(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_rhoSglEdgeNeg0(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_rhoSglScrewPos0(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_rhoSglScrewNeg0(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_rhoDipEdge0(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_rhoDipScrew0(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_burgersPerSlipFamily(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_Lambda0PerSlipFamily(lattice_maxNslipFamily,maxNinstance))
allocate(constitutive_nonlocal_interactionSlipSlip(lattice_maxNinteraction,maxNinstance))
dislocation stress now considers dislocation segments of length V^(1/3) and ensures non-singular solution for points that are collinear to the dislocation line by means of a core spreading parameter "a". stress is scaled by a reference cutoff radius "r" to avoid mesh-dependent stress values. corrected formula for conversion of anisotropic elastic constants to isotropic Youngs modulus and poissons ratio
2010-06-07 20:02:23 +05:30
constitutive_nonlocal_rhoSglEdgePos0 = -1.0_pReal
constitutive_nonlocal_rhoSglEdgeNeg0 = -1.0_pReal
constitutive_nonlocal_rhoSglScrewPos0 = -1.0_pReal
constitutive_nonlocal_rhoSglScrewNeg0 = -1.0_pReal
constitutive_nonlocal_rhoDipEdge0 = -1.0_pReal
constitutive_nonlocal_rhoDipScrew0 = -1.0_pReal
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
constitutive_nonlocal_burgersPerSlipFamily = 0.0_pReal
constitutive_nonlocal_lambda0PerSlipFamily = 0.0_pReal
constitutive_nonlocal_interactionSlipSlip = 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
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
allocate(constitutive_nonlocal_minimumDipoleHeightPerSlipFamily(lattice_maxNslipFamily,2,maxNinstance))
allocate(constitutive_nonlocal_peierlsStressPerSlipFamily(lattice_maxNslipFamily,2,maxNinstance))
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
constitutive_nonlocal_minimumDipoleHeightPerSlipFamily = -1.0_pReal
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
constitutive_nonlocal_peierlsStressPerSlipFamily = 0.0_pReal
* 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
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
!*** readout data from material.config file
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
rewind(myFile)
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
line = ''
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
section = 0_pInt
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
removed parameter check complaining about unknown keyword as default case. there are just too many keywords that do not trigger a variable assignment to cope with them (e.g. /nonlocal/, constitution, etc.) I suggest to kill similar logic from other files if present somewhere...
2012-02-14 05:00:59 +05:30
do while (IO_lc(IO_getTag(line,'<','>')) /= 'phase') ! wind forward to <phase>
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
read(myFile,'(a1024)',END=100) line
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
enddo
removed parameter check complaining about unknown keyword as default case. there are just too many keywords that do not trigger a variable assignment to cope with them (e.g. /nonlocal/, constitution, etc.) I suggest to kill similar logic from other files if present somewhere...
2012-02-14 05:00:59 +05:30
do ! read thru sections of phase part
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
read(myFile,'(a1024)',END=100) line
removed parameter check complaining about unknown keyword as default case. there are just too many keywords that do not trigger a variable assignment to cope with them (e.g. /nonlocal/, constitution, etc.) I suggest to kill similar logic from other files if present somewhere...
2012-02-14 05:00:59 +05:30
if (IO_isBlank(line)) cycle ! skip empty lines
if (IO_getTag(line,'<','>') /= '') exit ! stop at next part
if (IO_getTag(line,'[',']') /= '') then ! next section
section = section + 1_pInt ! advance section counter
* 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
cycle
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
endif
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (section > 0_pInt .and. phase_plasticity(section) == constitutive_nonlocal_label) then ! one of my sections
i = phase_plasticityInstance(section) ! which instance of my plasticity is present phase
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
positions = IO_stringPos(line,maxNchunks)
removed parameter check complaining about unknown keyword as default case. there are just too many keywords that do not trigger a variable assignment to cope with them (e.g. /nonlocal/, constitution, etc.) I suggest to kill similar logic from other files if present somewhere...
2012-02-14 05:00:59 +05:30
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key
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
select case(tag)
constitutive models need to skip new keyword elasticity when reading their arameters
2012-03-15 14:52:24 +05:30
case('plasticity','elasticity','/nonlocal/')
* 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
cycle
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
case ('(output)')
store number of outputs for each instance of the constitution in constitutive_[j2/titanmod/...]_Nouput and use this value to loop over all valid outputs when determining the size of the outputs array
2012-02-14 20:49:59 +05:30
constitutive_nonlocal_Noutput(i) = constitutive_nonlocal_Noutput(i) + 1_pInt
constitutive_nonlocal_output(constitutive_nonlocal_Noutput(i),i) = IO_lc(IO_stringValue(line,positions,2_pInt))
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
case ('lattice_structure')
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
constitutive_nonlocal_structureName(i) = IO_lc(IO_stringValue(line,positions,2_pInt))
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
case ('c/a_ratio','covera_ratio')
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
constitutive_nonlocal_CoverA(i) = IO_floatValue(line,positions,2_pInt)
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
case ('c11')
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
constitutive_nonlocal_C11(i) = IO_floatValue(line,positions,2_pInt)
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
case ('c12')
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
constitutive_nonlocal_C12(i) = IO_floatValue(line,positions,2_pInt)
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
case ('c13')
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
constitutive_nonlocal_C13(i) = IO_floatValue(line,positions,2_pInt)
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
case ('c33')
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
constitutive_nonlocal_C33(i) = IO_floatValue(line,positions,2_pInt)
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
case ('c44')
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
constitutive_nonlocal_C44(i) = IO_floatValue(line,positions,2_pInt)
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
case ('nslip')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_Nslip(f,i) = IO_intValue(line,positions,1_pInt+f)
- 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
case ('rhosgledgepos0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_rhoSglEdgePos0(f,i) = IO_floatValue(line,positions,1_pInt+f)
- 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
case ('rhosgledgeneg0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_rhoSglEdgeNeg0(f,i) = IO_floatValue(line,positions,1_pInt+f)
- 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
case ('rhosglscrewpos0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_rhoSglScrewPos0(f,i) = IO_floatValue(line,positions,1_pInt+f)
- 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
case ('rhosglscrewneg0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_rhoSglScrewNeg0(f,i) = IO_floatValue(line,positions,1_pInt+f)
- 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
case ('rhodipedge0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_rhoDipEdge0(f,i) = IO_floatValue(line,positions,1_pInt+f)
- 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
case ('rhodipscrew0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_rhoDipScrew0(f,i) = IO_floatValue(line,positions,1_pInt+f)
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
case ('lambda0')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_lambda0PerSlipFamily(f,i) = IO_floatValue(line,positions,1_pInt+f)
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
case ('burgers')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_burgersPerSlipFamily(f,i) = IO_floatValue(line,positions,1_pInt+f)
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
case('cutoffradius','r')
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
constitutive_nonlocal_R(i) = IO_floatValue(line,positions,2_pInt)
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
case('minimumdipoleheightedge','ddipminedge')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_minimumDipoleHeightPerSlipFamily(f,1_pInt,i) = IO_floatValue(line,positions,1_pInt+f)
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
case('minimumdipoleheightscrew','ddipminscrew')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_minimumDipoleHeightPerSlipFamily(f,2_pInt,i) = IO_floatValue(line,positions,1_pInt+f)
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
case('atomicvolume')
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
constitutive_nonlocal_atomicVolume(i) = IO_floatValue(line,positions,2_pInt)
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
case('selfdiffusionprefactor','dsd0')
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
constitutive_nonlocal_Dsd0(i) = IO_floatValue(line,positions,2_pInt)
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
case('selfdiffusionenergy','qsd')
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
constitutive_nonlocal_Qsd(i) = IO_floatValue(line,positions,2_pInt)
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
case('atol_rho')
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
constitutive_nonlocal_aTolRho(i) = IO_floatValue(line,positions,2_pInt)
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
case ('interaction_slipslip')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (it = 1_pInt:lattice_maxNinteraction) &
constitutive_nonlocal_interactionSlipSlip(it,i) = IO_floatValue(line,positions,1_pInt+it)
corrected typos
2012-01-26 18:20:04 +05:30
case('peierlsstressedge')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_peierlsStressPerSlipFamily(f,1_pInt,i) = IO_floatValue(line,positions,1_pInt+f)
corrected typos
2012-01-26 18:20:04 +05:30
case('peierlsstressscrew')
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
forall (f = 1_pInt:lattice_maxNslipFamily) &
constitutive_nonlocal_peierlsStressPerSlipFamily(f,2_pInt,i) = IO_floatValue(line,positions,1_pInt+f)
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
case('doublekinkwidth')
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
constitutive_nonlocal_doublekinkwidth(i) = IO_floatValue(line,positions,2_pInt)
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
case('solidsolutionenergy')
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
constitutive_nonlocal_solidSolutionEnergy(i) = IO_floatValue(line,positions,2_pInt)
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
case('solidsolutionsize')
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
constitutive_nonlocal_solidSolutionSize(i) = IO_floatValue(line,positions,2_pInt)
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
case('solidsolutionconcentration')
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
constitutive_nonlocal_solidSolutionConcentration(i) = IO_floatValue(line,positions,2_pInt)
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
case('p')
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
constitutive_nonlocal_p(i) = IO_floatValue(line,positions,2_pInt)
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
case('q')
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
constitutive_nonlocal_q(i) = IO_floatValue(line,positions,2_pInt)
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
case('viscosity','glideviscosity')
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
constitutive_nonlocal_viscosity(i) = IO_floatValue(line,positions,2_pInt)
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
case('attackfrequency','fattack')
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
constitutive_nonlocal_fattack(i) = IO_floatValue(line,positions,2_pInt)
* 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
case('rhosglscatter')
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
constitutive_nonlocal_rhoSglScatter(i) = IO_floatValue(line,positions,2_pInt)
* 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
case('surfacetransmissivity')
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
constitutive_nonlocal_surfaceTransmissivity(i) = IO_floatValue(line,positions,2_pInt)
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
case('shortrangestresscorrection')
constitutive_nonlocal_shortRangeStressCorrection(i) = IO_floatValue(line,positions,2_pInt) > 0.0_pReal
added check for unknown keywords again (in agreement with Philip ;-) indeed 'constitution' and '/nonlocal/' are the only keywords which have to be ignored, since they are parsed elsewhere
2012-02-14 14:52:37 +05:30
case default
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
call IO_error(210_pInt,ext_msg=tag//' ('//constitutive_nonlocal_label//')')
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
end select
endif
enddo
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
100 do i = 1_pInt,maxNinstance
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_structure(i) = &
lattice_initializeStructure(constitutive_nonlocal_structureName(i), constitutive_nonlocal_CoverA(i)) ! our lattice structure is defined in the material.config file by the structureName (and the c/a ratio)
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
myStructure = constitutive_nonlocal_structure(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
* 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
!*** sanity checks
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
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
if (myStructure < 1_pInt) call IO_error(205_pInt,e=i)
if (sum(constitutive_nonlocal_Nslip(:,i)) <= 0_pInt) call IO_error(211_pInt,ext_msg='Nslip (' &
//constitutive_nonlocal_label//')')
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 o = 1_pInt,maxval(phase_Noutput)
if(len(constitutive_nonlocal_output(o,i)) > 64_pInt) call IO_error(666_pInt)
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
enddo
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 f = 1_pInt,lattice_maxNslipFamily
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
if (constitutive_nonlocal_Nslip(f,i) > 0_pInt) then
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
if (constitutive_nonlocal_rhoSglEdgePos0(f,i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoSglEdgePos0 (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_rhoSglEdgeNeg0(f,i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoSglEdgeNeg0 (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_rhoSglScrewPos0(f,i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoSglScrewPos0 (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_rhoSglScrewNeg0(f,i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoSglScrewNeg0 (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_rhoDipEdge0(f,i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoDipEdge0 (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_rhoDipScrew0(f,i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoDipScrew0 (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_burgersPerSlipFamily(f,i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='Burgers (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_lambda0PerSlipFamily(f,i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='lambda0 (' &
//constitutive_nonlocal_label//')')
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
if (constitutive_nonlocal_minimumDipoleHeightPerSlipFamily(f,1,i) < 0.0_pReal) &
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
call IO_error(211_pInt,ext_msg='minimumDipoleHeightEdge (' &
//constitutive_nonlocal_label//')')
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
if (constitutive_nonlocal_minimumDipoleHeightPerSlipFamily(f,2,i) < 0.0_pReal) &
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
call IO_error(211_pInt,ext_msg='minimumDipoleHeightScrew (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_peierlsStressPerSlipFamily(f,1,i) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg='peierlsStressEdge (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_peierlsStressPerSlipFamily(f,2,i) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg='peierlsStressScrew (' &
//constitutive_nonlocal_label//')')
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
endif
enddo
somewhat better readable format without as much linebreaks
2012-02-10 13:20:29 +05:30
if (any(constitutive_nonlocal_interactionSlipSlip(1:maxval(lattice_interactionSlipSlip(:,:,myStructure)),i) < 0.0_pReal)) &
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
call IO_error(211_pInt,ext_msg='interaction_SlipSlip (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_R(i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='r (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_atomicVolume(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='atomicVolume (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_Dsd0(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='selfDiffusionPrefactor (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_Qsd(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='selfDiffusionEnergy (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_aTolRho(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='aTol_rho (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_doublekinkwidth(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='doublekinkwidth (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_solidSolutionEnergy(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='solidSolutionEnergy (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_solidSolutionSize(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='solidSolutionSize (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_solidSolutionConcentration(i) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg='solidSolutionConcentration (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_p(i) <= 0.0_pReal .or. constitutive_nonlocal_p(i) > 1.0_pReal) call IO_error(211_pInt,ext_msg='p (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_q(i) < 1.0_pReal .or. constitutive_nonlocal_q(i) > 2.0_pReal) call IO_error(211_pInt,ext_msg='q (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_viscosity(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='viscosity (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_fattack(i) <= 0.0_pReal) call IO_error(211_pInt,ext_msg='attackFrequency (' &
//constitutive_nonlocal_label//')')
if (constitutive_nonlocal_rhoSglScatter(i) < 0.0_pReal) call IO_error(211_pInt,ext_msg='rhoSglScatter (' &
//constitutive_nonlocal_label//')')
somewhat better readable format without as much linebreaks
2012-02-10 13:20:29 +05:30
if (constitutive_nonlocal_surfaceTransmissivity(i) < 0.0_pReal &
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
.or. constitutive_nonlocal_surfaceTransmissivity(i) > 1.0_pReal) call IO_error(211_pInt,ext_msg='surfaceTransmissivity (' &
//constitutive_nonlocal_label//')')
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +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 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
!*** determine 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
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
constitutive_nonlocal_Nslip(1:lattice_maxNslipFamily,i) = min( lattice_NslipSystem(1:lattice_maxNslipFamily, myStructure), &
constitutive_nonlocal_Nslip(1:lattice_maxNslipFamily,i) ) ! we can't use more slip systems per family than specified in lattice
constitutive_nonlocal_totalNslip(i) = sum(constitutive_nonlocal_Nslip(1:lattice_maxNslipFamily,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
enddo
!*** allocation of variables whose size depends on the total number of active slip systems
maxTotalNslip = maxval(constitutive_nonlocal_totalNslip)
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
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
allocate(constitutive_nonlocal_burgers(maxTotalNslip, maxNinstance))
constitutive_nonlocal_burgers = 0.0_pReal
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
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
allocate(constitutive_nonlocal_lambda0(maxTotalNslip, maxNinstance))
constitutive_nonlocal_lambda0 = 0.0_pReal
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
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
allocate(constitutive_nonlocal_minimumDipoleHeight(maxTotalNslip,2,maxNinstance))
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
constitutive_nonlocal_minimumDipoleHeight = -1.0_pReal
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +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
allocate(constitutive_nonlocal_forestProjectionEdge(maxTotalNslip, maxTotalNslip, maxNinstance))
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
constitutive_nonlocal_forestProjectionEdge = 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
allocate(constitutive_nonlocal_forestProjectionScrew(maxTotalNslip, maxTotalNslip, maxNinstance))
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
constitutive_nonlocal_forestProjectionScrew = 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
allocate(constitutive_nonlocal_interactionMatrixSlipSlip(maxTotalNslip, maxTotalNslip, maxNinstance))
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
constitutive_nonlocal_interactionMatrixSlipSlip = 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
allocate(constitutive_nonlocal_lattice2slip(1:3, 1:3, maxTotalNslip, maxNinstance))
constitutive_nonlocal_lattice2slip = 0.0_pReal
new outputs "accumulatedshear", "velocity_edge", and "velocity_screw" (the latter two replace the output "dislocationvelocity")
2011-11-09 14:52:52 +05:30
allocate(constitutive_nonlocal_accumulatedShear(maxTotalNslip, homogenization_maxNgrains, mesh_maxNips, mesh_NcpElems))
constitutive_nonlocal_accumulatedShear = 0.0_pReal
* found memory leak in nonlocal model! "constitutive_nonlocal_rhoDotFlux" has to have upper index bound of 10 for second dimension, not 8. * need to recalculate dislocation velocity in postResults, otherwise we take values of last perturbed state! So the following outputs were up to now showing the perturbed state: shearrate, dislocation velocity, all density rates!
2011-02-09 13:58:47 +05:30
allocate(constitutive_nonlocal_rhoDotFlux(maxTotalNslip, 10, homogenization_maxNgrains, mesh_maxNips, mesh_NcpElems))
added output for dislocation evolution rate associated with flux: "rho_dot_flux"
2010-03-10 15:19:40 +05:30
constitutive_nonlocal_rhoDotFlux = 0.0_pReal
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
allocate(constitutive_nonlocal_compatibility(2,maxTotalNslip, maxTotalNslip, FE_maxNipNeighbors, mesh_maxNips, mesh_NcpElems))
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
constitutive_nonlocal_compatibility = 0.0_pReal
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
allocate(constitutive_nonlocal_peierlsStress(maxTotalNslip,2,maxNinstance))
constitutive_nonlocal_peierlsStress = 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
do i = 1,maxNinstance
myStructure = constitutive_nonlocal_structure(i) ! lattice structure of this instance
* 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
!*** Inverse lookup of my slip system family and the slip system in lattice
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
l = 0_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 f = 1_pInt,lattice_maxNslipFamily
do s = 1_pInt,constitutive_nonlocal_Nslip(f,i)
l = l + 1_pInt
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_slipFamily(l,i) = f
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
constitutive_nonlocal_slipSystemLattice(l,i) = sum(lattice_NslipSystem(1:f-1_pInt, myStructure)) + s
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
enddo; enddo
* 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
!*** determine size of state array
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
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
ns = constitutive_nonlocal_totalNslip(i)
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
constitutive_nonlocal_sizeDotState(i) = int(size(constitutive_nonlocal_listBasicStates),pInt) * ns
constitutive_nonlocal_sizeDependentState(i) = int(size(constitutive_nonlocal_listDependentStates),pInt) * ns
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
constitutive_nonlocal_sizeState(i) = constitutive_nonlocal_sizeDotState(i) &
+ constitutive_nonlocal_sizeDependentState(i) &
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
+ int(size(constitutive_nonlocal_listOtherStates),pInt) * ns
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
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 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
!*** determine size of postResults array
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 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 o = 1_pInt,constitutive_nonlocal_Noutput(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
select case(constitutive_nonlocal_output(o,i))
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case( 'rho', &
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
'delta', &
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
'rho_edge', &
'rho_screw', &
- 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
'rho_sgl', &
'delta_sgl', &
'rho_sgl_edge', &
'rho_sgl_edge_pos', &
'rho_sgl_edge_neg', &
'rho_sgl_screw', &
'rho_sgl_screw_pos', &
'rho_sgl_screw_neg', &
'rho_sgl_mobile', &
'rho_sgl_edge_mobile', &
'rho_sgl_edge_pos_mobile', &
'rho_sgl_edge_neg_mobile', &
'rho_sgl_screw_mobile', &
'rho_sgl_screw_pos_mobile', &
'rho_sgl_screw_neg_mobile', &
'rho_sgl_immobile', &
'rho_sgl_edge_immobile', &
'rho_sgl_edge_pos_immobile', &
'rho_sgl_edge_neg_immobile', &
'rho_sgl_screw_immobile', &
'rho_sgl_screw_pos_immobile', &
'rho_sgl_screw_neg_immobile', &
'rho_dip', &
'delta_dip', &
'rho_dip_edge', &
'rho_dip_screw', &
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
'excess_rho', &
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
'excess_rho_edge', &
'excess_rho_screw', &
'rho_forest', &
'shearrate', &
'resolvedstress', &
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
'resolvedstress_external', &
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
'resolvedstress_back', &
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
'resistance', &
'rho_dot', &
- 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
'rho_dot_sgl', &
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
'rho_dot_dip', &
'rho_dot_gen', &
- 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
'rho_dot_gen_edge', &
'rho_dot_gen_screw', &
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
'rho_dot_sgl2dip', &
'rho_dot_ann_ath', &
'rho_dot_ann_the', &
added output for dislocation evolution rate associated with flux: "rho_dot_flux"
2010-03-10 15:19:40 +05:30
'rho_dot_flux', &
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
'rho_dot_flux_edge', &
'rho_dot_flux_screw', &
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
'velocity_edge_pos', &
'velocity_edge_neg', &
'velocity_screw_pos', &
'velocity_screw_neg', &
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
'fluxdensity_edge_pos_x', &
'fluxdensity_edge_pos_y', &
'fluxdensity_edge_pos_z', &
'fluxdensity_edge_neg_x', &
'fluxdensity_edge_neg_y', &
'fluxdensity_edge_neg_z', &
'fluxdensity_screw_pos_x', &
'fluxdensity_screw_pos_y', &
'fluxdensity_screw_pos_z', &
'fluxdensity_screw_neg_x', &
'fluxdensity_screw_neg_y', &
'fluxdensity_screw_neg_z', &
corrected typos
2012-01-26 18:20:04 +05:30
'maximumdipoleheight_edge', &
'maximumdipoleheight_screw', &
new outputs "accumulatedshear", "velocity_edge", and "velocity_screw" (the latter two replace the output "dislocationvelocity")
2011-11-09 14:52:52 +05:30
'accumulatedshear' )
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
mySize = constitutive_nonlocal_totalNslip(i)
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
case('dislocationstress')
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
mySize = 6_pInt
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
case default
condensed error reporting for constitutive_XYZ_init removed erroneous check for structure>3
2012-07-17 23:06:24 +05:30
call IO_error(212_pInt,ext_msg=constitutive_nonlocal_output(o,i)//' ('//constitutive_nonlocal_label//')')
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
end select
if (mySize > 0_pInt) then ! any meaningful output found
constitutive_nonlocal_sizePostResult(o,i) = mySize
constitutive_nonlocal_sizePostResults(i) = constitutive_nonlocal_sizePostResults(i) + mySize
endif
enddo
* 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
!*** elasticity matrix and shear modulus according to material.config
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
select case (myStructure)
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
case(1_pInt:2_pInt) ! cubic(s)
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(k=1_pInt:3_pInt)
forall(j=1_pInt:3_pInt) constitutive_nonlocal_Cslip_66(k,j,i) = constitutive_nonlocal_C12(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
constitutive_nonlocal_Cslip_66(k,k,i) = constitutive_nonlocal_C11(i)
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
constitutive_nonlocal_Cslip_66(k+3_pInt,k+3_pInt,i) = constitutive_nonlocal_C44(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
end forall
reordered (and partly redistributed) error message identifiers, deleted those which are not in use anymore. all constitutive as well numerics now raises an error, if an unknown keyword is found in the respective config file
2012-02-13 23:11:27 +05:30
case(3_pInt:) ! all hex
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_Cslip_66(1,1,i) = constitutive_nonlocal_C11(i)
constitutive_nonlocal_Cslip_66(2,2,i) = constitutive_nonlocal_C11(i)
constitutive_nonlocal_Cslip_66(3,3,i) = constitutive_nonlocal_C33(i)
constitutive_nonlocal_Cslip_66(1,2,i) = constitutive_nonlocal_C12(i)
constitutive_nonlocal_Cslip_66(2,1,i) = constitutive_nonlocal_C12(i)
constitutive_nonlocal_Cslip_66(1,3,i) = constitutive_nonlocal_C13(i)
constitutive_nonlocal_Cslip_66(3,1,i) = constitutive_nonlocal_C13(i)
constitutive_nonlocal_Cslip_66(2,3,i) = constitutive_nonlocal_C13(i)
constitutive_nonlocal_Cslip_66(3,2,i) = constitutive_nonlocal_C13(i)
constitutive_nonlocal_Cslip_66(4,4,i) = constitutive_nonlocal_C44(i)
constitutive_nonlocal_Cslip_66(5,5,i) = constitutive_nonlocal_C44(i)
constitutive_nonlocal_Cslip_66(6,6,i) = 0.5_pReal*(constitutive_nonlocal_C11(i)- constitutive_nonlocal_C12(i))
end select
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
constitutive_nonlocal_Cslip_66(1:6,1:6,i) = math_Mandel3333to66(math_Voigt66to3333(constitutive_nonlocal_Cslip_66(1:6,1:6,i)))
constitutive_nonlocal_Cslip_3333(1:3,1:3,1:3,1:3,i) = math_Voigt66to3333(constitutive_nonlocal_Cslip_66(1:6,1:6,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
dislocation stress now considers dislocation segments of length V^(1/3) and ensures non-singular solution for points that are collinear to the dislocation line by means of a core spreading parameter "a". stress is scaled by a reference cutoff radius "r" to avoid mesh-dependent stress values. corrected formula for conversion of anisotropic elastic constants to isotropic Youngs modulus and poissons ratio
2010-06-07 20:02:23 +05:30
constitutive_nonlocal_Gmod(i) = 0.2_pReal * ( constitutive_nonlocal_C11(i) - constitutive_nonlocal_C12(i) &
+ 3.0_pReal*constitutive_nonlocal_C44(i) ) ! (C11iso-C12iso)/2 with C11iso=(3*C11+2*C12+4*C44)/5 and C12iso=(C11+4*C12-2*C44)/5
constitutive_nonlocal_nu(i) = ( constitutive_nonlocal_C11(i) + 4.0_pReal*constitutive_nonlocal_C12(i) &
- 2.0_pReal*constitutive_nonlocal_C44(i) ) &
/ ( 4.0_pReal*constitutive_nonlocal_C11(i) + 6.0_pReal*constitutive_nonlocal_C12(i) &
+ 2.0_pReal*constitutive_nonlocal_C44(i) ) ! C12iso/(C11iso+C12iso) with C11iso=(3*C11+2*C12+4*C44)/5 and C12iso=(C11+4*C12-2*C44)/5
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, 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
do s1 = 1_pInt,ns
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
f = constitutive_nonlocal_slipFamily(s1,i)
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
* 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
!*** burgers vector, mean free path prefactor and minimum dipole distance for each slip system
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
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
constitutive_nonlocal_burgers(s1,i) = constitutive_nonlocal_burgersPerSlipFamily(f,i)
constitutive_nonlocal_lambda0(s1,i) = constitutive_nonlocal_lambda0PerSlipFamily(f,i)
constitutive_nonlocal_minimumDipoleHeight(s1,1:2,i) = constitutive_nonlocal_minimumDipoleHeightPerSlipFamily(f,1:2,i)
constitutive_nonlocal_peierlsStress(s1,1:2,i) = constitutive_nonlocal_peierlsStressPerSlipFamily(f,1:2,i)
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
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 s2 = 1_pInt,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
* 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
!*** calculation of forest projections for edge and screw dislocations. s2 acts as forest for s1
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
* 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
constitutive_nonlocal_forestProjectionEdge(s1,s2,i) &
= abs(math_mul3x3(lattice_sn(1:3,constitutive_nonlocal_slipSystemLattice(s1,i),myStructure), &
lattice_st(1:3,constitutive_nonlocal_slipSystemLattice(s2,i),myStructure))) ! forest projection of edge dislocations is the projection of (t = b x n) onto the slip normal of the respective slip plane
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 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
constitutive_nonlocal_forestProjectionScrew(s1,s2,i) &
= abs(math_mul3x3(lattice_sn(1:3,constitutive_nonlocal_slipSystemLattice(s1,i),myStructure), &
lattice_sd(1:3,constitutive_nonlocal_slipSystemLattice(s2,i),myStructure))) ! forest projection of screw dislocations is the projection of b onto the slip normal of the respective splip plane
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 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
!*** calculation of interaction matrices
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
* 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
constitutive_nonlocal_interactionMatrixSlipSlip(s1,s2,i) &
= constitutive_nonlocal_interactionSlipSlip(lattice_interactionSlipSlip(constitutive_nonlocal_slipSystemLattice(s1,i), &
constitutive_nonlocal_slipSystemLattice(s2,i), &
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
myStructure), i)
* 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
enddo
* 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
!*** rotation matrix from lattice configuration to slip system
constitutive_nonlocal_lattice2slip(1:3,1:3,s1,i) &
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
= math_transpose33( reshape([ lattice_sd(1:3, constitutive_nonlocal_slipSystemLattice(s1,i), myStructure), &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
-lattice_st(1:3, constitutive_nonlocal_slipSystemLattice(s1,i), myStructure), &
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
lattice_sn(1:3, constitutive_nonlocal_slipSystemLattice(s1,i), myStructure)], [3,3]))
* 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
enddo
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
enddo
endsubroutine
!*********************************************************************
!* initial microstructural state (just the "basic" states) *
!*********************************************************************
* 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
function constitutive_nonlocal_stateInit(myInstance)
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 prec, only: pReal, &
pInt
use lattice, only: lattice_maxNslipFamily
* 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
use math, only: math_sampleGaussVar
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt), intent(in) :: myInstance ! number specifying the current instance of the plasticity
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
!*** output variables
real(pReal), dimension(constitutive_nonlocal_sizeState(myInstance)) :: &
constitutive_nonlocal_stateInit
!*** local variables
real(pReal), dimension(constitutive_nonlocal_totalNslip(myInstance)) :: &
- 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
rhoSglEdgePos, & ! positive edge dislocation density
rhoSglEdgeNeg, & ! negative edge dislocation density
rhoSglScrewPos, & ! positive screw dislocation density
rhoSglScrewNeg, & ! negative screw dislocation density
rhoSglEdgePosUsed, & ! used positive edge dislocation density
rhoSglEdgeNegUsed, & ! used negative edge dislocation density
rhoSglScrewPosUsed, & ! used positive screw dislocation density
rhoSglScrewNegUsed, & ! used negative screw dislocation density
rhoDipEdge, & ! edge dipole dislocation density
removed unused variables
2011-04-13 19:46:22 +05:30
rhoDipScrew ! screw dipole dislocation density
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
integer(pInt) ns, & ! short notation for total number of active slip systems
f, & ! index of lattice family
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
from, &
upto, &
* 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
s, & ! index of slip system
i
real(pReal), dimension(2) :: noise
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_stateInit = 0.0_pReal
ns = constitutive_nonlocal_totalNslip(myInstance)
!*** set the basic state variables
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 f = 1_pInt,lattice_maxNslipFamily
from = 1_pInt + sum(constitutive_nonlocal_Nslip(1:f-1_pInt,myInstance))
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
upto = sum(constitutive_nonlocal_Nslip(1:f,myInstance))
* 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
do s = from,upto
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 i = 1_pInt,2_pInt
* 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
noise(i) = math_sampleGaussVar(0.0_pReal, constitutive_nonlocal_rhoSglScatter(myInstance))
enddo
rhoSglEdgePos(s) = constitutive_nonlocal_rhoSglEdgePos0(f, myInstance) + noise(1)
rhoSglEdgeNeg(s) = constitutive_nonlocal_rhoSglEdgeNeg0(f, myInstance) + noise(1)
rhoSglScrewPos(s) = constitutive_nonlocal_rhoSglScrewPos0(f, myInstance) + noise(2)
rhoSglScrewNeg(s) = constitutive_nonlocal_rhoSglScrewNeg0(f, myInstance) + noise(2)
enddo
- 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
rhoSglEdgePosUsed(from:upto) = 0.0_pReal
rhoSglEdgeNegUsed(from:upto) = 0.0_pReal
rhoSglScrewPosUsed(from:upto) = 0.0_pReal
rhoSglScrewNegUsed(from:upto) = 0.0_pReal
rhoDipEdge(from:upto) = constitutive_nonlocal_rhoDipEdge0(f, myInstance)
rhoDipScrew(from:upto) = constitutive_nonlocal_rhoDipScrew0(f, myInstance)
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
enddo
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
!*** put everything together and in right order
- 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
constitutive_nonlocal_stateInit( 1: ns) = rhoSglEdgePos
constitutive_nonlocal_stateInit( ns+1: 2*ns) = rhoSglEdgeNeg
constitutive_nonlocal_stateInit( 2*ns+1: 3*ns) = rhoSglScrewPos
constitutive_nonlocal_stateInit( 3*ns+1: 4*ns) = rhoSglScrewNeg
constitutive_nonlocal_stateInit( 4*ns+1: 5*ns) = rhoSglEdgePosUsed
constitutive_nonlocal_stateInit( 5*ns+1: 6*ns) = rhoSglEdgeNegUsed
constitutive_nonlocal_stateInit( 6*ns+1: 7*ns) = rhoSglScrewPosUsed
constitutive_nonlocal_stateInit( 7*ns+1: 8*ns) = rhoSglScrewNegUsed
constitutive_nonlocal_stateInit( 8*ns+1: 9*ns) = rhoDipEdge
constitutive_nonlocal_stateInit( 9*ns+1:10*ns) = rhoDipScrew
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
endfunction
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
!*********************************************************************
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
!* absolute state tolerance *
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
!*********************************************************************
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
pure function constitutive_nonlocal_aTolState(myInstance)
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
use prec, only: pReal, &
pInt
implicit none
!*** input variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt), intent(in) :: myInstance ! number specifying the current instance of the plasticity
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
!*** output variables
real(pReal), dimension(constitutive_nonlocal_sizeState(myInstance)) :: &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
constitutive_nonlocal_aTolState ! absolute state tolerance for the current instance of this plasticity
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
!*** local variables
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
constitutive_nonlocal_aTolState = constitutive_nonlocal_aTolRho(myInstance)
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
endfunction
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
!*********************************************************************
!* calculates homogenized elacticity matrix *
!*********************************************************************
pure function constitutive_nonlocal_homogenizedC(state,g,ip,el)
use prec, only: pReal, &
pInt, &
p_vec
use mesh, only: mesh_NcpElems, &
mesh_maxNips
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
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
integer(pInt), intent(in) :: g, & ! current grain ID
ip, & ! current integration point
el ! current element
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: state ! microstructural state
!*** output variables
real(pReal), dimension(6,6) :: constitutive_nonlocal_homogenizedC ! homogenized elasticity matrix
!*** local variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt) myInstance ! current instance of this plasticity
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
myInstance = phase_plasticityInstance(material_phase(g,ip,el))
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
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
constitutive_nonlocal_homogenizedC = constitutive_nonlocal_Cslip_66(1:6,1:6,myInstance)
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
endfunction
!*********************************************************************
!* calculates quantities characterizing the microstructure *
!*********************************************************************
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
subroutine constitutive_nonlocal_microstructure(state, Temperature, Fe, Fp, g, ip, el)
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 prec, only: pReal, &
pInt, &
p_vec
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 IO, only: IO_error
use math, only: math_Mandel33to6, &
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
math_mul33x33, &
math_mul33x3, &
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
math_mul3x3, &
math_norm3, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_inv33, &
math_invert33, &
math_transpose33, &
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
pi
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_constitutive, &
debug_levelBasic, &
debug_levelSelective, &
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
debug_g, &
debug_i, &
debug_e
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 mesh, only: mesh_NcpElems, &
mesh_maxNips, &
mesh_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
FE_NipNeighbors, &
FE_maxNipNeighbors, &
mesh_ipNeighborhood, &
fixed problem in internal stress calculation for periodic neighborhood
2011-02-25 13:40:11 +05:30
mesh_ipCenterOfGravity, &
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
mesh_ipVolume, &
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
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_localPlasticity, &
phase_plasticityInstance
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 lattice, only: lattice_sd, &
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
lattice_st
implicit none
!*** input variables
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
integer(pInt), intent(in) :: g, & ! current grain ID
ip, & ! current integration point
el ! current element
real(pReal), intent(in) :: Temperature ! temperature
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
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
!*** input/output variables
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
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(inout) :: &
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
state ! microstructural state
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
!*** output variables
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
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
!*** local variables
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
integer(pInt) neighboring_el, & ! element number of neighboring material point
neighboring_ip, & ! integration point of neighboring material point
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
instance, & ! my instance of this plasticity
neighboring_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
latticeStruct, & ! my lattice structure
neighboring_latticeStruct, & ! lattice structure of neighboring material point
phase, &
neighboring_phase, &
ns, & ! total number of active slip systems at my material point
neighboring_ns, & ! total number of active slip systems at neighboring material point
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, &
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
n
integer(pInt), dimension(2) :: neighbor
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
real(pReal) nu, & ! poisson's ratio
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
mu, &
b, &
detFe, &
detFp, &
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
FVsize, &
temp
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
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) :: ipCoords, &
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
neighboring_ipCoords, &
rhoExcessDifferences
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
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
rhoForest, & ! forest dislocation density
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
tauBack, & ! back stress from pileup on same slip system
removed unused variables
2011-04-13 19:46:22 +05:30
tauThreshold ! threshold shear stress
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
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,FE_maxNipNeighbors) :: &
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
connection_latticeConf
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(2,constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,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)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,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-)
real(pReal), dimension(2,maxval(constitutive_nonlocal_totalNslip),FE_maxNipNeighbors) :: &
neighboring_rhoExcess ! excess density at neighboring material point
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(3,constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,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
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
logical inversionError
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
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
phase = material_phase(g,ip,el)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
instance = phase_plasticityInstance(phase)
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
latticeStruct = constitutive_nonlocal_structure(instance)
ns = constitutive_nonlocal_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
!*** get basic states
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
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt) &
rhoSgl(s,t) = max(state(g,ip,el)%p((t-1_pInt)*ns+s), 0.0_pReal) ! ensure positive single mobile densities
forall (t = 5_pInt:8_pInt) &
rhoSgl(1:ns,t) = state(g,ip,el)%p((t-1_pInt)*ns+1_pInt:t*ns)
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt) &
rhoDip(s,c) = max(state(g,ip,el)%p((7_pInt+c)*ns+s), 0.0_pReal) ! ensure positive dipole densities
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 forest dislocation density
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
!*** (= projection of screw and edge dislocations)
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
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
forall (s = 1_pInt:ns) &
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
rhoForest(s) = dot_product((sum(abs(rhoSgl(1:ns,[1,2,5,6])),2) + rhoDip(1:ns,1)), &
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
constitutive_nonlocal_forestProjectionEdge(s,1:ns,instance)) &
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
+ dot_product((sum(abs(rhoSgl(1:ns,[3,4,7,8])),2) + rhoDip(1:ns,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
constitutive_nonlocal_forestProjectionScrew(s,1:ns,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 - 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
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
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
forall (s = 1_pInt:ns) &
tauThreshold(s) = constitutive_nonlocal_Gmod(instance) * constitutive_nonlocal_burgers(s,instance) &
* sqrt(dot_product((sum(abs(rhoSgl),2) + sum(abs(rhoDip),2)), &
constitutive_nonlocal_interactionMatrixSlipSlip(s,1:ns,instance)))
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
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
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: - 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
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
tauBack = 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
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
if (.not. phase_localPlasticity(phase) .and. constitutive_nonlocal_shortRangeStressCorrection(instance)) then
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
call math_invert33(Fe, invFe, detFe, inversionError)
call math_invert33(Fp, invFp, detFp, inversionError)
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
ipCoords = mesh_ipCenterOfGravity(1:3,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(1,1:ns) = rhoSgl(1:ns,1) - rhoSgl(1:ns,2)
rhoExcess(2,1:ns) = rhoSgl(1:ns,3) - rhoSgl(1:ns,4)
FVsize = mesh_ipVolume(ip,el) ** (1.0_pReal/3.0_pReal)
nu = constitutive_nonlocal_nu(instance)
mu = constitutive_nonlocal_Gmod(instance)
* 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
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 n = 1_pInt,FE_NipNeighbors(mesh_element(2,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
neighboring_el = mesh_ipNeighborhood(1,n,ip,el)
neighboring_ip = mesh_ipNeighborhood(2,n,ip,el)
if (neighboring_el > 0 .and. neighboring_ip > 0) then
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
neighboring_phase = material_phase(g,neighboring_ip,neighboring_el)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
neighboring_instance = phase_plasticityInstance(neighboring_phase)
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
neighboring_latticeStruct = constitutive_nonlocal_structure(neighboring_instance)
neighboring_ns = constitutive_nonlocal_totalNslip(neighboring_instance)
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
neighboring_ipCoords = mesh_ipCenterOfGravity(1:3,neighboring_ip,neighboring_el)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. phase_localPlasticity(neighboring_phase) &
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
.and. neighboring_latticeStruct == latticeStruct &
.and. neighboring_instance == instance) then
if (neighboring_ns == ns) then
if (neighboring_el /= el .or. neighboring_ip /= ip) then
connection_latticeConf(1:3,n) = math_mul33x3(invFe, neighboring_ipCoords - ipCoords)
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 (s = 1_pInt:ns, c = 1_pInt:2_pInt) &
corrected special treatment of periodic images in calculation of stress correction
2012-03-15 15:38:08 +05:30
neighboring_rhoExcess(c,s,n) = state(g,neighboring_ip,neighboring_el)%p((2_pInt*c-2_pInt)*ns+s) & ! positive mobiles
- state(g,neighboring_ip,neighboring_el)%p((2_pInt*c-1_pInt)*ns+s) ! negative mobiles
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
! thats myself! probably using periodic images -> assume constant excess density
connection_latticeConf(1:3,n) = math_mul33x3(math_transpose33(invFp), mesh_ipAreaNormal(1:3,n,ip,el)) ! direction of area normal
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
neighboring_rhoExcess(1:2,1:ns,n) = rhoExcess
endif
else
! different number of active slip systems
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
call IO_error(-1_pInt,ext_msg='different number of active slip systems in neighboring IPs of same crystal structure')
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
! local neighbor or different lattice structure or different constitution instance -> use central values instead
connection_latticeConf(1:3,n) = 0.0_pReal
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
neighboring_rhoExcess(1:2,1:ns,n) = rhoExcess
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
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
neighboring_rhoExcess(1:2,1:ns,n) = rhoExcess
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
m(1:3,1:ns,1) = lattice_sd(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,instance), latticeStruct)
m(1:3,1:ns,2) = -lattice_st(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,instance), latticeStruct)
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
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
!* gradient from interpolation of neighboring excess density
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
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
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
neighbor(1) = 2_pInt * dir - 1_pInt
neighbor(2) = 2_pInt * dir
connections(dir,1:3) = connection_latticeConf(1:3,neighbor(1)) - connection_latticeConf(1:3,neighbor(2))
rhoExcessDifferences(dir) = neighboring_rhoExcess(c,s,neighbor(1)) - neighboring_rhoExcess(c,s,neighbor(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
adding switch in material.config for short range stress correction
2012-03-15 20:28:12 +05:30
call math_invert33(connections,invConnections,temp,inversionError)
if (inversionError) then
call IO_error(-1_pInt,ext_msg='back stress calculation: inversion error')
endif
rhoExcessGradient(c) = math_mul3x3(math_mul33x3(invConnections, rhoExcessDifferences), m(1:3,s,c))
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
local stress correction of gradient in dead dislocations and neighboring excess density is additive
2012-03-14 20:54:19 +05:30
!* plus gradient from deads
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
!* normalized with the total density
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
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
rhoTotal(1_pInt) = sum(abs(rhoSgl(s,[1_pInt,2_pInt,5_pInt,6_pInt]))) + rhoDip(s,1_pInt)
rhoTotal(2_pInt) = sum(abs(rhoSgl(s,[3_pInt,4_pInt,7_pInt,8_pInt]))) + rhoDip(s,2_pInt)
forall (c = 1_pInt:2_pInt, rhoTotal(c) > 0.0_pReal) &
rhoExcessGradient_over_rho(c) = rhoExcessGradient(c) / rhoTotal(c)
!* gives the local stress correction when multiplied with a factor
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
b = constitutive_nonlocal_burgers(s,instance)
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
tauBack(s) = - mu * b / (2.0_pReal * pi) * (rhoExcessGradient_over_rho(1) / (1.0_pReal - nu) + 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
dead dislocations now exert a backstress on their "home" MP
2011-05-26 15:05:42 +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
!*** set dependent states
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 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
state(g,ip,el)%p(10_pInt*ns+1:11_pInt*ns) = rhoForest
state(g,ip,el)%p(11_pInt*ns+1:12_pInt*ns) = tauThreshold
state(g,ip,el)%p(12_pInt*ns+1:13_pInt*ns) = tauBack
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 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
#ifndef _OPENMP
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 &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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
* 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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,i8,1x,i2,1x,i1)') '<< CONST >> nonlocal_microstructure at el ip g',el,ip,g
* 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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,/,12x,12(e10.3,1x))') '<< CONST >> rhoForest', rhoForest
write(6,'(a,/,12x,12(f10.5,1x))') '<< CONST >> tauThreshold / MPa', tauThreshold/1e6
write(6,'(a,/,12x,12(f10.5,1x))') '<< CONST >> tauBack / MPa', tauBack/1e6
* 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
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
endsubroutine
!*********************************************************************
!* calculates kinetics *
!*********************************************************************
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
subroutine constitutive_nonlocal_kinetics(v, tau, c, Temperature, state, g, ip, el, dv_dtau)
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
use prec, only: pReal, &
pInt, &
p_vec
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_constitutive, &
debug_levelBasic, &
debug_levelSelective, &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
debug_g, &
debug_i, &
debug_e
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +05:30
use material, only: material_phase, &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
phase_plasticityInstance
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
!*** input variables
integer(pInt), intent(in) :: g, & ! current grain number
ip, & ! current integration point
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
el, & ! current element number
c ! dislocation character (1:edge, 2:screw)
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
real(pReal), intent(in) :: Temperature ! temperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))), &
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
intent(in) :: tau ! resolved external shear stress (for bcc this already contains non Schmid effects)
type(p_vec), intent(in) :: state ! microstructural state
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
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
!*** input/output variables
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
!*** output variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))), &
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
intent(out) :: v ! velocity
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))), &
* 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
intent(out), optional :: dv_dtau ! velocity derivative with respect to resolved shear stress
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
!*** local variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt) instance, & ! current instance of this plasticity
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
ns, & ! short notation for the total number of active slip systems
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
s ! index of my current slip system
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
tauThreshold, & ! threshold shear stress
tauEff ! effective shear stress
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
real(pReal) tauRel_P, &
tauRel_S, &
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
tPeierls, & ! waiting time in front of a peierls barriers
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
tSolidSolution, & ! waiting time in front of a solid solution obstacle
vViscous, & ! viscous glide 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
dtPeierls_dtau, & ! derivative with respect to resolved shear stress
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
dtSolidSolution_dtau, & ! derivative with respect to resolved shear stress
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
p, & ! shortcut to Kocks,Argon,Ashby parameter p
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
q, & ! shortcut to Kocks,Argon,Ashby parameter q
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
instance = phase_plasticityInstance(material_phase(g,ip,el))
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
ns = constitutive_nonlocal_totalNslip(instance)
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
tauThreshold = state%p(11_pInt*ns+1:12_pInt*ns)
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
tauEff = abs(tau) - tauThreshold
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
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
p = constitutive_nonlocal_p(instance)
q = constitutive_nonlocal_q(instance)
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
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
v = 0.0_pReal
* 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
if (present(dv_dtau)) dv_dtau = 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
if (Temperature > 0.0_pReal) then
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
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
if (tauEff(s) > 0.0_pReal) then
* 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
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
!* Peierls contribution
!* The derivative only gives absolute values; the correct sign is taken care of in the formula for the derivative of the velocity
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
meanfreepath_P = constitutive_nonlocal_burgers(s,instance)
jumpWidth_P = constitutive_nonlocal_burgers(s,instance)
activationLength_P = constitutive_nonlocal_doublekinkwidth(instance) * constitutive_nonlocal_burgers(s,instance)
activationVolume_P = activationLength_P * jumpWidth_P * constitutive_nonlocal_burgers(s,instance)
criticalStress_P = constitutive_nonlocal_peierlsStress(s,c,instance)
activationEnergy_P = criticalStress_P * activationVolume_P
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
tauRel_P = tauEff(s) / criticalStress_P
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
tPeierls = 1.0_pReal / constitutive_nonlocal_fattack(instance) &
* exp(activationEnergy_P / (kB * Temperature) * (1.0_pReal - tauRel_P**p)**q)
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
if (present(dv_dtau)) then
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
dtPeierls_dtau = tPeierls * p * q * activationVolume_P / (kB * Temperature) &
* (1.0_pReal - tauRel_P**p)**(q-1.0_pReal) * tauRel_P**(p-1.0_pReal)
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
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
!* 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
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
meanfreepath_S = constitutive_nonlocal_burgers(s,instance) / sqrt(constitutive_nonlocal_solidSolutionConcentration(instance))
jumpWidth_S = constitutive_nonlocal_solidSolutionSize(instance) * constitutive_nonlocal_burgers(s,instance)
activationLength_S = constitutive_nonlocal_burgers(s,instance) &
/ sqrt(constitutive_nonlocal_solidSolutionConcentration(instance))
activationVolume_S = activationLength_S * jumpWidth_S * constitutive_nonlocal_burgers(s,instance)
activationEnergy_S = constitutive_nonlocal_solidSolutionEnergy(instance)
criticalStress_S = activationEnergy_S / activationVolume_S
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
tauRel_S = tauEff(s) / criticalStress_S
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
tSolidSolution = 1.0_pReal / constitutive_nonlocal_fattack(instance) &
* exp(activationEnergy_S / (kB * Temperature) * (1.0_pReal - tauRel_S**p)**q)
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
if (present(dv_dtau)) then
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
dtSolidSolution_dtau = tSolidSolution * p * q * activationVolume_S / (kB * Temperature) &
* (1.0_pReal - tauRel_S**p)**(q-1.0_pReal) * tauRel_S**(p-1.0_pReal)
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
endif
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
!* viscous glide 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
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
mobility = constitutive_nonlocal_burgers(s,instance) / constitutive_nonlocal_viscosity(instance)
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
vViscous = mobility * tauEff(s)
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
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
!* Mean velocity results from waiting time at peierls barriers and solid solution obstacles with respective meanfreepath of
!* free flight at glide velocity in between. Backward jumps at low stresses are considered only at peierls barriers,
!* since those have the smallest activation volume, thus are decisive.
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
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
v(s) = 1.0_pReal / (tPeierls / meanfreepath_P + tSolidSolution / meanfreepath_S + 1.0_pReal / vViscous) &
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
* (1.0_pReal - exp(-tauEff(s) * activationVolume_P / (kB * Temperature)))
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
v(s) = sign(v(s),tau(s))
if (present(dv_dtau)) then
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
dv_dtau(s) = 1.0_pReal / (tPeierls / meanfreepath_P + tSolidSolution / meanfreepath_S + 1.0_pReal / vViscous) &
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
* (abs(v(s)) * (dtPeierls_dtau + dtSolidSolution_dtau + 1.0_pReal / (mobility * tauEff(s)*tauEff(s))) &
+ activationVolume_P / (kB * Temperature) * exp(-tauEff(s) * activationVolume_P / (kB * Temperature)))
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
endif
* 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
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
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
* 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
#ifndef _OPENMP
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 &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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
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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,i8,1x,i2,1x,i1)') '<< CONST >> nonlocal_kinetics at el ip g',el,ip,g
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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> tau / MPa', tau / 1e6_pReal
viscosity term in kinetics law proportional to resolvedstress minus forest term
2012-03-14 20:48:36 +05:30
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> tauEff / MPa', tauEff / 1e6_pReal
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
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> v / 1e-3m/s', v * 1e3
* 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
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
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
endsubroutine
!*********************************************************************
!* calculates plastic velocity gradient and its tangent *
!*********************************************************************
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
subroutine constitutive_nonlocal_LpAndItsTangent(Lp, dLp_dTstar99, Tstar_v, Temperature, state, g, ip, el)
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 prec, only: pReal, &
pInt, &
p_vec
use math, only: math_Plain3333to99, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_mul6x6
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_constitutive, &
debug_levelBasic, &
debug_levelSelective, &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
debug_g, &
debug_i, &
debug_e
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
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 lattice, only: lattice_Sslip, &
lattice_Sslip_v
implicit none
!*** input variables
integer(pInt), intent(in) :: g, & ! current grain number
ip, & ! current integration point
el ! current element number
real(pReal), intent(in) :: Temperature ! temperature
real(pReal), dimension(6), intent(in) :: Tstar_v ! 2nd Piola-Kirchhoff stress in Mandel notation
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
!*** input/output variables
type(p_vec), intent(inout) :: state ! microstructural state
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
!*** output variables
real(pReal), dimension(3,3), intent(out) :: Lp ! plastic velocity gradient
real(pReal), dimension(9,9), intent(out) :: dLp_dTstar99 ! derivative of Lp with respect to Tstar (9x9 matrix)
!*** local variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt) myInstance, & ! current instance of this plasticity
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
myStructure, & ! current lattice structure
ns, & ! short notation for the total number of active slip systems
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
c, &
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, &
t, & ! dislocation type
s, & ! index of my current slip system
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
sLattice ! index of my current slip system according to lattice order
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
real(pReal), dimension(3,3,3,3) :: dLp_dTstar3333 ! derivative of Lp with respect to Tstar (3x3x3x3 matrix)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),4) :: &
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
rhoSgl, & ! single dislocation densities (including used)
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
v, & ! velocity
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
dv_dtau ! velocity derivative with respect to the shear stress
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
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
tau, & ! resolved shear stress including non Schmid and backstress terms
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
gdotTotal, & ! shear rate
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
dgdotTotal_dtau, & ! derivative of the shear rate with respect to the shear stress
tauBack ! back stress from dislocation gradients on same slip system
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
!*** initialize local variables
Lp = 0.0_pReal
dLp_dTstar3333 = 0.0_pReal
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
myInstance = phase_plasticityInstance(material_phase(g,ip,el))
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
myStructure = constitutive_nonlocal_structure(myInstance)
ns = constitutive_nonlocal_totalNslip(myInstance)
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
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
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt) &
rhoSgl(s,t) = max(state%p((t-1_pInt)*ns+s), 0.0_pReal)
tauBack = state%p(12_pInt*ns+1:13_pInt*ns)
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
!*** get effective resolved shear stress
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
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
tau(s) = math_mul6x6(Tstar_v, lattice_Sslip_v(:,constitutive_nonlocal_slipSystemLattice(s,myInstance),myStructure)) &
+ tauBack(s)
enddo
!*** get dislocation velocity and its tangent and store the velocity in the state array
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
if (myStructure == 1_pInt) then ! for fcc all velcities are equal
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
call constitutive_nonlocal_kinetics(v(1:ns,1), tau, 1_pInt, Temperature, state, g, ip, el, dv_dtau(1:ns,1))
do t = 1_pInt,4_pInt
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
v(1:ns,t) = v(1:ns,1)
dv_dtau(1:ns,t) = dv_dtau(1:ns,1)
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
state%p((12_pInt+t)*ns+1:(13_pInt+t)*ns) = v(1:ns,1)
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
enddo
else ! for all other lattice structures the velcities may vary with character and sign
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
do t = 1_pInt,4_pInt
c = (t-1_pInt)/2_pInt+1_pInt
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
call constitutive_nonlocal_kinetics(v(1:ns,t), tau, c, Temperature, state, g, ip, el, dv_dtau(1:ns,t))
state%p((12+t)*ns+1:(13+t)*ns) = v(1:ns,t)
enddo
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
!*** Bauschinger effect
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 (s = 1_pInt:ns, t = 5_pInt:8_pInt, state%p((t-1)*ns+s) * v(s,t-4_pInt) < 0.0_pReal) &
rhoSgl(s,t-4_pInt) = rhoSgl(s,t-4_pInt) + abs(state%p((t-1_pInt)*ns+s))
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
!*** Calculation of gdot and its tangent
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
gdotTotal = sum(rhoSgl * v, 2) * constitutive_nonlocal_burgers(1:ns,myInstance)
dgdotTotal_dtau = sum(rhoSgl * dv_dtau, 2) * constitutive_nonlocal_burgers(1:ns,myInstance)
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
!*** Calculation of Lp and its tangent
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +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
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
sLattice = constitutive_nonlocal_slipSystemLattice(s,myInstance)
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
Lp = Lp + gdotTotal(s) * lattice_Sslip(1:3,1:3,sLattice,myStructure)
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
forall (i=1_pInt:3_pInt,j=1_pInt:3_pInt,k=1_pInt:3_pInt,l=1_pInt:3_pInt) &
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
dLp_dTstar3333(i,j,k,l) = dLp_dTstar3333(i,j,k,l) + dgdotTotal_dtau(s) * lattice_Sslip(i,j, sLattice,myStructure) &
* lattice_Sslip(k,l, sLattice,myStructure)
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
enddo
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
dLp_dTstar99 = math_Plain3333to99(dLp_dTstar3333)
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
* 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
#ifndef _OPENMP
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 &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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
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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,i8,1x,i2,1x,i1)') '<< CONST >> nonlocal_LpandItsTangent at el ip g ',el,ip,g
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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,/,12x,12(f12.5,1x))') '<< CONST >> gdot total / 1e-3',gdotTotal*1e3_pReal
write(6,'(a,/,3(12x,3(f12.7,1x),/))') '<< CONST >> Lp',Lp
* 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
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
endsubroutine
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
!*********************************************************************
!* incremental change of microstructure *
!*********************************************************************
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
subroutine constitutive_nonlocal_deltaState(deltaState, state, Tstar_v, Temperature, g,ip,el)
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
use prec, only: pReal, &
pInt, &
p_vec
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
debug_constitutive, &
debug_levelBasic, &
debug_levelSelective, &
debug_g, &
debug_i, &
debug_e
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
use math, only: pi, &
math_mul6x6
use lattice, only: lattice_Sslip_v
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
use mesh, only: mesh_NcpElems, &
mesh_maxNips
use material, only: homogenization_maxNgrains, &
material_phase, &
phase_plasticityInstance
implicit none
!*** input variables
integer(pInt), intent(in) :: g, & ! current grain number
ip, & ! current integration point
el ! current element number
real(pReal), intent(in) :: Temperature ! temperature
real(pReal), dimension(6), intent(in) :: Tstar_v ! current 2nd Piola-Kirchhoff stress in Mandel notation
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
!*** input/output variables
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(inout) :: &
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
state ! current microstructural state
!*** output variables
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
type(p_vec), intent(out) :: deltaState ! change of state variables / microstructure
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
!*** local variables
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
integer(pInt) myInstance, & ! current instance of this plasticity
myStructure, & ! current lattice structure
ns, & ! short notation for the total number of active slip systems
c, & ! character of dislocation
n, & ! index of my current neighbor
t, & ! type of dislocation
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
s, & ! index of my current slip system
sLattice ! index of my current slip system according to lattice order
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),10) :: &
deltaRho, & ! density increment
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
deltaRhoRemobilization, & ! density increment by remobilization
deltaRhoSingle2DipoleStress, & ! density increment by dipole formation (by stress change)
deltaRhoDipole2SingleStress ! density increment by dipole dissociation (by stress change)
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),8) :: &
rhoSgl ! current single dislocation densities (positive/negative screw and edge without dipoles)
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),4) :: &
v ! dislocation glide velocity
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
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
tau, & ! current resolved shear stress
tauBack ! current back stress from pileups on same slip system
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,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
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
#ifndef _OPENMP
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 &
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
write(6,*)
small correction in debug output
2012-05-30 13:11:22 +05:30
write(6,'(a,i8,1x,i2,1x,i1)') '<< CONST >> nonlocal_deltaState at el ip g ',el,ip,g
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
write(6,*)
endif
#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
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
myInstance = phase_plasticityInstance(material_phase(g,ip,el))
myStructure = constitutive_nonlocal_structure(myInstance)
ns = constitutive_nonlocal_totalNslip(myInstance)
!*** shortcut to state variables
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt) &
rhoSgl(s,t) = max(state(g,ip,el)%p((t-1_pInt)*ns+s), 0.0_pReal)
forall (s = 1_pInt:ns, t = 5_pInt:8_pInt) &
rhoSgl(s,t) = state(g,ip,el)%p((t-1_pInt)*ns+s)
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt) &
rhoDip(s,c) = max(state(g,ip,el)%p((7_pInt+c)*ns+s), 0.0_pReal)
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
tauBack = state(g,ip,el)%p(12_pInt*ns+1:13_pInt*ns)
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
forall (t = 1_pInt:4_pInt) &
v(1_pInt:ns,t) = state(g,ip,el)%p((12_pInt+t)*ns+1_pInt:(13_pInt+t)*ns)
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
forall (c = 1_pInt:2_pInt) &
dUpperOld(1_pInt:ns,c) = state(g,ip,el)%p((16_pInt+c)*ns+1_pInt:(17_pInt+c)*ns)
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
!****************************************************************************
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
do s = 1_pInt,ns
sLattice = constitutive_nonlocal_slipSystemLattice(s,myInstance)
tau(s) = math_mul6x6(Tstar_v, lattice_Sslip_v(1:6,sLattice,myStructure)) + tauBack(s)
if (abs(tau(s)) < 1.0e-15_pReal) tau(s) = 1.0e-15_pReal
enddo
dLower = constitutive_nonlocal_minimumDipoleHeight(1:ns,1:2,myInstance)
corrected formulation of maximum height of screw dislocation dipoles
2012-07-24 20:20:11 +05:30
dUpper(1:ns,1) = constitutive_nonlocal_Gmod(myInstance) * constitutive_nonlocal_burgers(1:ns,myInstance) &
/ (8.0_pReal * pi * (1.0_pReal - constitutive_nonlocal_nu(myInstance)) * abs(tau))
dUpper(1:ns,2) = constitutive_nonlocal_Gmod(myInstance) * constitutive_nonlocal_burgers(1:ns,myInstance) &
/ (4.0_pReal * pi * abs(tau))
forall (c = 1_pInt:2_pInt) &
dUpper(1:ns,c) = min(1.0_pReal / sqrt(sum(abs(rhoSgl),c) + sum(rhoDip,c)), dUpper(1:ns,c))
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
!*** dissociation by stress increase
deltaRhoDipole2SingleStress = 0.0_pReal
forall (c=1_pInt:2_pInt, s=1_pInt:ns, deltaDUpper(s,c) < 0.0_pReal) &
no dipole formation by stress decrease; dipole dissociation rate proportional to "deltaDipoleLimit / oldDipoleLimit", not "deltaDipoleLimit / newDipoleLimit"
2012-07-24 12:27:37 +05:30
deltaRhoDipole2SingleStress(s,8_pInt+c) = rhoDip(s,c) * deltaDUpper(s,c) / (dUpperOld(s,c) - dLower(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
forall (t=1_pInt:4_pInt) &
deltaRhoDipole2SingleStress(1_pInt:ns,t) = -0.5_pReal * deltaRhoDipole2SingleStress(1_pInt:ns,(t-1_pInt)/2_pInt+9_pInt)
no dipole formation by stress decrease; dipole dissociation rate proportional to "deltaDipoleLimit / oldDipoleLimit", not "deltaDipoleLimit / newDipoleLimit"
2012-07-24 12:27:37 +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
forall (c = 1_pInt:2_pInt) &
state(g,ip,el)%p((16_pInt+c)*ns+1_pInt:(17_pInt+c)*ns) = dUpper(1_pInt:ns,c)
!****************************************************************************
!*** assign the rates of dislocation densities to deltaState
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
deltaRho = 0.0_pReal
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 &
no dipole formation by stress decrease; dipole dissociation rate proportional to "deltaDipoleLimit / oldDipoleLimit", not "deltaDipoleLimit / newDipoleLimit"
2012-07-24 12:27:37 +05:30
+ deltaRhoDipole2SingleStress
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
deltaState%p = reshape(deltaRho,(/10_pInt*ns/))
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
#ifndef _OPENMP
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 &
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
write(6,'(a,/,8(12x,12(e12.5,1x),/))') '<< CONST >> dislocation remobilization', deltaRhoRemobilization(1:ns,1:8)
added some debug output
2012-05-30 13:35:36 +05:30
write(6,'(a,/,10(12x,12(e12.5,1x),/))') '<< CONST >> dipole dissociation by stress increase', deltaRhoDipole2SingleStress
moved remobilization of dead dislocations from dotState to deltaState
2012-05-18 19:05:44 +05:30
write(6,*)
endif
#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
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
endsubroutine
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
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
!*********************************************************************
!* rate of change of microstructure *
!*********************************************************************
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
function constitutive_nonlocal_dotState(Tstar_v, Fe, Fp, Temperature, state, timestep, orientation, g,ip,el)
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 prec, only: pReal, &
pInt, &
moved DAMASK_NaN to prec.f90 respectively prec_single.f90 as it is precision dependent
2011-10-20 22:16:11 +05:30
p_vec, &
DAMASK_NaN
* 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
use numerics, only: numerics_integrationMode
- 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
use IO, only: IO_error
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_constitutive, &
debug_levelBasic, &
debug_levelSelective, &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
debug_g, &
debug_i, &
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
debug_e
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 math, only: math_norm3, &
math_mul6x6, &
math_mul3x3, &
math_mul33x3, &
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
math_mul33x33, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_inv33, &
math_det33, &
math_transpose33, &
moved DAMASK_NaN to prec.f90 respectively prec_single.f90 as it is precision dependent
2011-10-20 22:16:11 +05:30
pi
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 mesh, only: mesh_NcpElems, &
mesh_maxNips, &
mesh_element, &
FE_NipNeighbors, &
mesh_ipNeighborhood, &
mesh_ipVolume, &
mesh_ipArea, &
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +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, &
phase_plasticity
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +05:30
use lattice, only: lattice_Sslip_v, &
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
lattice_sd, &
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +05:30
lattice_st
* 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
integer(pInt), intent(in) :: g, & ! current grain number
ip, & ! current integration point
el ! current element number
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
real(pReal), intent(in) :: Temperature, & ! temperature
* 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
timestep ! substepped crystallite time increment
real(pReal), dimension(6), intent(in) :: Tstar_v ! current 2nd Piola-Kirchhoff stress in Mandel notation
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
real(pReal), dimension(3,3,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
Fe, & ! elastic deformation gradient
Fp ! plastic deformation gradient
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
real(pReal), dimension(4,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
orientation ! crystal lattice orientation
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
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
dotState=NaN enforces cutback, if evolution rates lead to negative densities
2012-02-22 21:38:22 +05:30
state ! current microstructural state
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
!*** input/output variables
!*** output variables
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
real(pReal), dimension(constitutive_nonlocal_sizeDotState(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
constitutive_nonlocal_dotState ! evolution of state variables / microstructure
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt) myInstance, & ! current instance of this plasticity
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
myStructure, & ! current lattice structure
ns, & ! short notation for the total number of active slip systems
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
c, & ! character of dislocation
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
n, & ! index of my current neighbor
* 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
neighboring_el, & ! element number of my neighbor
neighboring_ip, & ! integration point of my neighbor
* 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
neighboring_n, & ! neighbor index pointing to me when looking from my neighbor
again corrections. but this version must work.
2010-03-24 21:53:21 +05:30
opposite_n, & ! index of my opposite neighbor
opposite_ip, & ! ip of my opposite neighbor
opposite_el, & ! element index of my opposite neighbor
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
t, & ! type of dislocation
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
topp, & ! type of dislocation with opposite sign to t
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
s, & ! index of my current slip system
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
sLattice, & ! index of my current slip system according to lattice order
deads
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),10) :: &
* 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
rhoDot, & ! density evolution
rhoDotMultiplication, & ! density evolution by multiplication
rhoDotFlux, & ! density evolution by flux
rhoDotSingle2DipoleGlide, & ! density evolution by dipole formation (by glide)
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, & ! density evolution by athermal annihilation
* 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
rhoDotThermalAnnihilation ! density evolution by thermal annihilation
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),8) :: &
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
neighboring_rhoSgl, & ! current single dislocation densities (positive/negative screw and edge without dipoles)
* 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
rhoSgl ! current single dislocation densities (positive/negative screw and edge without dipoles)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),4) :: &
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
v, & ! dislocation glide velocity
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
neighboring_v, & ! dislocation glide velocity
* 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
gdot ! shear rates
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
* 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
rhoForest, & ! forest dislocation density
tauThreshold, & ! threshold shear stress
tau, & ! current resolved shear stress
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
tauBack, & ! current back stress from pileups on same slip system
* 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
vClimb ! climb velocity of edge dipoles
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),2) :: &
* 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
rhoDip, & ! current dipole dislocation densities (screw and edge dipoles)
dLower, & ! minimum stable dipole distance for edges and screws
* 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
dUpper ! current maximum stable dipole distance for edges and screws
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(3,constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),4) :: &
* 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
m ! direction of dislocation motion
real(pReal), dimension(3,3) :: my_F, & ! my total deformation gradient
neighboring_F, & ! total deformation gradient of my neighbor
my_Fe, & ! my elastic deformation gradient
neighboring_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
removed unused variables
2011-04-13 19:46:22 +05:30
D ! 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, &
considerLeavingFlux
- 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
* 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
#ifndef _OPENMP
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 &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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
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
write(6,*)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,i8,1x,i2,1x,i1)') '<< CONST >> nonlocal_dotState at el ip g ',el,ip,g
- 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
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
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
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
myInstance = phase_plasticityInstance(material_phase(g,ip,el))
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
myStructure = constitutive_nonlocal_structure(myInstance)
ns = constitutive_nonlocal_totalNslip(myInstance)
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
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
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 (s = 1_pInt:ns, t = 1_pInt:4_pInt) &
rhoSgl(s,t) = max(state(g,ip,el)%p((t-1_pInt)*ns+s), 0.0_pReal)
forall (s = 1_pInt:ns, t = 5_pInt:8_pInt) &
rhoSgl(s,t) = state(g,ip,el)%p((t-1_pInt)*ns+s)
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt) &
rhoDip(s,c) = max(state(g,ip,el)%p((7_pInt+c)*ns+s), 0.0_pReal)
rhoForest = state(g,ip,el)%p(10_pInt*ns+1:11_pInt*ns)
tauThreshold = state(g,ip,el)%p(11_pInt*ns+1_pInt:12_pInt*ns)
tauBack = state(g,ip,el)%p(12_pInt*ns+1:13_pInt*ns)
forall (t = 1_pInt:4_pInt) &
v(1_pInt:ns,t) = state(g,ip,el)%p((12_pInt+t)*ns+1_pInt:(13_pInt+t)*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
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
- 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
!*** sanity check for timestep
if (timestep <= 0.0_pReal) then ! if illegal timestep...
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
constitutive_nonlocal_dotState = 0.0_pReal ! ...return without doing anything (-> zero dotState)
- 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
return
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
!****************************************************************************
!*** 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) &
gdot(1_pInt:ns,t) = rhoSgl(1_pInt:ns,t) * constitutive_nonlocal_burgers(1:ns,myInstance) * 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
* 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
#ifndef _OPENMP
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 &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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 check for CFL condition in constitutive_nonlocal_dotState
2011-04-06 14:37:36 +05:30
!****************************************************************************
take absolute dislocation velocities when testing Courant-Friedrichs-Lewy condition
2012-02-21 18:41:47 +05:30
!*** check CFL (Courant-Friedrichs-Lewy) condition for flux
added check for CFL condition in constitutive_nonlocal_dotState
2011-04-06 14:37:36 +05:30
take absolute dislocation velocities when testing Courant-Friedrichs-Lewy condition
2012-02-21 18:41:47 +05:30
if (any(abs(gdot) > 0.0_pReal .and. 2.0_pReal * abs(v) * timestep > mesh_ipVolume(ip,el) / maxval(mesh_ipArea(:,ip,el)))) then ! safety factor 2.0 (we use the reference volume and are for simplicity here)
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
#ifndef _OPENMP
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) then
take absolute dislocation velocities when testing Courant-Friedrichs-Lewy condition
2012-02-21 18:41:47 +05:30
write(6,'(a,i5,a,i2)') '<< CONST >> CFL condition not fullfilled at el ',el,' ip ',ip
write(6,'(a,e10.3,a,e10.3)') '<< CONST >> velocity is at ',maxval(abs(v)),' at a timestep of ',timestep
write(6,'(a)') '<< CONST >> enforcing cutback !!!'
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
endif
#endif
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
constitutive_nonlocal_dotState = DAMASK_NaN
added check for CFL condition in constitutive_nonlocal_dotState
2011-04-06 14:37:36 +05:30
return
endif
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
* 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
sLattice = constitutive_nonlocal_slipSystemLattice(s,myInstance)
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
tau(s) = math_mul6x6(Tstar_v, lattice_Sslip_v(1:6,sLattice,myStructure)) + tauBack(s)
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
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
dLower = constitutive_nonlocal_minimumDipoleHeight(1:ns,1:2,myInstance)
corrected formulation of maximum height of screw dislocation dipoles
2012-07-24 20:20:11 +05:30
dUpper(1:ns,1) = constitutive_nonlocal_Gmod(myInstance) * constitutive_nonlocal_burgers(1:ns,myInstance) &
/ (8.0_pReal * pi * (1.0_pReal - constitutive_nonlocal_nu(myInstance)) * abs(tau))
dUpper(1:ns,2) = constitutive_nonlocal_Gmod(myInstance) * constitutive_nonlocal_burgers(1:ns,myInstance) &
/ (4.0_pReal * pi * abs(tau))
forall (c = 1_pInt:2_pInt) &
dUpper(1:ns,c) = min(1.0_pReal / sqrt(sum(abs(rhoSgl),c) + sum(rhoDip,c)), dUpper(1:ns,c))
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
added check for CFL condition in constitutive_nonlocal_dotState
2011-04-06 14:37:36 +05:30
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
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
* 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
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
where (rhoSgl(1:ns,3:4) > 0.0_pReal) &
rhoDotMultiplication(1:ns,1:2) = spread(0.5_pReal * sum(abs(gdot(1:ns,3:4)),2) * sqrt(rhoForest) &
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
/ constitutive_nonlocal_lambda0(1:ns,myInstance) &
/ constitutive_nonlocal_burgers(1:ns,myInstance), 2, 2)
multiplication only controlled by screws
2012-03-13 19:49:36 +05:30
rhoDotMultiplication(1:ns,3:4) = rhoDotMultiplication(1:ns,1:2)
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
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. phase_localPlasticity(material_phase(g,ip,el))) then ! only for nonlocal plasticity
* "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
!*** take care of the definition of lattice_st = lattice_sd x lattice_sn !!!
!*** opposite sign to our p vector in the (s,p,n) triplet !!!
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
m(1:3,1:ns,1) = lattice_sd(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,myInstance), myStructure)
m(1:3,1:ns,2) = -lattice_sd(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,myInstance), myStructure)
* "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
m(1:3,1:ns,3) = -lattice_st(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,myInstance), myStructure)
m(1:3,1:ns,4) = lattice_st(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,myInstance), myStructure)
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
* 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
my_Fe = Fe(1:3,1:3,g,ip,el)
my_F = math_mul33x33(my_Fe, Fp(1:3,1:3,g,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
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
do n = 1_pInt,FE_NipNeighbors(mesh_element(2,el)) ! loop through my neighbors
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
neighboring_el = mesh_ipNeighborhood(1,n,ip,el)
neighboring_ip = mesh_ipNeighborhood(2,n,ip,el)
* 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
if (neighboring_el > 0_pInt .and. neighboring_ip > 0_pInt) then ! if neighbor exists ...
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
do neighboring_n = 1_pInt,FE_NipNeighbors(mesh_element(2,neighboring_el)) ! find neighboring index that points from my neighbor to myself
* 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
if ( el == mesh_ipNeighborhood(1,neighboring_n,neighboring_ip,neighboring_el) &
* 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
.and. ip == mesh_ipNeighborhood(2,neighboring_n,neighboring_ip,neighboring_el)) then ! possible candidate
if (math_mul3x3(mesh_ipAreaNormal(1:3,n,ip,el),&
mesh_ipAreaNormal(1:3,neighboring_n,neighboring_ip,neighboring_el)) < 0.0_pReal) then ! area normals have opposite orientation (we have to check that because of special case for single element with two ips and periodicity. In this case the neighbor is identical in two different directions.)
exit
endif
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
endif
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
opposite_n = n + mod(n,2_pInt) - mod(n+1_pInt,2_pInt)
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
opposite_el = mesh_ipNeighborhood(1,opposite_n,ip,el)
opposite_ip = mesh_ipNeighborhood(2,opposite_n,ip,el)
* 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
if (neighboring_el > 0_pInt .and. neighboring_ip > 0_pInt) then ! if neighbor exists, average deformation gradient
neighboring_Fe = Fe(1:3,1:3,g,neighboring_ip,neighboring_el)
neighboring_F = math_mul33x33(neighboring_Fe, Fp(1:3,1:3,g,neighboring_ip,neighboring_el))
Favg = 0.5_pReal * (my_F + neighboring_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
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +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.
* 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
!* 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
considerEnteringFlux = .false.
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
neighboring_v = 0.0_pReal ! needed for check of sign change in flux density below
neighboring_rhoSgl = 0.0_pReal
* 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
if (neighboring_el > 0_pInt .or. neighboring_ip > 0_pInt) then
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (phase_plasticity(material_phase(1,neighboring_ip,neighboring_el)) == constitutive_nonlocal_label &
* 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
.and. any(constitutive_nonlocal_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
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
forall (t = 1_pInt:4_pInt) &
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
neighboring_v(1_pInt:ns,t) = state(g,neighboring_ip,neighboring_el)%p((12_pInt+t)*ns+1_pInt:(13_pInt+t)*ns)
forall (t = 1_pInt:4_pInt) &
neighboring_rhoSgl(1_pInt:ns,t) = max(state(g,neighboring_ip,neighboring_el)%p((t-1_pInt)*ns+1_pInt:t*ns), 0.0_pReal)
forall (t = 5_pInt:8_pInt) &
neighboring_rhoSgl(1_pInt:ns,t) = state(g,neighboring_ip,neighboring_el)%p((t-1_pInt)*ns+1_pInt:t*ns)
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
normal_neighbor2me_defConf = math_det33(Favg) &
* math_mul33x3(math_inv33(transpose(Favg)), mesh_ipAreaNormal(1:3,neighboring_n,neighboring_ip,neighboring_el)) ! calculate the normal of the interface in (average) deformed configuration (now pointing from my neighbor to me!!!)
normal_neighbor2me = math_mul33x3(transpose(neighboring_Fe), normal_neighbor2me_defConf) / math_det33(neighboring_Fe) ! interface normal in the lattice configuration of my neighbor
* 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
area = mesh_ipArea(neighboring_n,neighboring_ip,neighboring_el) * math_norm3(normal_neighbor2me)
normal_neighbor2me = normal_neighbor2me / math_norm3(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)
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
if (neighboring_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
.and. v(s,t) * neighboring_v(s,t) >= 0.0_pReal ) then ! ... only if no sign change in flux density
do deads = 0_pInt,4_pInt,4_pInt
lineLength = abs(neighboring_rhoSgl(s,t+deads)) * neighboring_v(s,t) &
* math_mul3x3(m(1:3,s,t), normal_neighbor2me) * area ! positive line length that wants to enter through this interface
where (constitutive_nonlocal_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
* constitutive_nonlocal_compatibility(c,1_pInt:ns,s,n,ip,el) ** 2.0_pReal
where (constitutive_nonlocal_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
* constitutive_nonlocal_compatibility(c,1_pInt:ns,s,n,ip,el) ** 2.0_pReal
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
* 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
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
!* This is not considered, if my opposite neighbor has a different constitutive law than nonlocal (still considered for nonlocal law with lcal 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.
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
if (opposite_el > 0_pInt .and. opposite_ip > 0_pInt) then
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (phase_plasticity(material_phase(1,opposite_ip,opposite_el)) /= constitutive_nonlocal_label) &
* 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
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
normal_me2neighbor_defConf = math_det33(Favg) * math_mul33x3(math_inv33(math_transpose33(Favg)), &
mesh_ipAreaNormal(1:3,n,ip,el)) ! calculate the normal of the interface in (average) deformed configuration (pointing from me to my neighbor!!!)
N^2 initialization loop (former spectralPictureMode) rewritten in material.f90 additional output in DAMASK_spectral_interface.f90 132 character cut off in constitutive_nonlocal.f90 rounding error in math.f90 complex number initialization (1.0_pReal)*2.0_pReal*pi new $DAMASK_NUM_THREADS warning in numerics.f90 / IO.f90 polishing in DAMASK_spectral.f90
2012-01-30 19:22:41 +05:30
normal_me2neighbor = math_mul33x3(math_transpose33(my_Fe), normal_me2neighbor_defConf) / math_det33(my_Fe) ! interface normal in my lattice configuration
* 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
area = mesh_ipArea(n,ip,el) * math_norm3(normal_me2neighbor)
normal_me2neighbor = normal_me2neighbor / math_norm3(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
c = (t + 1_pInt) / 2_pInt
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
if (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)
if (v(s,t) * neighboring_v(s,t) >= 0.0_pReal) then ! no sign change in flux density
transmissivity = sum(constitutive_nonlocal_compatibility(c,1_pInt:ns,s,n,ip,el)**2.0_pReal) ! overall transmissivity from this slip system to my 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
else ! sign change in flux density means sign change in stress which does not allow for dislocations to arive at the neighbor
transmissivity = 0.0_pReal
endif
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
lineLength = rhoSgl(s,t) * 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
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
rhoDotFlux(s,t+4_pInt) = rhoDotFlux(s,t+4_pInt) + lineLength / mesh_ipVolume(ip,el) * (1.0_pReal - transmissivity) &
Dead dislocations are treated the same as mobile dislocations for the flux part though they do not contribute to slip. By that the pileup of dead dislocations is able to diminish with time (kinetics are the same as for the glide part; this is not correct but gives valuable results). Also remobilization of dead dislocations at neighbor is taken into account for flux.
2012-03-14 21:02:50 +05:30
* sign(1.0_pReal, 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
lineLength = rhoSgl(s,t+4_pInt) * v(s,t) * math_mul3x3(m(1:3,s,t), normal_me2neighbor) * area ! positive line length of deads that wants to leave through this interface
rhoDotFlux(s,t+4_pInt) = rhoDotFlux(s,t+4_pInt) - lineLength / mesh_ipVolume(ip,el) * transmissivity ! dead dislocations leaving through this interface
* 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
if (numerics_integrationMode == 1_pInt) then
* 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
constitutive_nonlocal_rhoDotFlux(1:ns,1:10,g,ip,el) = rhoDotFlux(1:ns,1:10) ! save flux calculation for output (if in central integration mode)
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
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
!****************************************************************************
!*** 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
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
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
rhoDotSingle2DipoleGlide(1:ns,2*c-1) = -2.0_pReal * dUpper(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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
* (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
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
rhoDotSingle2DipoleGlide(1:ns,2*c) = -2.0_pReal * dUpper(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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
* (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
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
rhoDotSingle2DipoleGlide(1:ns,2*c+3) = -2.0_pReal * dUpper(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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
* 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
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
rhoDotSingle2DipoleGlide(1:ns,2*c+4) = -2.0_pReal * dUpper(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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
* 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
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
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
!*** athermal annihilation
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
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
forall (c=1_pInt:2_pInt) &
rhoDotAthermalAnnihilation(1:ns,c+8_pInt) = -2.0_pReal * dLower(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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 * (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
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
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
!*** thermally activated annihilation of dipoles
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
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
D = constitutive_nonlocal_Dsd0(myInstance) * exp(-constitutive_nonlocal_Qsd(myInstance) / (kB * Temperature))
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
vClimb = constitutive_nonlocal_atomicVolume(myInstance) * D / ( kB * Temperature ) &
* constitutive_nonlocal_Gmod(myInstance) / ( 2.0_pReal * pi * (1.0_pReal-constitutive_nonlocal_nu(myInstance)) ) &
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) )
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 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
rhoDotThermalAnnihilation(1:ns,9) = - 4.0_pReal * rhoDip(1:ns,1) * vClimb / (dUpper(1:ns,1) - dLower(1:ns,1)) ! edge climb
rhoDotThermalAnnihilation(1:ns,10) = 0.0_pReal !!! cross slipping still has to be implemented !!!
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
dotState=NaN enforces cutback, if evolution rates lead to negative densities
2012-02-22 21:38:22 +05:30
if ( any(rhoSgl(1:ns,1:4) + rhoDot(1:ns,1:4) * timestep < - constitutive_nonlocal_aTolRho(myInstance)) &
.or. any(rhoDip(1:ns,1:2) + rhoDot(1:ns,9:10) * timestep < - constitutive_nonlocal_aTolRho(myInstance))) then
#ifndef _OPENMP
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) then
dotState=NaN enforces cutback, if evolution rates lead to negative densities
2012-02-22 21:38:22 +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
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
constitutive_nonlocal_dotState = DAMASK_NaN
dotState=NaN enforces cutback, if evolution rates lead to negative densities
2012-02-22 21:38:22 +05:30
return
else
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
constitutive_nonlocal_dotState(1:10_pInt*ns) = reshape(rhoDot,(/10_pInt*ns/))
dotState=NaN enforces cutback, if evolution rates lead to negative densities
2012-02-22 21:38:22 +05:30
endif
* 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
#ifndef _OPENMP
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 &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((debug_e == el .and. debug_i == ip .and. debug_g == g)&
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,/,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
write(6,'(a,/,2(12x,12(e12.5,1x),/))') '<< CONST >> athermal dipole annihilation', &
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
rhoDotAthermalAnnihilation(1:ns,1:2) * timestep
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,/,2(12x,12(e12.5,1x),/))') '<< CONST >> thermally activated dipole annihilation', &
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
rhoDotThermalAnnihilation(1:ns,9:10) * timestep
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 >> total density change', rhoDot * timestep
write(6,'(a,/,10(12x,12(f12.7,1x),/))') '<< CONST >> relative density change', &
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
rhoDot(1:ns,1:8) * timestep / (abs(rhoSgl)+1.0e-10), &
rhoDot(1:ns,9:10) * timestep / (rhoDip+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
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
endfunction
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: - 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
!*********************************************************************
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +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. *
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
!*********************************************************************
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
subroutine constitutive_nonlocal_updateCompatibility(orientation,i,e)
use prec, only: pReal, &
pInt
use math, only: math_QuaternionDisorientation, &
math_mul3x3, &
math_qRot
use material, only: material_phase, &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
phase_localPlasticity, &
phase_plasticityInstance, &
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
homogenization_maxNgrains
use mesh, only: mesh_element, &
mesh_ipNeighborhood, &
FE_NipNeighbors, &
mesh_maxNips, &
mesh_NcpElems
use lattice, only: lattice_sn, &
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +05:30
lattice_sd
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
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
implicit none
!* input variables
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
integer(pInt), intent(in) :: i, & ! ip index
e ! element index
real(pReal), dimension(4,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
orientation ! crystal orientation in quaternions
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
!* output variables
!* local variables
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
integer(pInt) Nneighbors, & ! number of neighbors
n, & ! neighbor index
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
neighboring_e, & ! element index of my neighbor
neighboring_i, & ! integration point index of my neighbor
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
my_phase, &
neighboring_phase, &
my_structure, & ! lattice structure
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
my_instance, & ! instance of plasticity
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
ns, & ! number of active slip systems
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
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
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(2,constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(1,i,e))),&
constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(1,i,e))),&
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
FE_NipNeighbors(mesh_element(2,e))) :: &
compatibility ! compatibility for current element and ip
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(3,constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(1,i,e)))) :: &
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
slipNormal, &
slipDirection
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
real(pReal) compatibilitySum, &
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
thresholdValue, &
nThresholdValues
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
logical, dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(1,i,e)))) :: &
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
belowThreshold
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
Nneighbors = FE_NipNeighbors(mesh_element(2,e))
my_phase = material_phase(1,i,e)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
my_instance = phase_plasticityInstance(my_phase)
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
my_structure = constitutive_nonlocal_structure(my_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
ns = constitutive_nonlocal_totalNslip(my_instance)
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +05:30
slipNormal(1:3,1:ns) = lattice_sn(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,my_instance), my_structure)
slipDirection(1:3,1:ns) = lattice_sd(1:3, constitutive_nonlocal_slipSystemLattice(1:ns,my_instance), my_structure)
!*** start out fully compatible
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
compatibility = 0.0_pReal
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
forall(s1 = 1_pInt:ns) &
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
compatibility(1:2,s1,s1,1:Nneighbors) = 1.0_pReal
restructured constitutive_nonlocal_compatibility and incorporated the "surfaceTransmissivity" in the compatibility calculation
2011-02-16 22:08:18 +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 thrugh neighbors and check whether there is any compatibility.
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 n = 1_pInt,Nneighbors
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
neighboring_e = mesh_ipNeighborhood(1,n,i,e)
neighboring_i = mesh_ipNeighborhood(2,n,i,e)
!* FREE SURFACE
!* Set surface transmissivity to the value specified in the material.config
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
if (neighboring_e <= 0_pInt .or. neighboring_i <= 0_pInt) then
forall(s1 = 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
compatibility(1:2,s1,s1,n) = sqrt(constitutive_nonlocal_surfaceTransmissivity(my_instance))
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.
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
!* If the neighboring "cpfem" phase has a local plasticity,
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
!* we do not consider this to be a phase boundary, so completely compatible.
neighboring_phase = material_phase(1,neighboring_i,neighboring_e)
if (neighboring_phase /= my_phase) then
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. phase_localPlasticity(neighboring_phase)) then
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
forall(s1 = 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
compatibility(1:2,s1,s1,n) = 0.0_pReal ! = sqrt(0.0)
endif
cycle
endif
!* GRAIN BOUNDARY ?
!* The 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 compatibility values exceeding one.
!* Finally the smallest compatibility value is decreased until the sum is exactly equal to one.
!* All values below the threshold are set to zero.
absoluteMisorientation = math_QuaternionDisorientation(orientation(1:4,1,i,e), &
orientation(1:4,1,neighboring_i,neighboring_e), &
0_pInt) ! no symmetry
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 s1 = 1_pInt,ns ! my slip systems
do s2 = 1_pInt,ns ! my neighbor's slip systems
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
compatibility(1,s2,s1,n) = math_mul3x3(slipNormal(1:3,s1), math_qRot(absoluteMisorientation, slipNormal(1:3,s2))) &
* abs(math_mul3x3(slipDirection(1:3,s1), math_qRot(absoluteMisorientation, slipDirection(1:3,s2))))
compatibility(2,s2,s1,n) = abs(math_mul3x3(slipNormal(1:3,s1), math_qRot(absoluteMisorientation, slipNormal(1:3,s2)))) &
* abs(math_mul3x3(slipDirection(1:3,s1), math_qRot(absoluteMisorientation, slipDirection(1:3,s2))))
enddo
compatibilitySum = 0.0_pReal
belowThreshold = .true.
do while (compatibilitySum < 1.0_pReal .and. any(belowThreshold(1:ns)))
thresholdValue = maxval(compatibility(2,1:ns,s1,n), belowThreshold(1:ns)) ! screws always positive
nThresholdValues = real(count(compatibility(2,1:ns,s1,n) == thresholdValue),pReal)
where (compatibility(2,1:ns,s1,n) >= thresholdValue) &
belowThreshold(1:ns) = .false.
if (compatibilitySum + thresholdValue * nThresholdValues > 1.0_pReal) &
where (abs(compatibility(1:2,1:ns,s1,n)) == thresholdValue) &
compatibility(1:2,1:ns,s1,n) = sign((1.0_pReal - compatibilitySum) / nThresholdValues, compatibility(1:2,1:ns,s1,n))
compatibilitySum = compatibilitySum + nThresholdValues * thresholdValue
enddo
where (belowThreshold(1:ns)) compatibility(1,1:ns,s1,n) = 0.0_pReal
where (belowThreshold(1:ns)) compatibility(2,1:ns,s1,n) = 0.0_pReal
enddo ! my slip systems cycle
enddo ! neighbor cycle
constitutive_nonlocal_compatibility(1:2,1:ns,1:ns,1:Nneighbors,i,e) = compatibility
endsubroutine
!*********************************************************************
!* rate of change of temperature *
!*********************************************************************
pure function constitutive_nonlocal_dotTemperature(Tstar_v,Temperature,state,g,ip,el)
use prec, only: pReal, &
pInt, &
p_vec
use mesh, only: mesh_NcpElems, &
mesh_maxNips
use material, only: homogenization_maxNgrains
implicit none
!* input variables
integer(pInt), intent(in) :: g, & ! current grain ID
ip, & ! current integration point
el ! current element
real(pReal), intent(in) :: Temperature ! temperature
real(pReal), dimension(6), intent(in) :: Tstar_v ! 2nd Piola-Kirchhoff stress in Mandel notation
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
state ! microstructural state
!* output variables
real(pReal) constitutive_nonlocal_dotTemperature ! evolution of Temperature
!* local variables
constitutive_nonlocal_dotTemperature = 0.0_pReal
endfunction
!*********************************************************************
!* calculates quantities characterizing the microstructure *
!*********************************************************************
function constitutive_nonlocal_dislocationstress(state, Fe, g, ip, el)
use prec, only: pReal, &
pInt, &
p_vec
use math, only: math_mul33x33, &
math_mul33x3, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_invert33, &
math_transpose33, &
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
pi
use mesh, only: mesh_NcpElems, &
mesh_maxNips, &
mesh_element, &
mesh_node0, &
FE_Nips, &
mesh_ipCenterOfGravity, &
mesh_ipVolume, &
mesh_periodicSurface
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_localPlasticity, &
phase_plasticityInstance
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
implicit none
!*** input variables
integer(pInt), intent(in) :: g, & ! current grain ID
ip, & ! current integration point
el ! current element
real(pReal), dimension(3,3,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
Fe ! elastic deformation gradient
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
state ! microstructural state
!*** input/output variables
!*** output variables
real(pReal), dimension(3,3) :: constitutive_nonlocal_dislocationstress
!*** local variables
integer(pInt) neighboring_el, & ! element number of neighboring material point
neighboring_ip, & ! integration point of neighboring material point
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
instance, & ! my instance of this plasticity
neighboring_instance, & ! instance of this plasticity of neighboring material point
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
latticeStruct, & ! my lattice structure
neighboring_latticeStruct, & ! lattice structure of neighboring material point
phase, &
neighboring_phase, &
ns, & ! total number of active slip systems at my material point
neighboring_ns, & ! total number of active slip systems at neighboring material point
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, &
deltaX, deltaY, deltaZ, &
side, &
j
integer(pInt), dimension(2,3) :: periodicImages
real(pReal) nu, & ! poisson's ratio
x, y, z, & ! coordinates of connection vector in neighboring lattice frame
xsquare, ysquare, zsquare, & ! squares of respective coordinates
distance, & ! length of connection vector
segmentLength, & ! segment length of dislocations
lambda, &
R, Rsquare, Rcube, &
denominator, &
flipSign, &
neighboring_ipVolumeSideLength, &
detFe
real(pReal), dimension(3) :: connection, & ! connection vector between me and my neighbor in the deformed configuration
connection_neighboringLattice, & ! connection vector between me and my neighbor in the lattice configuration of my neighbor
connection_neighboringSlip, & ! connection vector between me and my neighbor in the slip system frame of my neighbor
maxCoord, minCoord, &
meshSize, &
ipCoords, &
neighboring_ipCoords
real(pReal), dimension(3,3) :: sigma, & ! dislocation stress for one slip system in neighboring material point's slip system frame
Tdislo_neighboringLattice, & ! dislocation stress as 2nd Piola-Kirchhoff stress at neighboring material point
invFe, & ! inverse of my elastic deformation gradient
neighboring_invFe, &
neighboringLattice2myLattice ! mapping from neighboring MPs lattice configuration to my lattice configuration
real(pReal), dimension(2,2,maxval(constitutive_nonlocal_totalNslip)) :: &
neighboring_rhoExcess ! excess density at neighboring material point (edge/screw,mobile/dead,slipsystem)
real(pReal), dimension(2,maxval(constitutive_nonlocal_totalNslip)) :: &
rhoExcessDead
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,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-)
logical inversionError
phase = material_phase(g,ip,el)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
instance = phase_plasticityInstance(phase)
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
latticeStruct = constitutive_nonlocal_structure(instance)
ns = constitutive_nonlocal_totalNslip(instance)
!*** get basic states
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
forall (s = 1_pInt:ns, t = 1_pInt:4_pInt) &
rhoSgl(s,t) = max(state(g,ip,el)%p((t-1_pInt)*ns+s), 0.0_pReal) ! ensure positive single mobile densities
forall (t = 5_pInt:8_pInt) &
rhoSgl(1:ns,t) = state(g,ip,el)%p((t-1_pInt)*ns+1_pInt:t*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
!*** 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
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
constitutive_nonlocal_dislocationstress = 0.0_pReal
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. phase_localPlasticity(phase)) then
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
call math_invert33(Fe(1:3,1:3,g,ip,el), invFe, detFe, inversionError)
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
! if (inversionError) then
! return
! endif
!* in case of periodic surfaces we have to find out how many periodic images in each direction we need
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
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
maxCoord(dir) = maxval(mesh_node0(dir,:))
minCoord(dir) = minval(mesh_node0(dir,:))
enddo
meshSize = maxCoord - minCoord
ipCoords = mesh_ipCenterOfGravity(1:3,ip,el)
periodicImages = 0_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
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
if (mesh_periodicSurface(dir)) then
periodicImages(1,dir) = floor((ipCoords(dir) - constitutive_nonlocal_R(instance) - minCoord(dir)) / meshSize(dir), pInt)
periodicImages(2,dir) = ceiling((ipCoords(dir) + constitutive_nonlocal_R(instance) - maxCoord(dir)) / meshSize(dir), pInt)
endif
enddo
!* loop through all material points (also through their periodic images if present),
!* but only consider nonlocal neighbors within a certain cutoff radius R
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 neighboring_el = 1_pInt,mesh_NcpElems
ipLoop: do neighboring_ip = 1_pInt,FE_Nips(mesh_element(2,neighboring_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
neighboring_phase = material_phase(g,neighboring_ip,neighboring_el)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (phase_localPlasticity(neighboring_phase)) then
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
cycle
endif
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
neighboring_instance = phase_plasticityInstance(neighboring_phase)
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
neighboring_latticeStruct = constitutive_nonlocal_structure(neighboring_instance)
neighboring_ns = constitutive_nonlocal_totalNslip(neighboring_instance)
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
call math_invert33(Fe(1:3,1:3,1,neighboring_ip,neighboring_el), neighboring_invFe, detFe, inversionError)
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
! if (inversionError) then
! return
! endif
neighboring_ipVolumeSideLength = mesh_ipVolume(neighboring_ip,neighboring_el) ** (1.0_pReal/3.0_pReal) ! reference volume used here
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
forall (s = 1_pInt:neighboring_ns, c = 1_pInt:2_pInt) &
neighboring_rhoExcess(c,1,s) = state(g,neighboring_ip,neighboring_el)%p((2_pInt*c-2_pInt)*neighboring_ns+s) & ! positive mobiles
- state(g,neighboring_ip,neighboring_el)%p((2_pInt*c-1_pInt)*neighboring_ns+s) ! negative mobiles
forall (s = 1_pInt:neighboring_ns, c = 1_pInt:2_pInt) &
neighboring_rhoExcess(c,2,s) = abs(state(g,neighboring_ip,neighboring_el)%p((2_pInt*c+2_pInt)*neighboring_ns+s)) & ! positive deads
- abs(state(g,neighboring_ip,neighboring_el)%p((2_pInt*c+3_pInt)*neighboring_ns+s)) ! negative deads
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
nu = constitutive_nonlocal_nu(neighboring_instance)
Tdislo_neighboringLattice = 0.0_pReal
do deltaX = periodicImages(1,1),periodicImages(2,1)
do deltaY = periodicImages(1,2),periodicImages(2,2)
do deltaZ = periodicImages(1,3),periodicImages(2,3)
!* regular case
if (neighboring_el /= el .or. neighboring_ip /= ip &
.or. deltaX /= 0_pInt .or. deltaY /= 0_pInt .or. deltaZ /= 0_pInt) then
neighboring_ipCoords = mesh_ipCenterOfGravity(1:3,neighboring_ip,neighboring_el) &
+ (/real(deltaX,pReal), real(deltaY,pReal), real(deltaZ,pReal)/) * meshSize
connection = neighboring_ipCoords - ipCoords
distance = sqrt(sum(connection * connection))
if (distance > constitutive_nonlocal_R(instance)) then
cycle
endif
!* the segment length is the minimum of the third root of the control volume and the ip distance
!* this ensures, that the central MP never sits on a neighboring dislocation segment
connection_neighboringLattice = math_mul33x3(neighboring_invFe, connection)
segmentLength = min(neighboring_ipVolumeSideLength, distance)
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +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 all slip systems of the neighboring material point
!* and add up the stress contributions from egde and screw excess on these slip systems (if significant)
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,neighboring_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
if (all(abs(neighboring_rhoExcess(:,:,s)) < constitutive_nonlocal_aTolRho(instance))) then
cycle ! not significant
endif
!* map the connection vector from the lattice into the slip system frame
connection_neighboringSlip = math_mul33x3(constitutive_nonlocal_lattice2slip(1:3,1:3,s,neighboring_instance), &
connection_neighboringLattice)
!* edge contribution to stress
sigma = 0.0_pReal
x = connection_neighboringSlip(1)
y = connection_neighboringSlip(2)
z = connection_neighboringSlip(3)
xsquare = x * x
ysquare = y * y
zsquare = z * z
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 j = 1_pInt,2_pInt
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
if (abs(neighboring_rhoExcess(1,j,s)) < constitutive_nonlocal_aTolRho(instance)) then
cycle
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
elseif (j > 1_pInt) then
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
x = connection_neighboringSlip(1) + sign(0.5_pReal * segmentLength, &
state(g,neighboring_ip,neighboring_el)%p(4*neighboring_ns+s) &
- state(g,neighboring_ip,neighboring_el)%p(5*neighboring_ns+s))
xsquare = x * x
endif
flipSign = sign(1.0_pReal, -y)
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 side = 1_pInt,-1_pInt,-2_pInt
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
lambda = real(side,pReal) * 0.5_pReal * segmentLength - y
R = sqrt(xsquare + zsquare + lambda * lambda)
Rsquare = R * R
Rcube = Rsquare * R
denominator = R * (R + flipSign * lambda)
if (denominator == 0.0_pReal) then
exit ipLoop
endif
sigma(1,1) = sigma(1,1) - real(side,pReal) * flipSign * z / denominator &
* (1.0_pReal + xsquare / Rsquare + xsquare / denominator) &
* neighboring_rhoExcess(1,j,s)
sigma(2,2) = sigma(2,2) - real(side,pReal) * (flipSign * 2.0_pReal * nu * z / denominator + z * lambda / Rcube)&
* neighboring_rhoExcess(1,j,s)
sigma(3,3) = sigma(3,3) + real(side,pReal) * flipSign * z / denominator &
* (1.0_pReal - zsquare / Rsquare - zsquare / denominator) &
* neighboring_rhoExcess(1,j,s)
sigma(1,2) = sigma(1,2) + real(side,pReal) * x * z / Rcube * neighboring_rhoExcess(1,j,s)
sigma(1,3) = sigma(1,3) + real(side,pReal) * flipSign * x / denominator &
* (1.0_pReal - zsquare / Rsquare - zsquare / denominator) &
* neighboring_rhoExcess(1,j,s)
sigma(2,3) = sigma(2,3) - real(side,pReal) * (nu / R - zsquare / Rcube) * neighboring_rhoExcess(1,j,s)
enddo
enddo
!* screw contribution to stress
x = connection_neighboringSlip(1) ! have to restore this value, because position might have been adapted for edge deads before
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 j = 1_pInt,2_pInt
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
if (abs(neighboring_rhoExcess(2,j,s)) < constitutive_nonlocal_aTolRho(instance)) then
cycle
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
elseif (j > 1_pInt) then
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
y = connection_neighboringSlip(2) + sign(0.5_pReal * segmentLength, &
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
state(g,neighboring_ip,neighboring_el)%p(6_pInt*neighboring_ns+s) &
- state(g,neighboring_ip,neighboring_el)%p(7_pInt*neighboring_ns+s))
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
ysquare = y * y
endif
changed internal representation of orientation and misorientation from euler angles to quaternions (this should also fix some bugs in the math_misorientation subroutine). includes a couple of new functions in math.f90 and some changes in crystallite.f90. beware that crystallite output "orientation" now by default returns the orientation as quaternion. if you want euler angles instead, you have to add "eulerangles" as a crystallite output in your material.config file (see material.config template). for input of orientations in the texture block of the material.config you still have to specify the rotation in terms of euler angles, quaternions are not yet supported for input.
2010-03-18 17:53:17 +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
flipSign = sign(1.0_pReal, x)
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 side = 1_pInt,-1_pInt,-2_pInt
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
lambda = x + real(side,pReal) * 0.5_pReal * segmentLength
R = sqrt(ysquare + zsquare + lambda * lambda)
Rsquare = R * R
Rcube = Rsquare * R
denominator = R * (R + flipSign * lambda)
if (denominator == 0.0_pReal) then
exit ipLoop
endif
sigma(1,2) = sigma(1,2) - real(side,pReal) * flipSign * z * (1.0_pReal - nu) / denominator &
* neighboring_rhoExcess(2,j,s)
sigma(1,3) = sigma(1,3) + real(side,pReal) * flipSign * y * (1.0_pReal - nu) / denominator &
* neighboring_rhoExcess(2,j,s)
enddo
enddo
if (all(abs(sigma) < 1.0e-10_pReal)) then ! SIGMA IS NOT A REAL STRESS, THATS WHY WE NEED A REALLY SMALL VALUE HERE
cycle
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
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
!* copy symmetric parts
sigma(2,1) = sigma(1,2)
sigma(3,1) = sigma(1,3)
sigma(3,2) = sigma(2,3)
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
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
!* scale stresses and map them into the neighboring material point's lattice configuration
sigma = sigma * constitutive_nonlocal_Gmod(neighboring_instance) &
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
* constitutive_nonlocal_burgers(s,neighboring_instance) &
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
/ (4.0_pReal * pi * (1.0_pReal - nu)) &
* mesh_ipVolume(neighboring_ip,neighboring_el) / segmentLength ! reference volume is used here (according to the segment length calculation)
Tdislo_neighboringLattice = Tdislo_neighboringLattice &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
+ math_mul33x33(math_transpose33(constitutive_nonlocal_lattice2slip(1:3,1:3,s,neighboring_instance)), &
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
math_mul33x33(sigma, constitutive_nonlocal_lattice2slip(1:3,1:3,s,neighboring_instance)))
enddo ! slip system loop
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
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
!* special case of central ip volume
!* only consider dead dislocations
!* we assume that they all sit at a distance equal to half the third root of V
!* in direction of the according slip direction
else
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
forall (s = 1_pInt:ns, c = 1_pInt:2_pInt) &
rhoExcessDead(c,s) = state(g,ip,el)%p((2_pInt*c+2_pInt)*ns+s) & ! positive deads (here we use symmetry: if this has negative sign it is treated as negative density at positive position instead of positive density at negative position)
+ state(g,ip,el)%p((2_pInt*c+3_pInt)*ns+s) ! negative deads (here we use symmetry: if this has negative sign it is treated as positive density at positive position instead of negative density at negative position)
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
if (all(abs(rhoExcessDead(:,s)) < constitutive_nonlocal_aTolRho(instance))) then
cycle ! not significant
endif
sigma = 0.0_pReal ! all components except for sigma13 are zero
sigma(1,3) = - (rhoExcessDead(1,s) + rhoExcessDead(2,s) * (1.0_pReal - nu)) * neighboring_ipVolumeSideLength &
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
* constitutive_nonlocal_Gmod(instance) * constitutive_nonlocal_burgers(s,instance) &
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
/ (sqrt(2.0_pReal) * pi * (1.0_pReal - nu))
sigma(3,1) = sigma(1,3)
Tdislo_neighboringLattice = Tdislo_neighboringLattice &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
+ math_mul33x33(math_transpose33(constitutive_nonlocal_lattice2slip(1:3,1:3,s,instance)), &
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
math_mul33x33(sigma, constitutive_nonlocal_lattice2slip(1:3,1:3,s,instance)))
enddo ! slip system loop
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
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
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
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 ! deltaZ loop
enddo ! deltaY loop
enddo ! deltaX loop
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
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
!* map the stress from the neighboring MP's lattice configuration into the deformed configuration
!* and back into my lattice configuration
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
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
neighboringLattice2myLattice = math_mul33x33(invFe, Fe(1:3,1:3,1,neighboring_ip,neighboring_el))
constitutive_nonlocal_dislocationstress = constitutive_nonlocal_dislocationstress &
+ math_mul33x33(neighboringLattice2myLattice, &
math_mul33x33(Tdislo_neighboringLattice, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33(neighboringLattice2myLattice)))
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 ipLoop
enddo ! element loop
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
endfunction
!*********************************************************************
!* return array of constitutive results *
!*********************************************************************
* 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
function constitutive_nonlocal_postResults(Tstar_v, Fe, Temperature, dt, state, dotState, g,ip,el)
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.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
use prec, only: pReal, &
pInt, &
p_vec
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
use math, only: math_mul6x6, &
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
math_mul33x3, &
math_mul33x33, &
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
pi
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
use mesh, only: mesh_NcpElems, &
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +05:30
mesh_maxNips
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +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, &
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
phase_Noutput
mixed things up, did not want to commit constitutive_nonlocal.f90 but rather DAMASK_spectral.f90!!!! did a lot of polishing on constitutive_nonlocal.f90 (mostly checked in at last commit), for changes on DAMASK_spectral.f90 see previous message
2012-02-23 22:50:57 +05:30
use lattice, only: lattice_Sslip_v, &
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
lattice_sd, &
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
lattice_st
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
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
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
!*** input 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
integer(pInt), intent(in) :: g, & ! current grain number
ip, & ! current integration point
el ! current element number
real(pReal), intent(in) :: Temperature, & ! temperature
* 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
dt ! time increment
real(pReal), dimension(6), intent(in) :: Tstar_v ! current 2nd Piola-Kirchhoff stress in Mandel notation
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,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
Fe ! elastic deformation gradient
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
type(p_vec), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems), intent(in) :: &
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
state ! current microstructural state
type(p_vec), intent(in) :: dotState ! evolution rate of microstructural state
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
!*** output variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_sizePostResults(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
constitutive_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
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
!*** local variables
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
integer(pInt) myInstance, & ! current instance of this plasticity
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
myStructure, & ! current lattice structure
ns, & ! short notation for the total number of active slip systems
c, & ! character of dislocation
cs, & ! constitutive result index
o, & ! index of current output
t, & ! type of dislocation
s, & ! index of my current slip system
sLattice ! index of my current slip system according to lattice order
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),8) :: &
- 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
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)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),4) :: &
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
gdot, & ! shear rates
v ! velocities
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el)))) :: &
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
rhoForest, & ! forest dislocation density
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
tauThreshold, & ! threshold shear stress
tau, & ! current resolved shear stress
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
tauBack, & ! back stress from pileups on same slip system
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
vClimb ! climb velocity of edge dipoles
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),2) :: &
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
rhoDip, & ! current dipole dislocation densities (screw and edge dipoles)
- 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
rhoDotDip, & ! evolution rate of dipole dislocation densities (screw and edge dipoles)
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
dLower, & ! minimum stable dipole distance for edges and screws
* 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
dUpper ! current maximum stable dipole distance for edges and screws
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
real(pReal), dimension(3,constitutive_nonlocal_totalNslip(phase_plasticityInstance(material_phase(g,ip,el))),2) :: &
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
m, & ! direction of dislocation motion for edge and screw (unit vector)
m_currentconf ! direction of dislocation motion for edge and screw (unit vector) in current configuration
* 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
real(pReal) D ! self diffusion
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
real(pReal), dimension(3,3) :: sigma
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
myInstance = phase_plasticityInstance(material_phase(g,ip,el))
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
myStructure = constitutive_nonlocal_structure(myInstance)
ns = constitutive_nonlocal_totalNslip(myInstance)
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: - 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
cs = 0_pInt
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_postResults = 0.0_pReal
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
- corrected contribution of immobile singles to dipole formation and annihilation rates - remobilization of immobile singles immediately increases the mobile single dislocation density and therefore directly affects all other mechanisms in dotState
2010-01-06 15:24:00 +05:30
!* short hand notations for state variables
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
forall (t = 1_pInt:8_pInt) rhoSgl(1:ns,t) = state(g,ip,el)%p((t-1_pInt)*ns+1_pInt:t*ns)
forall (c = 1_pInt:2_pInt) rhoDip(1:ns,c) = state(g,ip,el)%p((7_pInt+c)*ns+1_pInt:(8_pInt+c)*ns)
rhoForest = state(g,ip,el)%p(10_pInt*ns+1:11_pInt*ns)
tauThreshold = state(g,ip,el)%p(11_pInt*ns+1:12_pInt*ns)
tauBack = state(g,ip,el)%p(12_pInt*ns+1:13_pInt*ns)
forall (t = 1_pInt:8_pInt) rhoDotSgl(1:ns,t) = dotState%p((t-1_pInt)*ns+1_pInt:t*ns)
forall (c = 1_pInt:2_pInt) rhoDotDip(1:ns,c) = dotState%p((7_pInt+c)*ns+1_pInt:(8_pInt+c)*ns)
forall (t = 1_pInt:4_pInt) v(1:ns,t) = state(g,ip,el)%p((12_pInt+t)*ns+1_pInt:(13_pInt+t)*ns)
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
- corrected contribution of immobile singles to dipole formation and annihilation rates - remobilization of immobile singles immediately increases the mobile single dislocation density and therefore directly affects all other mechanisms in dotState
2010-01-06 15:24:00 +05:30
!* Calculate shear rate
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 t = 1_pInt,4_pInt
do s = 1_pInt,ns
if (rhoSgl(s,t+4_pInt) * v(s,t) < 0.0_pReal) then
rhoSgl(s,t) = rhoSgl(s,t) + abs(rhoSgl(s,t+4_pInt)) ! remobilization of immobile singles for changing sign of v (bauschinger effect)
rhoSgl(s,t+4_pInt) = 0.0_pReal ! remobilization of immobile singles for changing sign of v (bauschinger effect)
- corrected contribution of immobile singles to dipole formation and annihilation rates - remobilization of immobile singles immediately increases the mobile single dislocation density and therefore directly affects all other mechanisms in dotState
2010-01-06 15:24:00 +05:30
endif
enddo
enddo
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +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
forall (t = 1_pInt:4_pInt) &
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
gdot(1:ns,t) = rhoSgl(1:ns,t) * constitutive_nonlocal_burgers(1:ns,myInstance) * v(1:ns,t)
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
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
* 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
- corrected contribution of immobile singles to dipole formation and annihilation rates - remobilization of immobile singles immediately increases the mobile single dislocation density and therefore directly affects all other mechanisms in dotState
2010-01-06 15:24:00 +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
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
sLattice = constitutive_nonlocal_slipSystemLattice(s,myInstance)
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
tau(s) = math_mul6x6(Tstar_v, lattice_Sslip_v(1:6,sLattice,myStructure)) + tauBack(s)
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
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
dLower = constitutive_nonlocal_minimumDipoleHeight(1:ns,1:2,myInstance)
corrected formulation of maximum height of screw dislocation dipoles
2012-07-24 20:20:11 +05:30
dUpper(1:ns,1) = constitutive_nonlocal_Gmod(myInstance) * constitutive_nonlocal_burgers(1:ns,myInstance) &
/ (8.0_pReal * pi * (1.0_pReal - constitutive_nonlocal_nu(myInstance)) * abs(tau))
dUpper(1:ns,2) = constitutive_nonlocal_Gmod(myInstance) * constitutive_nonlocal_burgers(1:ns,myInstance) &
/ (4.0_pReal * pi * abs(tau))
forall (c = 1_pInt:2_pInt) &
dUpper(1:ns,c) = min(1.0_pReal / sqrt(sum(abs(rhoSgl),c) + sum(rhoDip,c)), dUpper(1:ns,c))
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
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
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
!*** dislocation motion
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
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
m(1:3,1:ns,1) = lattice_sd(1:3,constitutive_nonlocal_slipSystemLattice(1:ns,myInstance),myStructure)
* "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
m(1:3,1:ns,2) = -lattice_st(1:3,constitutive_nonlocal_slipSystemLattice(1:ns,myInstance),myStructure)
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
forall (c = 1_pInt:2_pInt, s = 1_pInt:ns) &
* 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
m_currentconf(1:3,s,c) = math_mul33x3(Fe, m(1:3,s,c))
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
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 o = 1_pInt,phase_Noutput(material_phase(g,ip,el))
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
select case(constitutive_nonlocal_output(o,myInstance))
case ('rho')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl),2) + sum(rhoDip,2)
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
cs = cs + ns
- 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
case ('rho_sgl')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl),2)
- 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
cs = cs + ns
case ('rho_sgl_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl(1:ns,1:4)),2)
- 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
cs = cs + ns
case ('rho_sgl_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoSgl(1:ns,5:8),2)
- 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
cs = cs + ns
case ('rho_dip')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoDip,2)
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case ('rho_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl(1:ns,(/1,2,5,6/))),2) + rhoDip(1:ns,1)
- 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
cs = cs + ns
case ('rho_sgl_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl(1:ns,(/1,2,5,6/))),2)
- 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
cs = cs + ns
case ('rho_sgl_edge_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoSgl(1:ns,1:2),2)
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
- 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
case ('rho_sgl_edge_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoSgl(1:ns,5:6),2)
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
cs = cs + ns
- 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
case ('rho_sgl_edge_pos')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,1) + abs(rhoSgl(1:ns,5))
- 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
cs = cs + ns
case ('rho_sgl_edge_pos_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,1)
- 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
cs = cs + ns
case ('rho_sgl_edge_pos_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,5)
- 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
cs = cs + ns
case ('rho_sgl_edge_neg')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,2) + abs(rhoSgl(1:ns,6))
- 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
cs = cs + ns
case ('rho_sgl_edge_neg_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,2)
- 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
cs = cs + ns
case ('rho_sgl_edge_neg_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,6)
- 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
cs = cs + ns
case ('rho_dip_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoDip(1:ns,1)
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case ('rho_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl(1:ns,(/3,4,7,8/))),2) + rhoDip(1:ns,2)
- 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
cs = cs + ns
case ('rho_sgl_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(rhoSgl(1:ns,(/3,4,7,8/))),2)
- 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
cs = cs + ns
case ('rho_sgl_screw_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoSgl(1:ns,3:4),2)
- 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
cs = cs + ns
case ('rho_sgl_screw_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoSgl(1:ns,7:8),2)
- 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
cs = cs + ns
case ('rho_sgl_screw_pos')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,3) + abs(rhoSgl(1:ns,7))
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
- 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
case ('rho_sgl_screw_pos_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,3)
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
cs = cs + ns
- 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
case ('rho_sgl_screw_pos_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,7)
- 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
cs = cs + ns
case ('rho_sgl_screw_neg')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,4) + abs(rhoSgl(1:ns,8))
- 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
cs = cs + ns
case ('rho_sgl_screw_neg_mobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,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
cs = cs + ns
case ('rho_sgl_screw_neg_immobile')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,8)
- 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
cs = cs + ns
case ('rho_dip_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoDip(1:ns,2)
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
cs = cs + ns
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
case ('excess_rho')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = (rhoSgl(1:ns,1) + abs(rhoSgl(1:ns,5))) &
- (rhoSgl(1:ns,2) + abs(rhoSgl(1:ns,6))) &
+ (rhoSgl(1:ns,3) + abs(rhoSgl(1:ns,7))) &
- (rhoSgl(1:ns,4) + abs(rhoSgl(1:ns,8)))
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
cs = cs + ns
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
case ('excess_rho_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = (rhoSgl(1:ns,1) + abs(rhoSgl(1:ns,5))) &
- (rhoSgl(1:ns,2) + abs(rhoSgl(1:ns,6)))
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +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
case ('excess_rho_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = (rhoSgl(1:ns,3) + abs(rhoSgl(1:ns,7))) &
- (rhoSgl(1:ns,4) + abs(rhoSgl(1:ns,8)))
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case ('rho_forest')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoForest
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
cs = cs + ns
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
- 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
case ('delta')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = 1.0_pReal / sqrt(sum(abs(rhoSgl),2) + sum(rhoDip,2))
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
cs = cs + ns
- 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
case ('delta_sgl')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = 1.0_pReal / sqrt(sum(abs(rhoSgl),2))
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
cs = cs + ns
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
- 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
case ('delta_dip')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = 1.0_pReal / sqrt(sum(rhoDip,2))
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case ('shearrate')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(gdot,2)
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case ('resolvedstress')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = tau
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +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
case ('resolvedstress_back')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = tauBack
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
cs = cs + ns
case ('resolvedstress_external')
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
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
sLattice = constitutive_nonlocal_slipSystemLattice(s,myInstance)
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
constitutive_nonlocal_postResults(cs+s) = math_mul6x6(Tstar_v, lattice_Sslip_v(1:6,sLattice,myStructure))
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
cs = cs + ns
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
case ('resistance')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = tauThreshold
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
cs = cs + ns
case ('rho_dot')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoDotSgl,2) + sum(rhoDotDip,2)
- 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
cs = cs + ns
case ('rho_dot_sgl')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoDotSgl,2)
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
cs = cs + ns
case ('rho_dot_dip')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(rhoDotDip,2)
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
cs = cs + ns
case ('rho_dot_gen')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(gdot),2) * sqrt(rhoForest) &
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
/ constitutive_nonlocal_lambda0(1:ns,myInstance) &
/ constitutive_nonlocal_burgers(1:ns,myInstance)
- 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
cs = cs + ns
case ('rho_dot_gen_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(gdot(1:ns,3:4)),2) * sqrt(rhoForest) &
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
/ constitutive_nonlocal_lambda0(1:ns,myInstance) &
/ constitutive_nonlocal_burgers(1:ns,myInstance)
- 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
cs = cs + ns
case ('rho_dot_gen_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(abs(gdot(1:ns,1:2)),2) * sqrt(rhoForest) &
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
/ constitutive_nonlocal_lambda0(1:ns,myInstance) &
/ constitutive_nonlocal_burgers(1:ns,myInstance)
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
cs = cs + ns
case ('rho_dot_sgl2dip')
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 ! dipole formation by glide
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = constitutive_nonlocal_postResults(cs+1:cs+ns) + &
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
2.0_pReal * dUpper(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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
* ( 2.0_pReal * ( rhoSgl(1:ns,2_pInt*c-1_pInt) * abs(gdot(1:ns,2*c)) &
+ rhoSgl(1:ns,2_pInt*c) * abs(gdot(1:ns,2_pInt*c-1_pInt))) & ! was single hitting single
+ 2.0_pReal * ( abs(rhoSgl(1:ns,2_pInt*c+3_pInt)) * abs(gdot(1:ns,2_pInt*c)) &
+ abs(rhoSgl(1:ns,2_pInt*c+4_pInt)) * abs(gdot(1:ns,2_pInt*c-1_pInt)))) ! was single hitting immobile/used single
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
enddo
cs = cs + ns
case ('rho_dot_ann_ath')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = constitutive_nonlocal_postResults(cs+1:cs+ns) + &
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
2.0_pReal * dLower(1:ns,c) / constitutive_nonlocal_burgers(1:ns,myInstance) &
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
* ( 2.0_pReal * ( rhoSgl(1:ns,2_pInt*c-1_pInt) * abs(gdot(1:ns,2_pInt*c)) &
+ rhoSgl(1:ns,2_pInt*c) * abs(gdot(1:ns,2_pInt*c-1_pInt))) & ! was single hitting single
+ 2.0_pReal * ( abs(rhoSgl(1:ns,2_pInt*c+3_pInt)) * abs(gdot(1:ns,2_pInt*c)) &
+ abs(rhoSgl(1:ns,2_pInt*c+4_pInt)) * abs(gdot(1:ns,2_pInt*c-1_pInt))) & ! was single hitting immobile/used single
+ rhoDip(1:ns,c) * (abs(gdot(1:ns,2_pInt*c-1_pInt)) + abs(gdot(1:ns,2_pInt*c)))) ! single knocks dipole constituent
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
enddo
cs = cs + ns
case ('rho_dot_ann_the')
* kinetics now according to Mohles; enables solid solution hardening * changed example in material.config accordingly
2011-01-26 15:47:42 +05:30
D = constitutive_nonlocal_Dsd0(myInstance) * exp(-constitutive_nonlocal_Qsd(myInstance) / (kB * Temperature))
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
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
vClimb = constitutive_nonlocal_atomicVolume(myInstance) * D / (kB * Temperature) &
* constitutive_nonlocal_Gmod(myInstance) / (2.0_pReal * pi * (1.0_pReal-constitutive_nonlocal_nu(myInstance))) &
* 2.0_pReal / (dUpper(1:ns,1) + dLower(1:ns,1))
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
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = 4.0_pReal * rhoDip(1:ns,1) * vClimb / (dUpper(1:ns,1) - dLower(1:ns,1))
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
! !!! cross-slip of screws missing !!!
cs = cs + ns
new output "dislocationvelocity"
2010-02-23 22:53:07 +05:30
added output for dislocation evolution rate associated with flux: "rho_dot_flux"
2010-03-10 15:19:40 +05:30
case ('rho_dot_flux')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(constitutive_nonlocal_rhoDotFlux(1:ns,1:4,g,ip,el),2) &
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
+ sum(abs(constitutive_nonlocal_rhoDotFlux(1:ns,5:8,g,ip,el)),2)
added output for dislocation evolution rate associated with flux: "rho_dot_flux"
2010-03-10 15:19:40 +05:30
cs = cs + ns
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
case ('rho_dot_flux_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(constitutive_nonlocal_rhoDotFlux(1:ns,1:2,g,ip,el),2) &
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
+ sum(abs(constitutive_nonlocal_rhoDotFlux(1:ns,5:6,g,ip,el)),2)
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
cs = cs + ns
added output for dislocation evolution rate associated with flux: "rho_dot_flux"
2010-03-10 15:19:40 +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
case ('rho_dot_flux_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = sum(constitutive_nonlocal_rhoDotFlux(1:ns,3:4,g,ip,el),2) &
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
+ sum(abs(constitutive_nonlocal_rhoDotFlux(1:ns,7:8,g,ip,el)),2)
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
cs = cs + ns
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
case ('velocity_edge_pos')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = v(1:ns,1)
new output "dislocationvelocity"
2010-02-23 22:53:07 +05:30
cs = cs + ns
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
case ('velocity_edge_neg')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = v(1:ns,2)
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
cs = cs + ns
case ('velocity_screw_pos')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = v(1:ns,3)
new outputs "accumulatedshear", "velocity_edge", and "velocity_screw" (the latter two replace the output "dislocationvelocity")
2011-11-09 14:52:52 +05:30
cs = cs + ns
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
case ('velocity_screw_neg')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = v(1:ns,4)
dislocation velocity output for each dislocation type (edge+,edge-,screw+,screw-) for fcc constitutive_nonlocal_kinetics is called only once and the result is used for each dislocation type, for all other lattice structures we have one call for each dislocation type
2012-01-26 13:13:36 +05:30
cs = cs + ns
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
case ('fluxdensity_edge_pos_x')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,1) * v(1:ns,1) * m_currentconf(1,1:ns,1)
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
cs = cs + ns
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
case ('fluxdensity_edge_pos_y')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,1) * v(1:ns,1) * m_currentconf(2,1:ns,1)
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
cs = cs + ns
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
case ('fluxdensity_edge_pos_z')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,1) * v(1:ns,1) * m_currentconf(3,1:ns,1)
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
cs = cs + ns
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
case ('fluxdensity_edge_neg_x')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = - rhoSgl(1:ns,2) * v(1:ns,2) * m_currentconf(1,1:ns,1)
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
cs = cs + ns
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
case ('fluxdensity_edge_neg_y')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = - rhoSgl(1:ns,2) * v(1:ns,2) * m_currentconf(2,1:ns,1)
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
cs = cs + ns
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
case ('fluxdensity_edge_neg_z')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = - rhoSgl(1:ns,2) * v(1:ns,2) * m_currentconf(3,1:ns,1)
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
cs = cs + ns
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
case ('fluxdensity_screw_pos_x')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,3) * v(1:ns,3) * m_currentconf(1,1:ns,2)
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
cs = cs + ns
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
case ('fluxdensity_screw_pos_y')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,3) * v(1:ns,3) * m_currentconf(2,1:ns,2)
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
cs = cs + ns
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
case ('fluxdensity_screw_pos_z')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = rhoSgl(1:ns,3) * v(1:ns,3) * m_currentconf(3,1:ns,2)
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
cs = cs + ns
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
case ('fluxdensity_screw_neg_x')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = - rhoSgl(1:ns,4) * v(1:ns,4) * m_currentconf(1,1:ns,2)
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
cs = cs + ns
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
case ('fluxdensity_screw_neg_y')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = - rhoSgl(1:ns,4) * v(1:ns,4) * m_currentconf(2,1:ns,2)
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
cs = cs + ns
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
case ('fluxdensity_screw_neg_z')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = - rhoSgl(1:ns,4) * v(1:ns,4) * m_currentconf(3,1:ns,2)
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
cs = cs + ns
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
case ('maximumdipoleheight_edge')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = dUpper(1:ns,1)
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
cs = cs + ns
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
case ('maximumdipoleheight_screw')
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = dUpper(1:ns,2)
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
cs = cs + ns
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +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
case('dislocationstress')
sigma = constitutive_nonlocal_dislocationstress(state, Fe, g, ip, el)
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
constitutive_nonlocal_postResults(cs+1_pInt) = sigma(1,1)
constitutive_nonlocal_postResults(cs+2_pInt) = sigma(2,2)
constitutive_nonlocal_postResults(cs+3_pInt) = sigma(3,3)
constitutive_nonlocal_postResults(cs+4_pInt) = sigma(1,2)
constitutive_nonlocal_postResults(cs+5_pInt) = sigma(2,3)
constitutive_nonlocal_postResults(cs+6_pInt) = sigma(3,1)
* new output variable "internalstress", which gives the internal stress tensor * use "math_invert3x3" instead of "math_inv3x3" for inversion of Fe * for dislocation stress calculation: first regular case, then special case of dead dislocations in central ip * "dv_dtau" now given for each dislocation type, so is a (ns,4) array * deleted unused variables in "_LpAndItsTangent" * corrected contribution of deads in "_LpAndItsTangent" * the NaN variables defined in math did not give a proper NaN value, so use 0.0/0.0 again * neighbors with nonlocal constitution but local properties (i.e. /nonlocal/ flag not set) are also considered for incoming fluxes
2011-09-07 17:00:28 +05:30
cs = cs + 6_pInt
new outputs "accumulatedshear", "velocity_edge", and "velocity_screw" (the latter two replace the output "dislocationvelocity")
2011-11-09 14:52:52 +05:30
case('accumulatedshear')
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
constitutive_nonlocal_accumulatedShear(1:ns,g,ip,el) = constitutive_nonlocal_accumulatedShear(1:ns,g,ip,el) + sum(gdot,2)*dt
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
constitutive_nonlocal_postResults(cs+1_pInt:cs+ns) = constitutive_nonlocal_accumulatedShear(1:ns,g,ip,el)
new outputs "accumulatedshear", "velocity_edge", and "velocity_screw" (the latter two replace the output "dislocationvelocity")
2011-11-09 14:52:52 +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
end select
enddo
endfunction
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
END MODULE