Merge branch 'merge-crystallite-constitutive' into 'development'
Merge crystallite constitutive See merge request damask/DAMASK!307
This commit is contained in:
commit
10bbeb5617
|
@ -2,3 +2,4 @@
|
|||
path = PRIVATE
|
||||
url = ../PRIVATE.git
|
||||
branch = master
|
||||
shallow = true
|
||||
|
|
2
PRIVATE
2
PRIVATE
|
@ -1 +1 @@
|
|||
Subproject commit 313dd5de618c996cdf9ace95a096f25e757386d9
|
||||
Subproject commit 45ef93dbfa3e0e6fa830914b3632e188c308a099
|
|
@ -13,7 +13,6 @@ module CPFEM
|
|||
use discretization_marc
|
||||
use material
|
||||
use config
|
||||
use crystallite
|
||||
use homogenization
|
||||
use IO
|
||||
use discretization
|
||||
|
@ -262,6 +261,7 @@ end subroutine CPFEM_general
|
|||
subroutine CPFEM_forward
|
||||
|
||||
call crystallite_forward
|
||||
call constitutive_forward
|
||||
|
||||
end subroutine CPFEM_forward
|
||||
|
||||
|
|
|
@ -21,7 +21,6 @@ module CPFEM2
|
|||
use HDF5_utilities
|
||||
use homogenization
|
||||
use constitutive
|
||||
use crystallite
|
||||
#if defined(Mesh)
|
||||
use FEM_quadrature
|
||||
use discretization_mesh
|
||||
|
@ -99,6 +98,7 @@ end subroutine CPFEM_restartWrite
|
|||
subroutine CPFEM_forward
|
||||
|
||||
call crystallite_forward
|
||||
call constitutive_forward
|
||||
|
||||
end subroutine CPFEM_forward
|
||||
|
||||
|
|
|
@ -44,12 +44,9 @@
|
|||
#include "source_damage_anisoDuctile.f90"
|
||||
#include "kinematics_cleavage_opening.f90"
|
||||
#include "kinematics_slipplane_opening.f90"
|
||||
#include "crystallite.f90"
|
||||
#include "thermal_isothermal.f90"
|
||||
#include "thermal_adiabatic.f90"
|
||||
#include "thermal_conduction.f90"
|
||||
#include "damage_none.f90"
|
||||
#include "damage_local.f90"
|
||||
#include "damage_nonlocal.f90"
|
||||
#include "homogenization.f90"
|
||||
#include "homogenization_mech.f90"
|
||||
|
|
1407
src/constitutive.f90
1407
src/constitutive.f90
File diff suppressed because it is too large
Load Diff
|
@ -133,6 +133,67 @@ submodule(constitutive) constitutive_mech
|
|||
el !< current element number
|
||||
end subroutine plastic_nonlocal_LpAndItsTangent
|
||||
|
||||
module subroutine plastic_isotropic_dotState(Mp,instance,of)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< Mandel stress
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of
|
||||
end subroutine plastic_isotropic_dotState
|
||||
|
||||
module subroutine plastic_phenopowerlaw_dotState(Mp,instance,of)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< Mandel stress
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of
|
||||
end subroutine plastic_phenopowerlaw_dotState
|
||||
|
||||
module subroutine plastic_kinehardening_dotState(Mp,instance,of)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< Mandel stress
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of
|
||||
end subroutine plastic_kinehardening_dotState
|
||||
|
||||
module subroutine plastic_dislotwin_dotState(Mp,T,instance,of)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< Mandel stress
|
||||
real(pReal), intent(in) :: &
|
||||
T
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of
|
||||
end subroutine plastic_dislotwin_dotState
|
||||
|
||||
module subroutine plastic_disloTungsten_dotState(Mp,T,instance,of)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< Mandel stress
|
||||
real(pReal), intent(in) :: &
|
||||
T
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of
|
||||
end subroutine plastic_disloTungsten_dotState
|
||||
|
||||
module subroutine plastic_nonlocal_dotState(Mp, F, Fp, Temperature,timestep, &
|
||||
instance,of,ip,el)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< MandelStress
|
||||
real(pReal), dimension(3,3,homogenization_maxNconstituents,discretization_nIPs,discretization_Nelems), intent(in) :: &
|
||||
F, & !< deformation gradient
|
||||
Fp !< plastic deformation gradient
|
||||
real(pReal), intent(in) :: &
|
||||
Temperature, & !< temperature
|
||||
timestep !< substepped crystallite time increment
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of, &
|
||||
ip, & !< current integration point
|
||||
el !< current element number
|
||||
end subroutine plastic_nonlocal_dotState
|
||||
|
||||
|
||||
module subroutine plastic_dislotwin_dependentState(T,instance,of)
|
||||
integer, intent(in) :: &
|
||||
|
@ -159,6 +220,24 @@ submodule(constitutive) constitutive_mech
|
|||
el !< current element number
|
||||
end subroutine plastic_nonlocal_dependentState
|
||||
|
||||
module subroutine plastic_kinehardening_deltaState(Mp,instance,of)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp !< Mandel stress
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of
|
||||
end subroutine plastic_kinehardening_deltaState
|
||||
|
||||
module subroutine plastic_nonlocal_deltaState(Mp,instance,of,ip,el)
|
||||
real(pReal), dimension(3,3), intent(in) :: &
|
||||
Mp
|
||||
integer, intent(in) :: &
|
||||
instance, &
|
||||
of, &
|
||||
ip, &
|
||||
el
|
||||
end subroutine plastic_nonlocal_deltaState
|
||||
|
||||
module subroutine plastic_isotropic_results(instance,group)
|
||||
integer, intent(in) :: instance
|
||||
character(len=*), intent(in) :: group
|
||||
|
@ -454,6 +533,124 @@ module subroutine constitutive_plastic_LpAndItsTangents(Lp, dLp_dS, dLp_dFi, &
|
|||
end subroutine constitutive_plastic_LpAndItsTangents
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief contains the constitutive equation for calculating the rate of change of microstructure
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module function constitutive_collectDotState(S, FArray, Fi, FpArray, subdt, ipc, ip, el,phase,of) result(broken)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ipc, & !< component-ID of integration point
|
||||
ip, & !< integration point
|
||||
el, & !< element
|
||||
phase, &
|
||||
of
|
||||
real(pReal), intent(in) :: &
|
||||
subdt !< timestep
|
||||
real(pReal), intent(in), dimension(3,3,homogenization_maxNconstituents,discretization_nIPs,discretization_Nelems) :: &
|
||||
FArray, & !< elastic deformation gradient
|
||||
FpArray !< plastic deformation gradient
|
||||
real(pReal), intent(in), dimension(3,3) :: &
|
||||
Fi !< intermediate deformation gradient
|
||||
real(pReal), intent(in), dimension(3,3) :: &
|
||||
S !< 2nd Piola Kirchhoff stress (vector notation)
|
||||
real(pReal), dimension(3,3) :: &
|
||||
Mp
|
||||
integer :: &
|
||||
ho, & !< homogenization
|
||||
tme, & !< thermal member position
|
||||
i, & !< counter in source loop
|
||||
instance
|
||||
logical :: broken
|
||||
|
||||
ho = material_homogenizationAt(el)
|
||||
tme = material_homogenizationMemberAt(ip,el)
|
||||
instance = phase_plasticityInstance(phase)
|
||||
|
||||
Mp = matmul(matmul(transpose(Fi),Fi),S)
|
||||
|
||||
plasticityType: select case (phase_plasticity(phase))
|
||||
|
||||
case (PLASTICITY_ISOTROPIC_ID) plasticityType
|
||||
call plastic_isotropic_dotState(Mp,instance,of)
|
||||
|
||||
case (PLASTICITY_PHENOPOWERLAW_ID) plasticityType
|
||||
call plastic_phenopowerlaw_dotState(Mp,instance,of)
|
||||
|
||||
case (PLASTICITY_KINEHARDENING_ID) plasticityType
|
||||
call plastic_kinehardening_dotState(Mp,instance,of)
|
||||
|
||||
case (PLASTICITY_DISLOTWIN_ID) plasticityType
|
||||
call plastic_dislotwin_dotState(Mp,temperature(ho)%p(tme),instance,of)
|
||||
|
||||
case (PLASTICITY_DISLOTUNGSTEN_ID) plasticityType
|
||||
call plastic_disloTungsten_dotState(Mp,temperature(ho)%p(tme),instance,of)
|
||||
|
||||
case (PLASTICITY_NONLOCAL_ID) plasticityType
|
||||
call plastic_nonlocal_dotState(Mp,FArray,FpArray,temperature(ho)%p(tme),subdt, &
|
||||
instance,of,ip,el)
|
||||
end select plasticityType
|
||||
broken = any(IEEE_is_NaN(plasticState(phase)%dotState(:,of)))
|
||||
|
||||
|
||||
end function constitutive_collectDotState
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief for constitutive models having an instantaneous change of state
|
||||
!> will return false if delta state is not needed/supported by the constitutive model
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module function constitutive_deltaState(S, Fi, ipc, ip, el, phase, of) result(broken)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ipc, & !< component-ID of integration point
|
||||
ip, & !< integration point
|
||||
el, & !< element
|
||||
phase, &
|
||||
of
|
||||
real(pReal), intent(in), dimension(3,3) :: &
|
||||
S, & !< 2nd Piola Kirchhoff stress
|
||||
Fi !< intermediate deformation gradient
|
||||
real(pReal), dimension(3,3) :: &
|
||||
Mp
|
||||
integer :: &
|
||||
instance, &
|
||||
myOffset, &
|
||||
mySize
|
||||
logical :: &
|
||||
broken
|
||||
|
||||
Mp = matmul(matmul(transpose(Fi),Fi),S)
|
||||
instance = phase_plasticityInstance(phase)
|
||||
|
||||
plasticityType: select case (phase_plasticity(phase))
|
||||
|
||||
case (PLASTICITY_KINEHARDENING_ID) plasticityType
|
||||
call plastic_kinehardening_deltaState(Mp,instance,of)
|
||||
broken = any(IEEE_is_NaN(plasticState(phase)%deltaState(:,of)))
|
||||
|
||||
case (PLASTICITY_NONLOCAL_ID) plasticityType
|
||||
call plastic_nonlocal_deltaState(Mp,instance,of,ip,el)
|
||||
broken = any(IEEE_is_NaN(plasticState(phase)%deltaState(:,of)))
|
||||
|
||||
case default
|
||||
broken = .false.
|
||||
|
||||
end select plasticityType
|
||||
|
||||
if(.not. broken) then
|
||||
select case(phase_plasticity(phase))
|
||||
case (PLASTICITY_NONLOCAL_ID,PLASTICITY_KINEHARDENING_ID)
|
||||
|
||||
myOffset = plasticState(phase)%offsetDeltaState
|
||||
mySize = plasticState(phase)%sizeDeltaState
|
||||
plasticState(phase)%state(myOffset + 1:myOffset + mySize,of) = &
|
||||
plasticState(phase)%state(myOffset + 1:myOffset + mySize,of) + plasticState(phase)%deltaState(1:mySize,of)
|
||||
end select
|
||||
endif
|
||||
|
||||
end function constitutive_deltaState
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------
|
||||
!> @brief writes plasticity constitutive results to HDF5 output file
|
||||
!--------------------------------------------------------------------------------------------
|
||||
|
@ -494,5 +691,581 @@ module subroutine plastic_results
|
|||
|
||||
end subroutine plastic_results
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief calculation of stress (P) with time integration based on a residuum in Lp and
|
||||
!> intermediate acceleration of the Newton-Raphson correction
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
function integrateStress(ipc,ip,el,timeFraction) result(broken)
|
||||
|
||||
integer, intent(in):: el, & ! element index
|
||||
ip, & ! integration point index
|
||||
ipc ! grain index
|
||||
real(pReal), optional, intent(in) :: timeFraction ! fraction of timestep
|
||||
|
||||
real(pReal), dimension(3,3):: F, & ! deformation gradient at end of timestep
|
||||
Fp_new, & ! plastic deformation gradient at end of timestep
|
||||
invFp_new, & ! inverse of Fp_new
|
||||
invFp_current, & ! inverse of Fp_current
|
||||
Lpguess, & ! current guess for plastic velocity gradient
|
||||
Lpguess_old, & ! known last good guess for plastic velocity gradient
|
||||
Lp_constitutive, & ! plastic velocity gradient resulting from constitutive law
|
||||
residuumLp, & ! current residuum of plastic velocity gradient
|
||||
residuumLp_old, & ! last residuum of plastic velocity gradient
|
||||
deltaLp, & ! direction of next guess
|
||||
Fi_new, & ! gradient of intermediate deformation stages
|
||||
invFi_new, &
|
||||
invFi_current, & ! inverse of Fi_current
|
||||
Liguess, & ! current guess for intermediate velocity gradient
|
||||
Liguess_old, & ! known last good guess for intermediate velocity gradient
|
||||
Li_constitutive, & ! intermediate velocity gradient resulting from constitutive law
|
||||
residuumLi, & ! current residuum of intermediate velocity gradient
|
||||
residuumLi_old, & ! last residuum of intermediate velocity gradient
|
||||
deltaLi, & ! direction of next guess
|
||||
Fe, & ! elastic deformation gradient
|
||||
S, & ! 2nd Piola-Kirchhoff Stress in plastic (lattice) configuration
|
||||
A, &
|
||||
B, &
|
||||
temp_33
|
||||
real(pReal), dimension(9) :: temp_9 ! needed for matrix inversion by LAPACK
|
||||
integer, dimension(9) :: devNull_9 ! needed for matrix inversion by LAPACK
|
||||
real(pReal), dimension(9,9) :: dRLp_dLp, & ! partial derivative of residuum (Jacobian for Newton-Raphson scheme)
|
||||
dRLi_dLi ! partial derivative of residuumI (Jacobian for Newton-Raphson scheme)
|
||||
real(pReal), dimension(3,3,3,3):: dS_dFe, & ! partial derivative of 2nd Piola-Kirchhoff stress
|
||||
dS_dFi, &
|
||||
dFe_dLp, & ! partial derivative of elastic deformation gradient
|
||||
dFe_dLi, &
|
||||
dFi_dLi, &
|
||||
dLp_dFi, &
|
||||
dLi_dFi, &
|
||||
dLp_dS, &
|
||||
dLi_dS
|
||||
real(pReal) steplengthLp, &
|
||||
steplengthLi, &
|
||||
dt, & ! time increment
|
||||
atol_Lp, &
|
||||
atol_Li, &
|
||||
devNull
|
||||
integer NiterationStressLp, & ! number of stress integrations
|
||||
NiterationStressLi, & ! number of inner stress integrations
|
||||
ierr, & ! error indicator for LAPACK
|
||||
o, &
|
||||
p, &
|
||||
m, &
|
||||
jacoCounterLp, &
|
||||
jacoCounterLi ! counters to check for Jacobian update
|
||||
logical :: error,broken
|
||||
|
||||
broken = .true.
|
||||
|
||||
if (present(timeFraction)) then
|
||||
dt = crystallite_subdt(ipc,ip,el) * timeFraction
|
||||
F = crystallite_subF0(1:3,1:3,ipc,ip,el) &
|
||||
+ (crystallite_subF(1:3,1:3,ipc,ip,el) - crystallite_subF0(1:3,1:3,ipc,ip,el)) * timeFraction
|
||||
else
|
||||
dt = crystallite_subdt(ipc,ip,el)
|
||||
F = crystallite_subF(1:3,1:3,ipc,ip,el)
|
||||
endif
|
||||
|
||||
call constitutive_plastic_dependentState(crystallite_partitionedF(1:3,1:3,ipc,ip,el), &
|
||||
crystallite_Fp(1:3,1:3,ipc,ip,el),ipc,ip,el)
|
||||
|
||||
p = material_phaseAt(ipc,el)
|
||||
m = material_phaseMemberAt(ipc,ip,el)
|
||||
|
||||
Lpguess = crystallite_Lp(1:3,1:3,ipc,ip,el) ! take as first guess
|
||||
Liguess = constitutive_mech_Li(p)%data(1:3,1:3,m) ! take as first guess
|
||||
|
||||
call math_invert33(invFp_current,devNull,error,crystallite_subFp0(1:3,1:3,ipc,ip,el))
|
||||
if (error) return ! error
|
||||
call math_invert33(invFi_current,devNull,error,crystallite_subFi0(1:3,1:3,ipc,ip,el))
|
||||
if (error) return ! error
|
||||
|
||||
A = matmul(F,invFp_current) ! intermediate tensor needed later to calculate dFe_dLp
|
||||
|
||||
jacoCounterLi = 0
|
||||
steplengthLi = 1.0_pReal
|
||||
residuumLi_old = 0.0_pReal
|
||||
Liguess_old = Liguess
|
||||
|
||||
NiterationStressLi = 0
|
||||
LiLoop: do
|
||||
NiterationStressLi = NiterationStressLi + 1
|
||||
if (NiterationStressLi>num%nStress) return ! error
|
||||
|
||||
invFi_new = matmul(invFi_current,math_I3 - dt*Liguess)
|
||||
Fi_new = math_inv33(invFi_new)
|
||||
|
||||
jacoCounterLp = 0
|
||||
steplengthLp = 1.0_pReal
|
||||
residuumLp_old = 0.0_pReal
|
||||
Lpguess_old = Lpguess
|
||||
|
||||
NiterationStressLp = 0
|
||||
LpLoop: do
|
||||
NiterationStressLp = NiterationStressLp + 1
|
||||
if (NiterationStressLp>num%nStress) return ! error
|
||||
|
||||
B = math_I3 - dt*Lpguess
|
||||
Fe = matmul(matmul(A,B), invFi_new)
|
||||
call constitutive_hooke_SandItsTangents(S, dS_dFe, dS_dFi, &
|
||||
Fe, Fi_new, ipc, ip, el)
|
||||
|
||||
call constitutive_plastic_LpAndItsTangents(Lp_constitutive, dLp_dS, dLp_dFi, &
|
||||
S, Fi_new, ipc, ip, el)
|
||||
|
||||
!* update current residuum and check for convergence of loop
|
||||
atol_Lp = max(num%rtol_crystalliteStress * max(norm2(Lpguess),norm2(Lp_constitutive)), & ! absolute tolerance from largest acceptable relative error
|
||||
num%atol_crystalliteStress) ! minimum lower cutoff
|
||||
residuumLp = Lpguess - Lp_constitutive
|
||||
|
||||
if (any(IEEE_is_NaN(residuumLp))) then
|
||||
return ! error
|
||||
elseif (norm2(residuumLp) < atol_Lp) then ! converged if below absolute tolerance
|
||||
exit LpLoop
|
||||
elseif (NiterationStressLp == 1 .or. norm2(residuumLp) < norm2(residuumLp_old)) then ! not converged, but improved norm of residuum (always proceed in first iteration)...
|
||||
residuumLp_old = residuumLp ! ...remember old values and...
|
||||
Lpguess_old = Lpguess
|
||||
steplengthLp = 1.0_pReal ! ...proceed with normal step length (calculate new search direction)
|
||||
else ! not converged and residuum not improved...
|
||||
steplengthLp = num%subStepSizeLp * steplengthLp ! ...try with smaller step length in same direction
|
||||
Lpguess = Lpguess_old &
|
||||
+ deltaLp * stepLengthLp
|
||||
cycle LpLoop
|
||||
endif
|
||||
|
||||
calculateJacobiLi: if (mod(jacoCounterLp, num%iJacoLpresiduum) == 0) then
|
||||
jacoCounterLp = jacoCounterLp + 1
|
||||
|
||||
do o=1,3; do p=1,3
|
||||
dFe_dLp(o,1:3,p,1:3) = - dt * A(o,p)*transpose(invFi_new) ! dFe_dLp(i,j,k,l) = -dt * A(i,k) invFi(l,j)
|
||||
enddo; enddo
|
||||
dRLp_dLp = math_eye(9) &
|
||||
- math_3333to99(math_mul3333xx3333(math_mul3333xx3333(dLp_dS,dS_dFe),dFe_dLp))
|
||||
temp_9 = math_33to9(residuumLp)
|
||||
call dgesv(9,1,dRLp_dLp,9,devNull_9,temp_9,9,ierr) ! solve dRLp/dLp * delta Lp = -res for delta Lp
|
||||
if (ierr /= 0) return ! error
|
||||
deltaLp = - math_9to33(temp_9)
|
||||
endif calculateJacobiLi
|
||||
|
||||
Lpguess = Lpguess &
|
||||
+ deltaLp * steplengthLp
|
||||
enddo LpLoop
|
||||
|
||||
call constitutive_LiAndItsTangents(Li_constitutive, dLi_dS, dLi_dFi, &
|
||||
S, Fi_new, ipc, ip, el)
|
||||
|
||||
!* update current residuum and check for convergence of loop
|
||||
atol_Li = max(num%rtol_crystalliteStress * max(norm2(Liguess),norm2(Li_constitutive)), & ! absolute tolerance from largest acceptable relative error
|
||||
num%atol_crystalliteStress) ! minimum lower cutoff
|
||||
residuumLi = Liguess - Li_constitutive
|
||||
if (any(IEEE_is_NaN(residuumLi))) then
|
||||
return ! error
|
||||
elseif (norm2(residuumLi) < atol_Li) then ! converged if below absolute tolerance
|
||||
exit LiLoop
|
||||
elseif (NiterationStressLi == 1 .or. norm2(residuumLi) < norm2(residuumLi_old)) then ! not converged, but improved norm of residuum (always proceed in first iteration)...
|
||||
residuumLi_old = residuumLi ! ...remember old values and...
|
||||
Liguess_old = Liguess
|
||||
steplengthLi = 1.0_pReal ! ...proceed with normal step length (calculate new search direction)
|
||||
else ! not converged and residuum not improved...
|
||||
steplengthLi = num%subStepSizeLi * steplengthLi ! ...try with smaller step length in same direction
|
||||
Liguess = Liguess_old &
|
||||
+ deltaLi * steplengthLi
|
||||
cycle LiLoop
|
||||
endif
|
||||
|
||||
calculateJacobiLp: if (mod(jacoCounterLi, num%iJacoLpresiduum) == 0) then
|
||||
jacoCounterLi = jacoCounterLi + 1
|
||||
|
||||
temp_33 = matmul(matmul(A,B),invFi_current)
|
||||
do o=1,3; do p=1,3
|
||||
dFe_dLi(1:3,o,1:3,p) = -dt*math_I3(o,p)*temp_33 ! dFe_dLp(i,j,k,l) = -dt * A(i,k) invFi(l,j)
|
||||
dFi_dLi(1:3,o,1:3,p) = -dt*math_I3(o,p)*invFi_current
|
||||
enddo; enddo
|
||||
do o=1,3; do p=1,3
|
||||
dFi_dLi(1:3,1:3,o,p) = matmul(matmul(Fi_new,dFi_dLi(1:3,1:3,o,p)),Fi_new)
|
||||
enddo; enddo
|
||||
dRLi_dLi = math_eye(9) &
|
||||
- math_3333to99(math_mul3333xx3333(dLi_dS, math_mul3333xx3333(dS_dFe, dFe_dLi) &
|
||||
+ math_mul3333xx3333(dS_dFi, dFi_dLi))) &
|
||||
- math_3333to99(math_mul3333xx3333(dLi_dFi, dFi_dLi))
|
||||
temp_9 = math_33to9(residuumLi)
|
||||
call dgesv(9,1,dRLi_dLi,9,devNull_9,temp_9,9,ierr) ! solve dRLi/dLp * delta Li = -res for delta Li
|
||||
if (ierr /= 0) return ! error
|
||||
deltaLi = - math_9to33(temp_9)
|
||||
endif calculateJacobiLp
|
||||
|
||||
Liguess = Liguess &
|
||||
+ deltaLi * steplengthLi
|
||||
enddo LiLoop
|
||||
|
||||
invFp_new = matmul(invFp_current,B)
|
||||
call math_invert33(Fp_new,devNull,error,invFp_new)
|
||||
if (error) return ! error
|
||||
|
||||
p = material_phaseAt(ipc,el)
|
||||
m = material_phaseMemberAt(ipc,ip,el)
|
||||
|
||||
crystallite_P (1:3,1:3,ipc,ip,el) = matmul(matmul(F,invFp_new),matmul(S,transpose(invFp_new)))
|
||||
crystallite_S (1:3,1:3,ipc,ip,el) = S
|
||||
crystallite_Lp (1:3,1:3,ipc,ip,el) = Lpguess
|
||||
constitutive_mech_Li(p)%data(1:3,1:3,m) = Liguess
|
||||
crystallite_Fp (1:3,1:3,ipc,ip,el) = Fp_new / math_det33(Fp_new)**(1.0_pReal/3.0_pReal) ! regularize
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,m) = Fi_new
|
||||
crystallite_Fe (1:3,1:3,ipc,ip,el) = matmul(matmul(F,invFp_new),invFi_new)
|
||||
broken = .false.
|
||||
|
||||
end function integrateStress
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief integrate stress, state with adaptive 1st order explicit Euler method
|
||||
!> using Fixed Point Iteration to adapt the stepsize
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module subroutine integrateStateFPI(g,i,e)
|
||||
|
||||
integer, intent(in) :: &
|
||||
e, & !< element index in element loop
|
||||
i, & !< integration point index in ip loop
|
||||
g !< grain index in grain loop
|
||||
integer :: &
|
||||
NiterationState, & !< number of iterations in state loop
|
||||
p, &
|
||||
c, &
|
||||
s, &
|
||||
size_pl
|
||||
integer, dimension(maxval(phase_Nsources)) :: &
|
||||
size_so
|
||||
real(pReal) :: &
|
||||
zeta
|
||||
real(pReal), dimension(max(constitutive_plasticity_maxSizeDotState,constitutive_source_maxSizeDotState)) :: &
|
||||
r ! state residuum
|
||||
real(pReal), dimension(constitutive_plasticity_maxSizeDotState,2) :: &
|
||||
plastic_dotState
|
||||
real(pReal), dimension(constitutive_source_maxSizeDotState,2,maxval(phase_Nsources)) :: source_dotState
|
||||
logical :: &
|
||||
broken
|
||||
|
||||
p = material_phaseAt(g,e)
|
||||
c = material_phaseMemberAt(g,i,e)
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e), g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
size_pl = plasticState(p)%sizeDotState
|
||||
plasticState(p)%state(1:size_pl,c) = plasticState(p)%subState0(1:size_pl,c) &
|
||||
+ plasticState(p)%dotState (1:size_pl,c) &
|
||||
* crystallite_subdt(g,i,e)
|
||||
plastic_dotState(1:size_pl,2) = 0.0_pReal
|
||||
|
||||
iteration: do NiterationState = 1, num%nState
|
||||
|
||||
if(nIterationState > 1) plastic_dotState(1:size_pl,2) = plastic_dotState(1:size_pl,1)
|
||||
plastic_dotState(1:size_pl,1) = plasticState(p)%dotState(:,c)
|
||||
|
||||
broken = integrateStress(g,i,e)
|
||||
if(broken) exit iteration
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e), g,i,e,p,c)
|
||||
if(broken) exit iteration
|
||||
|
||||
zeta = damper(plasticState(p)%dotState(:,c),plastic_dotState(1:size_pl,1),&
|
||||
plastic_dotState(1:size_pl,2))
|
||||
plasticState(p)%dotState(:,c) = plasticState(p)%dotState(:,c) * zeta &
|
||||
+ plastic_dotState(1:size_pl,1) * (1.0_pReal - zeta)
|
||||
r(1:size_pl) = plasticState(p)%state (1:size_pl,c) &
|
||||
- plasticState(p)%subState0(1:size_pl,c) &
|
||||
- plasticState(p)%dotState (1:size_pl,c) * crystallite_subdt(g,i,e)
|
||||
plasticState(p)%state(1:size_pl,c) = plasticState(p)%state(1:size_pl,c) &
|
||||
- r(1:size_pl)
|
||||
crystallite_converged(g,i,e) = converged(r(1:size_pl), &
|
||||
plasticState(p)%state(1:size_pl,c), &
|
||||
plasticState(p)%atol(1:size_pl))
|
||||
|
||||
if(crystallite_converged(g,i,e)) then
|
||||
broken = constitutive_deltaState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c),g,i,e,p,c)
|
||||
exit iteration
|
||||
endif
|
||||
|
||||
enddo iteration
|
||||
|
||||
|
||||
contains
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief calculate the damping for correction of state and dot state
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
real(pReal) pure function damper(current,previous,previous2)
|
||||
|
||||
real(pReal), dimension(:), intent(in) ::&
|
||||
current, previous, previous2
|
||||
|
||||
real(pReal) :: dot_prod12, dot_prod22
|
||||
|
||||
dot_prod12 = dot_product(current - previous, previous - previous2)
|
||||
dot_prod22 = dot_product(previous - previous2, previous - previous2)
|
||||
if ((dot_product(current,previous) < 0.0_pReal .or. dot_prod12 < 0.0_pReal) .and. dot_prod22 > 0.0_pReal) then
|
||||
damper = 0.75_pReal + 0.25_pReal * tanh(2.0_pReal + 4.0_pReal * dot_prod12 / dot_prod22)
|
||||
else
|
||||
damper = 1.0_pReal
|
||||
endif
|
||||
|
||||
end function damper
|
||||
|
||||
end subroutine integrateStateFPI
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief integrate state with 1st order explicit Euler method
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module subroutine integrateStateEuler(g,i,e)
|
||||
|
||||
integer, intent(in) :: &
|
||||
e, & !< element index in element loop
|
||||
i, & !< integration point index in ip loop
|
||||
g !< grain index in grain loop
|
||||
integer :: &
|
||||
p, &
|
||||
c, &
|
||||
sizeDotState
|
||||
logical :: &
|
||||
broken
|
||||
|
||||
p = material_phaseAt(g,e)
|
||||
c = material_phaseMemberAt(g,i,e)
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e), g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
plasticState(p)%state(1:sizeDotState,c) = plasticState(p)%subState0(1:sizeDotState,c) &
|
||||
+ plasticState(p)%dotState (1:sizeDotState,c) &
|
||||
* crystallite_subdt(g,i,e)
|
||||
|
||||
broken = constitutive_deltaState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c),g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
broken = integrateStress(g,i,e)
|
||||
crystallite_converged(g,i,e) = .not. broken
|
||||
|
||||
end subroutine integrateStateEuler
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief integrate stress, state with 1st order Euler method with adaptive step size
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module subroutine integrateStateAdaptiveEuler(g,i,e)
|
||||
|
||||
integer, intent(in) :: &
|
||||
e, & !< element index in element loop
|
||||
i, & !< integration point index in ip loop
|
||||
g !< grain index in grain loop
|
||||
integer :: &
|
||||
p, &
|
||||
c, &
|
||||
sizeDotState
|
||||
logical :: &
|
||||
broken
|
||||
|
||||
real(pReal), dimension(constitutive_plasticity_maxSizeDotState) :: residuum_plastic
|
||||
|
||||
|
||||
p = material_phaseAt(g,e)
|
||||
c = material_phaseMemberAt(g,i,e)
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e), g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
|
||||
residuum_plastic(1:sizeDotState) = - plasticState(p)%dotstate(1:sizeDotState,c) * 0.5_pReal * crystallite_subdt(g,i,e)
|
||||
plasticState(p)%state(1:sizeDotState,c) = plasticState(p)%subState0(1:sizeDotState,c) &
|
||||
+ plasticState(p)%dotstate(1:sizeDotState,c) * crystallite_subdt(g,i,e)
|
||||
|
||||
broken = constitutive_deltaState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c),g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
broken = integrateStress(g,i,e)
|
||||
if(broken) return
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e), g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
crystallite_converged(g,i,e) = converged(residuum_plastic(1:sizeDotState) &
|
||||
+ 0.5_pReal * plasticState(p)%dotState(:,c) * crystallite_subdt(g,i,e), &
|
||||
plasticState(p)%state(1:sizeDotState,c), &
|
||||
plasticState(p)%atol(1:sizeDotState))
|
||||
|
||||
end subroutine integrateStateAdaptiveEuler
|
||||
|
||||
|
||||
!---------------------------------------------------------------------------------------------------
|
||||
!> @brief Integrate state (including stress integration) with the classic Runge Kutta method
|
||||
!---------------------------------------------------------------------------------------------------
|
||||
module subroutine integrateStateRK4(g,i,e)
|
||||
|
||||
integer, intent(in) :: g,i,e
|
||||
|
||||
real(pReal), dimension(3,3), parameter :: &
|
||||
A = reshape([&
|
||||
0.5_pReal, 0.0_pReal, 0.0_pReal, &
|
||||
0.0_pReal, 0.5_pReal, 0.0_pReal, &
|
||||
0.0_pReal, 0.0_pReal, 1.0_pReal],&
|
||||
shape(A))
|
||||
real(pReal), dimension(3), parameter :: &
|
||||
C = [0.5_pReal, 0.5_pReal, 1.0_pReal]
|
||||
real(pReal), dimension(4), parameter :: &
|
||||
B = [1.0_pReal/6.0_pReal, 1.0_pReal/3.0_pReal, 1.0_pReal/3.0_pReal, 1.0_pReal/6.0_pReal]
|
||||
|
||||
call integrateStateRK(g,i,e,A,B,C)
|
||||
|
||||
end subroutine integrateStateRK4
|
||||
|
||||
|
||||
!---------------------------------------------------------------------------------------------------
|
||||
!> @brief Integrate state (including stress integration) with the Cash-Carp method
|
||||
!---------------------------------------------------------------------------------------------------
|
||||
module subroutine integrateStateRKCK45(g,i,e)
|
||||
|
||||
integer, intent(in) :: g,i,e
|
||||
|
||||
real(pReal), dimension(5,5), parameter :: &
|
||||
A = reshape([&
|
||||
1._pReal/5._pReal, .0_pReal, .0_pReal, .0_pReal, .0_pReal, &
|
||||
3._pReal/40._pReal, 9._pReal/40._pReal, .0_pReal, .0_pReal, .0_pReal, &
|
||||
3_pReal/10._pReal, -9._pReal/10._pReal, 6._pReal/5._pReal, .0_pReal, .0_pReal, &
|
||||
-11._pReal/54._pReal, 5._pReal/2._pReal, -70.0_pReal/27.0_pReal, 35.0_pReal/27.0_pReal, .0_pReal, &
|
||||
1631._pReal/55296._pReal,175._pReal/512._pReal,575._pReal/13824._pReal,44275._pReal/110592._pReal,253._pReal/4096._pReal],&
|
||||
shape(A))
|
||||
real(pReal), dimension(5), parameter :: &
|
||||
C = [0.2_pReal, 0.3_pReal, 0.6_pReal, 1.0_pReal, 0.875_pReal]
|
||||
real(pReal), dimension(6), parameter :: &
|
||||
B = &
|
||||
[37.0_pReal/378.0_pReal, .0_pReal, 250.0_pReal/621.0_pReal, &
|
||||
125.0_pReal/594.0_pReal, .0_pReal, 512.0_pReal/1771.0_pReal], &
|
||||
DB = B - &
|
||||
[2825.0_pReal/27648.0_pReal, .0_pReal, 18575.0_pReal/48384.0_pReal,&
|
||||
13525.0_pReal/55296.0_pReal, 277.0_pReal/14336.0_pReal, 1._pReal/4._pReal]
|
||||
|
||||
call integrateStateRK(g,i,e,A,B,C,DB)
|
||||
|
||||
end subroutine integrateStateRKCK45
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief Integrate state (including stress integration) with an explicit Runge-Kutta method or an
|
||||
!! embedded explicit Runge-Kutta method
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine integrateStateRK(g,i,e,A,B,CC,DB)
|
||||
|
||||
|
||||
real(pReal), dimension(:,:), intent(in) :: A
|
||||
real(pReal), dimension(:), intent(in) :: B, CC
|
||||
real(pReal), dimension(:), intent(in), optional :: DB
|
||||
|
||||
integer, intent(in) :: &
|
||||
e, & !< element index in element loop
|
||||
i, & !< integration point index in ip loop
|
||||
g !< grain index in grain loop
|
||||
integer :: &
|
||||
stage, & ! stage index in integration stage loop
|
||||
n, &
|
||||
p, &
|
||||
c, &
|
||||
sizeDotState
|
||||
logical :: &
|
||||
broken
|
||||
real(pReal), dimension(constitutive_plasticity_maxSizeDotState,size(B)) :: plastic_RKdotState
|
||||
|
||||
p = material_phaseAt(g,e)
|
||||
c = material_phaseMemberAt(g,i,e)
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e), g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
do stage = 1,size(A,1)
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
plastic_RKdotState(1:sizeDotState,stage) = plasticState(p)%dotState(:,c)
|
||||
plasticState(p)%dotState(:,c) = A(1,stage) * plastic_RKdotState(1:sizeDotState,1)
|
||||
|
||||
do n = 2, stage
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
plasticState(p)%dotState(:,c) = plasticState(p)%dotState(:,c) &
|
||||
+ A(n,stage) * plastic_RKdotState(1:sizeDotState,n)
|
||||
enddo
|
||||
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
plasticState(p)%state(1:sizeDotState,c) = plasticState(p)%subState0(1:sizeDotState,c) &
|
||||
+ plasticState(p)%dotState (1:sizeDotState,c) &
|
||||
* crystallite_subdt(g,i,e)
|
||||
|
||||
broken = integrateStress(g,i,e,CC(stage))
|
||||
if(broken) exit
|
||||
|
||||
broken = constitutive_collectDotState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
crystallite_partitionedF0, &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c), &
|
||||
crystallite_partitionedFp0, &
|
||||
crystallite_subdt(g,i,e)*CC(stage), g,i,e,p,c)
|
||||
if(broken) exit
|
||||
|
||||
enddo
|
||||
if(broken) return
|
||||
|
||||
sizeDotState = plasticState(p)%sizeDotState
|
||||
|
||||
plastic_RKdotState(1:sizeDotState,size(B)) = plasticState (p)%dotState(:,c)
|
||||
plasticState(p)%dotState(:,c) = matmul(plastic_RKdotState(1:sizeDotState,1:size(B)),B)
|
||||
plasticState(p)%state(1:sizeDotState,c) = plasticState(p)%subState0(1:sizeDotState,c) &
|
||||
+ plasticState(p)%dotState (1:sizeDotState,c) &
|
||||
* crystallite_subdt(g,i,e)
|
||||
if(present(DB)) &
|
||||
broken = .not. converged( matmul(plastic_RKdotState(1:sizeDotState,1:size(DB)),DB) &
|
||||
* crystallite_subdt(g,i,e), &
|
||||
plasticState(p)%state(1:sizeDotState,c), &
|
||||
plasticState(p)%atol(1:sizeDotState))
|
||||
|
||||
if(broken) return
|
||||
|
||||
broken = constitutive_deltaState(crystallite_S(1:3,1:3,g,i,e), &
|
||||
constitutive_mech_Fi(p)%data(1:3,1:3,c),g,i,e,p,c)
|
||||
if(broken) return
|
||||
|
||||
broken = integrateStress(g,i,e)
|
||||
crystallite_converged(g,i,e) = .not. broken
|
||||
|
||||
|
||||
end subroutine integrateStateRK
|
||||
|
||||
|
||||
end submodule constitutive_mech
|
||||
|
||||
|
|
|
@ -10,7 +10,8 @@ submodule(constitutive:constitutive_mech) plastic_nonlocal
|
|||
IPneighborhood => geometry_plastic_nonlocal_IPneighborhood, &
|
||||
IPvolume => geometry_plastic_nonlocal_IPvolume0, &
|
||||
IParea => geometry_plastic_nonlocal_IParea0, &
|
||||
IPareaNormal => geometry_plastic_nonlocal_IPareaNormal0
|
||||
IPareaNormal => geometry_plastic_nonlocal_IPareaNormal0, &
|
||||
geometry_plastic_nonlocal_disable
|
||||
|
||||
real(pReal), parameter :: &
|
||||
kB = 1.38e-23_pReal !< Boltzmann constant in J/Kelvin
|
||||
|
|
1638
src/crystallite.f90
1638
src/crystallite.f90
File diff suppressed because it is too large
Load Diff
|
@ -1,172 +0,0 @@
|
|||
!--------------------------------------------------------------------------------------------------
|
||||
!> @author Pratheek Shanthraj, Max-Planck-Institut für Eisenforschung GmbH
|
||||
!> @brief material subroutine for locally evolving damage field
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module damage_local
|
||||
use prec
|
||||
use IO
|
||||
use material
|
||||
use config
|
||||
use YAML_types
|
||||
use constitutive
|
||||
use results
|
||||
|
||||
implicit none
|
||||
private
|
||||
|
||||
type :: tParameters
|
||||
character(len=pStringLen), allocatable, dimension(:) :: &
|
||||
output
|
||||
end type tParameters
|
||||
|
||||
type, private :: tNumerics
|
||||
real(pReal) :: &
|
||||
residualStiffness !< non-zero residual damage
|
||||
end type tNumerics
|
||||
|
||||
type(tparameters), dimension(:), allocatable :: &
|
||||
param
|
||||
|
||||
type(tNumerics), private :: num
|
||||
|
||||
public :: &
|
||||
damage_local_init, &
|
||||
damage_local_updateState, &
|
||||
damage_local_results
|
||||
|
||||
contains
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief module initialization
|
||||
!> @details reads in material parameters, allocates arrays, and does sanity checks
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine damage_local_init
|
||||
|
||||
integer :: Ninstances,Nmaterialpoints,h
|
||||
class(tNode), pointer :: &
|
||||
num_generic, &
|
||||
material_homogenization, &
|
||||
homog, &
|
||||
homogDamage
|
||||
|
||||
print'(/,a)', ' <<<+- damage_local init -+>>>'; flush(IO_STDOUT)
|
||||
|
||||
!----------------------------------------------------------------------------------------------
|
||||
! read numerics parameter and do sanity check
|
||||
num_generic => config_numerics%get('generic',defaultVal=emptyDict)
|
||||
num%residualStiffness = num_generic%get_asFloat('residualStiffness', defaultVal=1.0e-6_pReal)
|
||||
if (num%residualStiffness < 0.0_pReal) call IO_error(301,ext_msg='residualStiffness')
|
||||
|
||||
Ninstances = count(damage_type == DAMAGE_local_ID)
|
||||
allocate(param(Ninstances))
|
||||
|
||||
material_homogenization => config_material%get('homogenization')
|
||||
do h = 1, material_homogenization%length
|
||||
if (damage_type(h) /= DAMAGE_LOCAL_ID) cycle
|
||||
homog => material_homogenization%get(h)
|
||||
homogDamage => homog%get('damage')
|
||||
associate(prm => param(damage_typeInstance(h)))
|
||||
|
||||
#if defined (__GFORTRAN__)
|
||||
prm%output = output_asStrings(homogDamage)
|
||||
#else
|
||||
prm%output = homogDamage%get_asStrings('output',defaultVal=emptyStringArray)
|
||||
#endif
|
||||
|
||||
Nmaterialpoints = count(material_homogenizationAt == h)
|
||||
damageState(h)%sizeState = 1
|
||||
allocate(damageState(h)%state0 (1,Nmaterialpoints), source=1.0_pReal)
|
||||
allocate(damageState(h)%subState0(1,Nmaterialpoints), source=1.0_pReal)
|
||||
allocate(damageState(h)%state (1,Nmaterialpoints), source=1.0_pReal)
|
||||
|
||||
damage(h)%p => damageState(h)%state(1,:)
|
||||
|
||||
end associate
|
||||
enddo
|
||||
|
||||
end subroutine damage_local_init
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief calculates local change in damage field
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
function damage_local_updateState(subdt, ip, el)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ip, & !< integration point number
|
||||
el !< element number
|
||||
real(pReal), intent(in) :: &
|
||||
subdt
|
||||
logical, dimension(2) :: &
|
||||
damage_local_updateState
|
||||
integer :: &
|
||||
homog, &
|
||||
offset
|
||||
real(pReal) :: &
|
||||
phi, phiDot, dPhiDot_dPhi
|
||||
|
||||
homog = material_homogenizationAt(el)
|
||||
offset = material_homogenizationMemberAt(ip,el)
|
||||
phi = damageState(homog)%subState0(1,offset)
|
||||
call damage_local_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el)
|
||||
phi = max(num%residualStiffness,min(1.0_pReal,phi + subdt*phiDot))
|
||||
|
||||
damage_local_updateState = [ abs(phi - damageState(homog)%state(1,offset)) &
|
||||
<= 1.0e-2_pReal &
|
||||
.or. abs(phi - damageState(homog)%state(1,offset)) &
|
||||
<= 1.0e-6_pReal*abs(damageState(homog)%state(1,offset)), &
|
||||
.true.]
|
||||
|
||||
damageState(homog)%state(1,offset) = phi
|
||||
|
||||
end function damage_local_updateState
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief calculates homogenized local damage driving forces
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine damage_local_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ip, & !< integration point number
|
||||
el !< element number
|
||||
real(pReal), intent(in) :: &
|
||||
phi
|
||||
real(pReal) :: &
|
||||
phiDot, dPhiDot_dPhi
|
||||
|
||||
phiDot = 0.0_pReal
|
||||
dPhiDot_dPhi = 0.0_pReal
|
||||
|
||||
call constitutive_damage_getRateAndItsTangents(phiDot, dPhiDot_dPhi, phi, ip, el)
|
||||
|
||||
phiDot = phiDot/real(homogenization_Nconstituents(material_homogenizationAt(el)),pReal)
|
||||
dPhiDot_dPhi = dPhiDot_dPhi/real(homogenization_Nconstituents(material_homogenizationAt(el)),pReal)
|
||||
|
||||
end subroutine damage_local_getSourceAndItsTangent
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief writes results to HDF5 output file
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine damage_local_results(homog,group)
|
||||
|
||||
integer, intent(in) :: homog
|
||||
character(len=*), intent(in) :: group
|
||||
|
||||
integer :: o
|
||||
|
||||
associate(prm => param(damage_typeInstance(homog)))
|
||||
outputsLoop: do o = 1,size(prm%output)
|
||||
select case(prm%output(o))
|
||||
case ('phi')
|
||||
call results_writeDataset(group,damage(homog)%p,prm%output(o),&
|
||||
'damage indicator','-')
|
||||
end select
|
||||
enddo outputsLoop
|
||||
end associate
|
||||
|
||||
end subroutine damage_local_results
|
||||
|
||||
|
||||
end module damage_local
|
|
@ -7,7 +7,6 @@ module damage_nonlocal
|
|||
use material
|
||||
use config
|
||||
use YAML_types
|
||||
use crystallite
|
||||
use lattice
|
||||
use constitutive
|
||||
use results
|
||||
|
|
|
@ -11,14 +11,11 @@ module homogenization
|
|||
use math
|
||||
use material
|
||||
use constitutive
|
||||
use crystallite
|
||||
use FEsolving
|
||||
use discretization
|
||||
use thermal_isothermal
|
||||
use thermal_adiabatic
|
||||
use thermal_conduction
|
||||
use damage_none
|
||||
use damage_local
|
||||
use damage_nonlocal
|
||||
use results
|
||||
|
||||
|
@ -162,11 +159,9 @@ subroutine homogenization_init
|
|||
call mech_init(num_homog)
|
||||
|
||||
if (any(thermal_type == THERMAL_isothermal_ID)) call thermal_isothermal_init
|
||||
if (any(thermal_type == THERMAL_adiabatic_ID)) call thermal_adiabatic_init
|
||||
if (any(thermal_type == THERMAL_conduction_ID)) call thermal_conduction_init
|
||||
|
||||
if (any(damage_type == DAMAGE_none_ID)) call damage_none_init
|
||||
if (any(damage_type == DAMAGE_local_ID)) call damage_local_init
|
||||
if (any(damage_type == DAMAGE_nonlocal_ID)) call damage_nonlocal_init
|
||||
|
||||
|
||||
|
@ -212,10 +207,6 @@ subroutine materialpoint_stressAndItsTangent(dt)
|
|||
homogState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e)) = &
|
||||
homogState(material_homogenizationAt(e))%State0( :,material_homogenizationMemberAt(i,e))
|
||||
|
||||
if (thermalState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
thermalState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e)) = &
|
||||
thermalState(material_homogenizationAt(e))%State0( :,material_homogenizationMemberAt(i,e))
|
||||
|
||||
if (damageState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
damageState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e)) = &
|
||||
damageState(material_homogenizationAt(e))%State0( :,material_homogenizationMemberAt(i,e))
|
||||
|
@ -245,9 +236,6 @@ subroutine materialpoint_stressAndItsTangent(dt)
|
|||
if(homogState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
homogState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e)) = &
|
||||
homogState(material_homogenizationAt(e))%State (:,material_homogenizationMemberAt(i,e))
|
||||
if(thermalState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
thermalState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e)) = &
|
||||
thermalState(material_homogenizationAt(e))%State (:,material_homogenizationMemberAt(i,e))
|
||||
if(damageState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
damageState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e)) = &
|
||||
damageState(material_homogenizationAt(e))%State (:,material_homogenizationMemberAt(i,e))
|
||||
|
@ -266,13 +254,11 @@ subroutine materialpoint_stressAndItsTangent(dt)
|
|||
subStep(i,e) = num%subStepSizeHomog * subStep(i,e) ! crystallite had severe trouble, so do a significant cutback
|
||||
|
||||
call crystallite_restore(i,e,subStep(i,e) < 1.0_pReal)
|
||||
call constitutive_restore(i,e)
|
||||
|
||||
if(homogState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
homogState(material_homogenizationAt(e))%State( :,material_homogenizationMemberAt(i,e)) = &
|
||||
homogState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e))
|
||||
if(thermalState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
thermalState(material_homogenizationAt(e))%State( :,material_homogenizationMemberAt(i,e)) = &
|
||||
thermalState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e))
|
||||
if(damageState(material_homogenizationAt(e))%sizeState > 0) &
|
||||
damageState(material_homogenizationAt(e))%State( :,material_homogenizationMemberAt(i,e)) = &
|
||||
damageState(material_homogenizationAt(e))%subState0(:,material_homogenizationMemberAt(i,e))
|
||||
|
@ -400,24 +386,6 @@ function updateState(subdt,subF,ip,el)
|
|||
el)
|
||||
end select chosenHomogenization
|
||||
|
||||
chosenThermal: select case (thermal_type(material_homogenizationAt(el)))
|
||||
case (THERMAL_adiabatic_ID) chosenThermal
|
||||
updateState = &
|
||||
updateState .and. &
|
||||
thermal_adiabatic_updateState(subdt, &
|
||||
ip, &
|
||||
el)
|
||||
end select chosenThermal
|
||||
|
||||
chosenDamage: select case (damage_type(material_homogenizationAt(el)))
|
||||
case (DAMAGE_local_ID) chosenDamage
|
||||
updateState = &
|
||||
updateState .and. &
|
||||
damage_local_updateState(subdt, &
|
||||
ip, &
|
||||
el)
|
||||
end select chosenDamage
|
||||
|
||||
end function updateState
|
||||
|
||||
|
||||
|
@ -441,8 +409,6 @@ subroutine homogenization_results
|
|||
group = trim(group_base)//'/damage'
|
||||
call results_closeGroup(results_addGroup(group))
|
||||
select case(damage_type(p))
|
||||
case(DAMAGE_LOCAL_ID)
|
||||
call damage_local_results(p,group)
|
||||
case(DAMAGE_NONLOCAL_ID)
|
||||
call damage_nonlocal_results(p,group)
|
||||
end select
|
||||
|
@ -450,8 +416,6 @@ subroutine homogenization_results
|
|||
group = trim(group_base)//'/thermal'
|
||||
call results_closeGroup(results_addGroup(group))
|
||||
select case(thermal_type(p))
|
||||
case(THERMAL_ADIABATIC_ID)
|
||||
call thermal_adiabatic_results(p,group)
|
||||
case(THERMAL_CONDUCTION_ID)
|
||||
call thermal_conduction_results(p,group)
|
||||
end select
|
||||
|
|
|
@ -81,29 +81,6 @@ module function kinematics_thermal_expansion_init(kinematics_length) result(myKi
|
|||
end function kinematics_thermal_expansion_init
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief report initial thermal strain based on current temperature deviation from reference
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
pure module function kinematics_thermal_expansion_initialStrain(homog,phase,offset) result(initialStrain)
|
||||
|
||||
integer, intent(in) :: &
|
||||
phase, &
|
||||
homog, &
|
||||
offset
|
||||
|
||||
real(pReal), dimension(3,3) :: &
|
||||
initialStrain !< initial thermal strain (should be small strain, though)
|
||||
|
||||
associate(prm => param(kinematics_thermal_expansion_instance(phase)))
|
||||
initialStrain = &
|
||||
(temperature(homog)%p(offset) - prm%T_ref)**1 / 1. * prm%A(1:3,1:3,1) + & ! constant coefficient
|
||||
(temperature(homog)%p(offset) - prm%T_ref)**2 / 2. * prm%A(1:3,1:3,2) + & ! linear coefficient
|
||||
(temperature(homog)%p(offset) - prm%T_ref)**3 / 3. * prm%A(1:3,1:3,3) ! quadratic coefficient
|
||||
end associate
|
||||
|
||||
end function kinematics_thermal_expansion_initialStrain
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief constitutive equation for calculating the velocity gradient
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
|
|
|
@ -41,10 +41,8 @@ module material
|
|||
STIFFNESS_DEGRADATION_UNDEFINED_ID, &
|
||||
STIFFNESS_DEGRADATION_DAMAGE_ID, &
|
||||
THERMAL_ISOTHERMAL_ID, &
|
||||
THERMAL_ADIABATIC_ID, &
|
||||
THERMAL_CONDUCTION_ID, &
|
||||
DAMAGE_NONE_ID, &
|
||||
DAMAGE_LOCAL_ID, &
|
||||
DAMAGE_NONLOCAL_ID, &
|
||||
HOMOGENIZATION_UNDEFINED_ID, &
|
||||
HOMOGENIZATION_NONE_ID, &
|
||||
|
@ -86,7 +84,6 @@ module material
|
|||
|
||||
type(tState), allocatable, dimension(:), public :: &
|
||||
homogState, &
|
||||
thermalState, &
|
||||
damageState
|
||||
|
||||
type(Rotation), dimension(:,:,:), allocatable, public, protected :: &
|
||||
|
@ -123,10 +120,8 @@ module material
|
|||
STIFFNESS_DEGRADATION_UNDEFINED_ID, &
|
||||
STIFFNESS_DEGRADATION_DAMAGE_ID, &
|
||||
THERMAL_ISOTHERMAL_ID, &
|
||||
THERMAL_ADIABATIC_ID, &
|
||||
THERMAL_CONDUCTION_ID, &
|
||||
DAMAGE_NONE_ID, &
|
||||
DAMAGE_LOCAL_ID, &
|
||||
DAMAGE_NONLOCAL_ID, &
|
||||
HOMOGENIZATION_NONE_ID, &
|
||||
HOMOGENIZATION_ISOSTRAIN_ID, &
|
||||
|
@ -152,7 +147,6 @@ subroutine material_init(restart)
|
|||
|
||||
|
||||
allocate(homogState (size(material_name_homogenization)))
|
||||
allocate(thermalState (size(material_name_homogenization)))
|
||||
allocate(damageState (size(material_name_homogenization)))
|
||||
|
||||
allocate(temperature (size(material_name_homogenization)))
|
||||
|
@ -218,8 +212,6 @@ subroutine material_parseHomogenization
|
|||
select case (homogThermal%get_asString('type'))
|
||||
case('isothermal')
|
||||
thermal_type(h) = THERMAL_isothermal_ID
|
||||
case('adiabatic')
|
||||
thermal_type(h) = THERMAL_adiabatic_ID
|
||||
case('conduction')
|
||||
thermal_type(h) = THERMAL_conduction_ID
|
||||
case default
|
||||
|
@ -232,8 +224,6 @@ subroutine material_parseHomogenization
|
|||
select case (homogDamage%get_asString('type'))
|
||||
case('none')
|
||||
damage_type(h) = DAMAGE_none_ID
|
||||
case('local')
|
||||
damage_type(h) = DAMAGE_local_ID
|
||||
case('nonlocal')
|
||||
damage_type(h) = DAMAGE_nonlocal_ID
|
||||
case default
|
||||
|
|
|
@ -1,226 +0,0 @@
|
|||
!--------------------------------------------------------------------------------------------------
|
||||
!> @author Pratheek Shanthraj, Max-Planck-Institut für Eisenforschung GmbH
|
||||
!> @brief material subroutine for adiabatic temperature evolution
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
module thermal_adiabatic
|
||||
use prec
|
||||
use config
|
||||
use material
|
||||
use results
|
||||
use constitutive
|
||||
use YAML_types
|
||||
use crystallite
|
||||
use lattice
|
||||
|
||||
implicit none
|
||||
private
|
||||
|
||||
type :: tParameters
|
||||
character(len=pStringLen), allocatable, dimension(:) :: &
|
||||
output
|
||||
end type tParameters
|
||||
|
||||
type(tparameters), dimension(:), allocatable :: &
|
||||
param
|
||||
|
||||
public :: &
|
||||
thermal_adiabatic_init, &
|
||||
thermal_adiabatic_updateState, &
|
||||
thermal_adiabatic_getSourceAndItsTangent, &
|
||||
thermal_adiabatic_getSpecificHeat, &
|
||||
thermal_adiabatic_getMassDensity, &
|
||||
thermal_adiabatic_results
|
||||
|
||||
contains
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief module initialization
|
||||
!> @details reads in material parameters, allocates arrays, and does sanity checks
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine thermal_adiabatic_init
|
||||
|
||||
integer :: maxNinstances,h,Nmaterialpoints
|
||||
class(tNode), pointer :: &
|
||||
material_homogenization, &
|
||||
homog, &
|
||||
homogThermal
|
||||
|
||||
print'(/,a)', ' <<<+- thermal_adiabatic init -+>>>'; flush(6)
|
||||
|
||||
maxNinstances = count(thermal_type == THERMAL_adiabatic_ID)
|
||||
if (maxNinstances == 0) return
|
||||
|
||||
allocate(param(maxNinstances))
|
||||
|
||||
material_homogenization => config_material%get('homogenization')
|
||||
do h = 1, size(material_name_homogenization)
|
||||
if (thermal_type(h) /= THERMAL_adiabatic_ID) cycle
|
||||
homog => material_homogenization%get(h)
|
||||
homogThermal => homog%get('thermal')
|
||||
|
||||
associate(prm => param(thermal_typeInstance(h)))
|
||||
|
||||
#if defined (__GFORTRAN__)
|
||||
prm%output = output_asStrings(homogThermal)
|
||||
#else
|
||||
prm%output = homogThermal%get_asStrings('output',defaultVal=emptyStringArray)
|
||||
#endif
|
||||
|
||||
Nmaterialpoints=count(material_homogenizationAt==h)
|
||||
thermalState(h)%sizeState = 1
|
||||
allocate(thermalState(h)%state0 (1,Nmaterialpoints), source=thermal_initialT(h))
|
||||
allocate(thermalState(h)%subState0(1,Nmaterialpoints), source=thermal_initialT(h))
|
||||
allocate(thermalState(h)%state (1,Nmaterialpoints), source=thermal_initialT(h))
|
||||
|
||||
temperature(h)%p => thermalState(h)%state(1,:)
|
||||
allocate(temperatureRate(h)%p(Nmaterialpoints),source = 0.0_pReal)
|
||||
|
||||
end associate
|
||||
enddo
|
||||
|
||||
end subroutine thermal_adiabatic_init
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief calculates adiabatic change in temperature based on local heat generation model
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
function thermal_adiabatic_updateState(subdt, ip, el)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ip, & !< integration point number
|
||||
el !< element number
|
||||
real(pReal), intent(in) :: &
|
||||
subdt
|
||||
|
||||
logical, dimension(2) :: &
|
||||
thermal_adiabatic_updateState
|
||||
integer :: &
|
||||
homog, &
|
||||
offset
|
||||
real(pReal) :: &
|
||||
T, Tdot, dTdot_dT
|
||||
|
||||
homog = material_homogenizationAt(el)
|
||||
offset = material_homogenizationMemberAt(ip,el)
|
||||
|
||||
T = thermalState(homog)%subState0(1,offset)
|
||||
call thermal_adiabatic_getSourceAndItsTangent(Tdot, dTdot_dT, T, ip, el)
|
||||
T = T + subdt*Tdot/(thermal_adiabatic_getSpecificHeat(ip,el)*thermal_adiabatic_getMassDensity(ip,el))
|
||||
|
||||
thermal_adiabatic_updateState = [ abs(T - thermalState(homog)%state(1,offset)) &
|
||||
<= 1.0e-2_pReal &
|
||||
.or. abs(T - thermalState(homog)%state(1,offset)) &
|
||||
<= 1.0e-6_pReal*abs(thermalState(homog)%state(1,offset)), &
|
||||
.true.]
|
||||
|
||||
temperature (homog)%p(material_homogenizationMemberAt(ip,el)) = T
|
||||
temperatureRate(homog)%p(material_homogenizationMemberAt(ip,el)) = &
|
||||
(thermalState(homog)%state(1,offset) - thermalState(homog)%subState0(1,offset))/(subdt+tiny(0.0_pReal))
|
||||
|
||||
end function thermal_adiabatic_updateState
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief returns heat generation rate
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine thermal_adiabatic_getSourceAndItsTangent(Tdot, dTdot_dT, T, ip, el)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ip, & !< integration point number
|
||||
el !< element number
|
||||
real(pReal), intent(in) :: &
|
||||
T
|
||||
real(pReal), intent(out) :: &
|
||||
Tdot, dTdot_dT
|
||||
integer :: &
|
||||
homog
|
||||
|
||||
Tdot = 0.0_pReal
|
||||
dTdot_dT = 0.0_pReal
|
||||
|
||||
homog = material_homogenizationAt(el)
|
||||
call constitutive_thermal_getRateAndItsTangents(TDot, dTDot_dT, T, crystallite_S, crystallite_Lp, ip, el)
|
||||
|
||||
Tdot = Tdot/real(homogenization_Nconstituents(homog),pReal)
|
||||
dTdot_dT = dTdot_dT/real(homogenization_Nconstituents(homog),pReal)
|
||||
|
||||
end subroutine thermal_adiabatic_getSourceAndItsTangent
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief returns homogenized specific heat capacity
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
function thermal_adiabatic_getSpecificHeat(ip,el)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ip, & !< integration point number
|
||||
el !< element number
|
||||
|
||||
real(pReal) :: &
|
||||
thermal_adiabatic_getSpecificHeat
|
||||
integer :: &
|
||||
grain
|
||||
|
||||
thermal_adiabatic_getSpecificHeat = 0.0_pReal
|
||||
|
||||
do grain = 1, homogenization_Nconstituents(material_homogenizationAt(el))
|
||||
thermal_adiabatic_getSpecificHeat = thermal_adiabatic_getSpecificHeat &
|
||||
+ lattice_c_p(material_phaseAt(grain,el))
|
||||
enddo
|
||||
|
||||
thermal_adiabatic_getSpecificHeat = thermal_adiabatic_getSpecificHeat &
|
||||
/ real(homogenization_Nconstituents(material_homogenizationAt(el)),pReal)
|
||||
|
||||
end function thermal_adiabatic_getSpecificHeat
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief returns homogenized mass density
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
function thermal_adiabatic_getMassDensity(ip,el)
|
||||
|
||||
integer, intent(in) :: &
|
||||
ip, & !< integration point number
|
||||
el !< element number
|
||||
real(pReal) :: &
|
||||
thermal_adiabatic_getMassDensity
|
||||
integer :: &
|
||||
grain
|
||||
|
||||
thermal_adiabatic_getMassDensity = 0.0_pReal
|
||||
|
||||
do grain = 1, homogenization_Nconstituents(material_homogenizationAt(el))
|
||||
thermal_adiabatic_getMassDensity = thermal_adiabatic_getMassDensity &
|
||||
+ lattice_rho(material_phaseAt(grain,el))
|
||||
enddo
|
||||
|
||||
thermal_adiabatic_getMassDensity = thermal_adiabatic_getMassDensity &
|
||||
/ real(homogenization_Nconstituents(material_homogenizationAt(el)),pReal)
|
||||
|
||||
end function thermal_adiabatic_getMassDensity
|
||||
|
||||
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
!> @brief writes results to HDF5 output file
|
||||
!--------------------------------------------------------------------------------------------------
|
||||
subroutine thermal_adiabatic_results(homog,group)
|
||||
|
||||
integer, intent(in) :: homog
|
||||
character(len=*), intent(in) :: group
|
||||
|
||||
integer :: o
|
||||
|
||||
associate(prm => param(damage_typeInstance(homog)))
|
||||
outputsLoop: do o = 1,size(prm%output)
|
||||
select case(trim(prm%output(o)))
|
||||
case('T')
|
||||
call results_writeDataset(group,temperature(homog)%p,'T',&
|
||||
'temperature','K')
|
||||
end select
|
||||
enddo outputsLoop
|
||||
end associate
|
||||
|
||||
end subroutine thermal_adiabatic_results
|
||||
|
||||
end module thermal_adiabatic
|
|
@ -8,7 +8,6 @@ module thermal_conduction
|
|||
use config
|
||||
use lattice
|
||||
use results
|
||||
use crystallite
|
||||
use constitutive
|
||||
use YAML_types
|
||||
|
||||
|
@ -66,10 +65,6 @@ subroutine thermal_conduction_init
|
|||
#endif
|
||||
|
||||
Nmaterialpoints=count(material_homogenizationAt==h)
|
||||
thermalState(h)%sizeState = 0
|
||||
allocate(thermalState(h)%state0 (0,Nmaterialpoints))
|
||||
allocate(thermalState(h)%subState0(0,Nmaterialpoints))
|
||||
allocate(thermalState(h)%state (0,Nmaterialpoints))
|
||||
|
||||
allocate (temperature (h)%p(Nmaterialpoints), source=thermal_initialT(h))
|
||||
allocate (temperatureRate(h)%p(Nmaterialpoints), source=0.0_pReal)
|
||||
|
|
|
@ -25,10 +25,6 @@ subroutine thermal_isothermal_init
|
|||
if (thermal_type(h) /= THERMAL_isothermal_ID) cycle
|
||||
|
||||
Nmaterialpoints = count(material_homogenizationAt == h)
|
||||
thermalState(h)%sizeState = 0
|
||||
allocate(thermalState(h)%state0 (0,Nmaterialpoints))
|
||||
allocate(thermalState(h)%subState0(0,Nmaterialpoints))
|
||||
allocate(thermalState(h)%state (0,Nmaterialpoints))
|
||||
|
||||
allocate(temperature (h)%p(Nmaterialpoints),source=thermal_initialT(h))
|
||||
allocate(temperatureRate(h)%p(Nmaterialpoints),source = 0.0_pReal)
|
||||
|
|
Loading…
Reference in New Issue