DAMASK_EICMD/src/homogenization.f90

439 lines
17 KiB
Fortran
Raw Normal View History

2012-08-10 21:28:17 +05:30
!--------------------------------------------------------------------------------------------------
!> @author Franz Roters, Max-Planck-Institut für Eisenforschung GmbH
!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH
!> @author Denny Tjahjanto, Max-Planck-Institut für Eisenforschung GmbH
!> @brief homogenization manager, organizing deformation partitioning and stress homogenization
2012-08-10 21:28:17 +05:30
!--------------------------------------------------------------------------------------------------
module homogenization
2019-06-15 20:12:16 +05:30
use prec
use IO
use config
use math
use material
use phase
2019-06-15 20:12:16 +05:30
use discretization
use damage_nonlocal
2020-12-30 04:44:48 +05:30
use HDF5_utilities
2019-06-15 20:12:16 +05:30
use results
2020-03-17 05:09:32 +05:30
2019-06-15 20:12:16 +05:30
implicit none
private
2019-06-11 13:18:07 +05:30
2020-03-29 23:34:51 +05:30
logical, public :: &
terminallyIll = .false. !< at least one material point is terminally ill
2020-04-14 13:08:32 +05:30
!--------------------------------------------------------------------------------------------------
! General variables for the homogenization at a material point
real(pReal), dimension(:,:,:), allocatable, public :: &
2020-12-16 15:51:24 +05:30
homogenization_F0, & !< def grad of IP at start of FE increment
homogenization_F !< def grad of IP to be reached at end of FE increment
real(pReal), dimension(:,:,:), allocatable, public :: & !, protected :: & Issue with ifort
2020-12-16 15:51:24 +05:30
homogenization_P !< first P--K stress of IP
real(pReal), dimension(:,:,:,:,:), allocatable, public :: & !, protected :: &
2020-12-16 15:51:24 +05:30
homogenization_dPdF !< tangent of first P--K stress at IP
2019-06-15 20:12:16 +05:30
2020-12-16 15:51:24 +05:30
!--------------------------------------------------------------------------------------------------
2020-03-17 05:09:32 +05:30
type :: tNumerics
integer :: &
2020-04-14 13:08:32 +05:30
nMPstate !< materialpoint state loop limit
2020-03-17 05:09:32 +05:30
end type tNumerics
type(tNumerics) :: num
2020-12-16 15:51:24 +05:30
!--------------------------------------------------------------------------------------------------
interface
2020-03-17 05:09:32 +05:30
2021-02-09 03:51:53 +05:30
module subroutine mechanical_init(num_homog)
2020-06-16 22:17:19 +05:30
class(tNode), pointer, intent(in) :: &
2020-12-16 15:51:24 +05:30
num_homog !< pointer to mechanical homogenization numerics data
2021-02-09 03:51:53 +05:30
end subroutine mechanical_init
2020-12-16 15:51:24 +05:30
2020-12-30 16:30:47 +05:30
module subroutine thermal_init
end subroutine thermal_init
2021-01-21 01:24:31 +05:30
module subroutine damage_init
end subroutine damage_init
2021-02-09 03:51:53 +05:30
module subroutine mechanical_partition(subF,ip,el)
2020-12-16 15:51:24 +05:30
real(pReal), intent(in), dimension(3,3) :: &
subF
integer, intent(in) :: &
ip, & !< integration point
el !< element number
2021-02-09 03:51:53 +05:30
end subroutine mechanical_partition
2020-03-17 05:09:32 +05:30
2021-01-24 17:56:01 +05:30
module subroutine thermal_partition(ce)
integer, intent(in) :: ce
2021-01-08 02:45:18 +05:30
end subroutine thermal_partition
module subroutine damage_partition(ce)
2021-01-21 01:24:31 +05:30
integer, intent(in) :: ce
end subroutine damage_partition
module subroutine thermal_homogenize(ip,el)
integer, intent(in) :: ip,el
end subroutine thermal_homogenize
2021-02-09 03:51:53 +05:30
module subroutine mechanical_homogenize(dt,ip,el)
real(pReal), intent(in) :: dt
2020-12-16 15:51:24 +05:30
integer, intent(in) :: &
ip, & !< integration point
el !< element number
2021-02-09 03:51:53 +05:30
end subroutine mechanical_homogenize
2020-03-17 05:09:32 +05:30
2021-02-09 03:51:53 +05:30
module subroutine mechanical_results(group_base,h)
2020-12-16 15:51:24 +05:30
character(len=*), intent(in) :: group_base
integer, intent(in) :: h
2021-02-09 03:51:53 +05:30
end subroutine mechanical_results
2020-03-17 05:09:32 +05:30
2021-02-09 03:51:53 +05:30
module function mechanical_updateState(subdt,subF,ip,el) result(doneAndHappy)
2020-12-28 14:25:54 +05:30
real(pReal), intent(in) :: &
subdt !< current time step
real(pReal), intent(in), dimension(3,3) :: &
subF
integer, intent(in) :: &
ip, & !< integration point
el !< element number
logical, dimension(2) :: doneAndHappy
2021-02-09 03:51:53 +05:30
end function mechanical_updateState
2019-06-15 20:12:16 +05:30
2021-01-24 17:56:01 +05:30
module function thermal_conduction_getConductivity(ip,el) result(K)
integer, intent(in) :: &
ip, & !< integration point number
el !< element number
real(pReal), dimension(3,3) :: K
end function thermal_conduction_getConductivity
module function thermal_conduction_getSpecificHeat(ce) result(c_P)
integer, intent(in) :: ce
real(pReal) :: c_P
end function thermal_conduction_getSpecificHeat
module function thermal_conduction_getMassDensity(ce) result(rho)
integer, intent(in) :: ce
real(pReal) :: rho
end function thermal_conduction_getMassDensity
module subroutine homogenization_thermal_setField(T,dot_T, ce)
integer, intent(in) :: ce
real(pReal), intent(in) :: T, dot_T
end subroutine homogenization_thermal_setField
2021-01-24 21:04:51 +05:30
module subroutine thermal_conduction_results(ho,group)
integer, intent(in) :: ho
character(len=*), intent(in) :: group
end subroutine thermal_conduction_results
2021-01-24 19:49:57 +05:30
module function homogenization_thermal_T(ce) result(T)
integer, intent(in) :: ce
real(pReal) :: T
end function homogenization_thermal_T
2021-01-24 21:34:41 +05:30
module subroutine thermal_conduction_getSource(Tdot, ip,el)
integer, intent(in) :: &
ip, & !< integration point number
el !< element number
real(pReal), intent(out) :: Tdot
end subroutine thermal_conduction_getSource
2021-01-24 23:17:19 +05:30
module function damage_nonlocal_getMobility(ip,el) result(M)
integer, intent(in) :: &
ip, & !< integration point number
el !< element number
real(pReal) :: M
end function damage_nonlocal_getMobility
2021-01-25 19:43:17 +05:30
module subroutine damage_nonlocal_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
end subroutine damage_nonlocal_getSourceAndItsTangent
module subroutine damage_nonlocal_putNonLocalDamage(phi,ip,el)
integer, intent(in) :: &
ip, & !< integration point number
el !< element number
real(pReal), intent(in) :: &
phi
end subroutine damage_nonlocal_putNonLocalDamage
module subroutine damage_nonlocal_results(homog,group)
integer, intent(in) :: homog
character(len=*), intent(in) :: group
end subroutine damage_nonlocal_results
2019-06-15 20:12:16 +05:30
end interface
2019-06-15 20:12:16 +05:30
public :: &
homogenization_init, &
materialpoint_stressAndItsTangent, &
2021-01-24 17:56:01 +05:30
thermal_conduction_getSpecificHeat, &
thermal_conduction_getConductivity, &
thermal_conduction_getMassDensity, &
2021-01-24 21:34:41 +05:30
thermal_conduction_getSource, &
2021-01-24 23:17:19 +05:30
damage_nonlocal_getMobility, &
2021-01-25 03:14:47 +05:30
damage_nonlocal_getSourceAndItsTangent, &
2021-01-25 19:43:17 +05:30
damage_nonlocal_putNonLocalDamage, &
2021-01-24 17:56:01 +05:30
homogenization_thermal_setfield, &
2021-01-24 19:49:57 +05:30
homogenization_thermal_T, &
2020-12-23 11:28:54 +05:30
homogenization_forward, &
2020-12-30 04:44:48 +05:30
homogenization_results, &
homogenization_restartRead, &
homogenization_restartWrite
2012-08-10 21:28:17 +05:30
contains
!--------------------------------------------------------------------------------------------------
!> @brief module initialization
!--------------------------------------------------------------------------------------------------
2021-01-21 01:24:31 +05:30
subroutine homogenization_init()
2020-06-16 22:17:19 +05:30
class (tNode) , pointer :: &
num_homog, &
num_homogGeneric
2020-07-02 01:50:22 +05:30
2020-12-16 15:51:24 +05:30
print'(/,a)', ' <<<+- homogenization init -+>>>'; flush(IO_STDOUT)
num_homog => config_numerics%get('homogenization',defaultVal=emptyDict)
2020-06-16 22:17:19 +05:30
num_homogGeneric => num_homog%get('generic',defaultVal=emptyDict)
2020-06-26 15:52:33 +05:30
num%nMPstate = num_homogGeneric%get_asInt ('nMPstate', defaultVal=10)
2020-03-17 05:09:32 +05:30
if (num%nMPstate < 1) call IO_error(301,ext_msg='nMPstate')
2020-12-16 15:51:24 +05:30
2021-02-09 03:51:53 +05:30
call mechanical_init(num_homog)
2021-01-08 02:45:18 +05:30
call thermal_init()
2021-01-21 01:24:31 +05:30
call damage_init()
2020-12-16 15:51:24 +05:30
if (any(damage_type == DAMAGE_nonlocal_ID)) call damage_nonlocal_init
2012-08-10 21:28:17 +05:30
end subroutine homogenization_init
2012-08-10 21:28:17 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief parallelized calculation of stress and corresponding tangent at material points
!--------------------------------------------------------------------------------------------------
2020-12-27 16:18:02 +05:30
subroutine materialpoint_stressAndItsTangent(dt,FEsolving_execIP,FEsolving_execElem)
2019-06-15 20:12:16 +05:30
real(pReal), intent(in) :: dt !< time increment
2020-12-27 16:18:02 +05:30
integer, dimension(2), intent(in) :: FEsolving_execElem, FEsolving_execIP
2019-06-15 20:12:16 +05:30
integer :: &
NiterationMPstate, &
2020-12-23 18:54:44 +05:30
ip, & !< integration point number
el, & !< element number
myNgrains, co, ce, ho, me, ph
2020-12-23 21:44:26 +05:30
logical :: &
2020-04-15 16:39:05 +05:30
converged
2020-12-23 21:44:26 +05:30
logical, dimension(2) :: &
2020-04-15 16:39:05 +05:30
doneAndHappy
2020-07-03 20:15:11 +05:30
2021-01-17 14:46:56 +05:30
!$OMP PARALLEL
2021-01-25 18:19:29 +05:30
!$OMP DO PRIVATE(ce,me,ho,myNgrains,NiterationMPstate,converged,doneAndHappy)
2020-12-23 18:54:44 +05:30
do el = FEsolving_execElem(1),FEsolving_execElem(2)
2020-12-27 16:18:02 +05:30
ho = material_homogenizationAt(el)
myNgrains = homogenization_Nconstituents(ho)
2020-12-23 21:44:26 +05:30
do ip = FEsolving_execIP(1),FEsolving_execIP(2)
2021-01-24 14:09:40 +05:30
ce = (el-1)*discretization_nIPs + ip
me = material_homogenizationMemberAt2(ce)
2021-02-09 03:51:53 +05:30
call phase_restore(ce,.false.) ! wrong name (is more a forward function)
2020-03-17 05:09:32 +05:30
2021-01-25 18:19:29 +05:30
if(homogState(ho)%sizeState > 0) homogState(ho)%State(:,me) = homogState(ho)%State0(:,me)
if(damageState_h(ho)%sizeState > 0) damageState_h(ho)%State(:,me) = damageState_h(ho)%State0(:,me)
2019-06-15 20:12:16 +05:30
2021-01-25 18:19:29 +05:30
doneAndHappy = [.false.,.true.]
2021-01-25 18:19:29 +05:30
NiterationMPstate = 0
convergenceLooping: do while (.not. (terminallyIll .or. doneAndHappy(1)) &
.and. NiterationMPstate < num%nMPstate)
NiterationMPstate = NiterationMPstate + 1
2019-06-15 20:12:16 +05:30
2020-12-28 01:50:54 +05:30
2021-01-25 18:19:29 +05:30
if (.not. doneAndHappy(1)) then
2021-02-09 03:51:53 +05:30
call mechanical_partition(homogenization_F(1:3,1:3,ce),ip,el)
2021-01-25 18:19:29 +05:30
converged = .true.
do co = 1, myNgrains
converged = converged .and. crystallite_stress(dt,co,ip,el)
enddo
2020-12-28 01:50:54 +05:30
2021-01-25 18:19:29 +05:30
if (.not. converged) then
doneAndHappy = [.true.,.false.]
else
2021-02-09 03:51:53 +05:30
doneAndHappy = mechanical_updateState(dt,homogenization_F(1:3,1:3,ce),ip,el)
2021-01-25 18:19:29 +05:30
converged = all(doneAndHappy)
2019-06-15 20:12:16 +05:30
endif
2021-01-25 18:19:29 +05:30
endif
2020-03-17 05:09:32 +05:30
2021-01-25 18:19:29 +05:30
enddo convergenceLooping
if (.not. converged) then
if (.not. terminallyIll) print*, ' Integration point ', ip,' at element ', el, ' terminally ill'
terminallyIll = .true.
endif
2020-12-23 19:07:12 +05:30
enddo
2020-12-24 17:14:26 +05:30
enddo
2021-01-17 14:46:56 +05:30
!$OMP END DO
2020-12-23 19:07:12 +05:30
2019-06-15 20:12:16 +05:30
if (.not. terminallyIll ) then
2021-01-17 14:46:56 +05:30
!$OMP DO PRIVATE(ho,ph,ce)
do el = FEsolving_execElem(1),FEsolving_execElem(2)
if (terminallyIll) continue
ho = material_homogenizationAt(el)
do ip = FEsolving_execIP(1),FEsolving_execIP(2)
ce = (el-1)*discretization_nIPs + ip
2021-01-24 17:56:01 +05:30
call thermal_partition(ce)
do co = 1, homogenization_Nconstituents(ho)
ph = material_phaseAt(co,el)
if (.not. thermal_stress(dt,ph,material_phaseMemberAt(co,ip,el))) then
if (.not. terminallyIll) & ! so first signals terminally ill...
print*, ' Integration point ', ip,' at element ', el, ' terminally ill'
terminallyIll = .true. ! ...and kills all others
endif
call thermal_homogenize(ip,el)
enddo
enddo
enddo
2021-01-17 14:46:56 +05:30
!$OMP END DO
2021-01-17 14:46:56 +05:30
!$OMP DO PRIVATE(ho)
2020-12-23 18:54:44 +05:30
elementLooping3: do el = FEsolving_execElem(1),FEsolving_execElem(2)
2020-12-27 16:18:02 +05:30
ho = material_homogenizationAt(el)
2020-12-23 18:54:44 +05:30
IpLooping3: do ip = FEsolving_execIP(1),FEsolving_execIP(2)
do co = 1, homogenization_Nconstituents(ho)
2020-12-27 16:18:02 +05:30
call crystallite_orientations(co,ip,el)
enddo
2021-02-09 03:51:53 +05:30
call mechanical_homogenize(dt,ip,el)
2020-12-23 14:35:02 +05:30
enddo IpLooping3
enddo elementLooping3
2021-01-17 14:46:56 +05:30
!$OMP END DO
2019-06-15 20:12:16 +05:30
else
2020-09-18 02:27:56 +05:30
print'(/,a,/)', ' << HOMOG >> Material Point terminally ill'
2019-06-15 20:12:16 +05:30
endif
2021-01-17 14:46:56 +05:30
!$OMP END PARALLEL
2012-08-10 21:28:17 +05:30
end subroutine materialpoint_stressAndItsTangent
2019-04-30 22:15:16 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief writes homogenization results to HDF5 output file
!--------------------------------------------------------------------------------------------------
subroutine homogenization_results
2020-03-17 05:09:32 +05:30
2020-12-28 13:57:48 +05:30
integer :: ho
2020-11-06 05:29:12 +05:30
character(len=:), allocatable :: group_base,group
2020-03-17 05:09:32 +05:30
2020-12-28 13:48:20 +05:30
2020-12-22 13:15:01 +05:30
call results_closeGroup(results_addGroup('current/homogenization/'))
2020-03-17 05:09:32 +05:30
2020-12-28 13:57:48 +05:30
do ho=1,size(material_name_homogenization)
group_base = 'current/homogenization/'//trim(material_name_homogenization(ho))
2019-12-10 11:44:39 +05:30
call results_closeGroup(results_addGroup(group_base))
2020-03-17 05:09:32 +05:30
2021-02-09 03:51:53 +05:30
call mechanical_results(group_base,ho)
2019-12-10 11:44:39 +05:30
group = trim(group_base)//'/damage'
call results_closeGroup(results_addGroup(group))
2020-12-28 13:57:48 +05:30
select case(damage_type(ho))
2019-12-10 11:44:39 +05:30
case(DAMAGE_NONLOCAL_ID)
2020-12-28 13:57:48 +05:30
call damage_nonlocal_results(ho,group)
2019-12-10 11:44:39 +05:30
end select
2020-03-17 05:09:32 +05:30
2019-12-10 11:44:39 +05:30
group = trim(group_base)//'/thermal'
call results_closeGroup(results_addGroup(group))
2020-12-28 13:57:48 +05:30
select case(thermal_type(ho))
2019-12-11 00:55:19 +05:30
case(THERMAL_CONDUCTION_ID)
2020-12-28 13:57:48 +05:30
call thermal_conduction_results(ho,group)
2019-12-11 00:55:19 +05:30
end select
2020-03-17 05:09:32 +05:30
2019-12-10 11:44:39 +05:30
enddo
2019-12-19 00:35:51 +05:30
2019-04-30 22:15:16 +05:30
end subroutine homogenization_results
2020-12-23 11:28:54 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief Forward data after successful increment.
! ToDo: Any guessing for the current states possible?
!--------------------------------------------------------------------------------------------------
subroutine homogenization_forward
2020-12-23 14:35:02 +05:30
integer :: ho
2020-12-23 11:28:54 +05:30
2020-12-28 13:48:20 +05:30
2020-12-23 11:28:54 +05:30
do ho = 1, size(material_name_homogenization)
homogState (ho)%state0 = homogState (ho)%state
2021-01-08 11:40:38 +05:30
damageState_h(ho)%state0 = damageState_h(ho)%state
2020-12-23 11:28:54 +05:30
enddo
end subroutine homogenization_forward
2020-12-30 04:44:48 +05:30
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
subroutine homogenization_restartWrite(fileHandle)
integer(HID_T), intent(in) :: fileHandle
integer(HID_T), dimension(2) :: groupHandle
integer :: ho
groupHandle(1) = HDF5_addGroup(fileHandle,'homogenization')
do ho = 1, size(material_name_homogenization)
groupHandle(2) = HDF5_addGroup(groupHandle(1),material_name_homogenization(ho))
call HDF5_read(groupHandle(2),homogState(ho)%state,'omega') ! ToDo: should be done by mech
call HDF5_closeGroup(groupHandle(2))
enddo
call HDF5_closeGroup(groupHandle(1))
end subroutine homogenization_restartWrite
!--------------------------------------------------------------------------------------------------
!--------------------------------------------------------------------------------------------------
subroutine homogenization_restartRead(fileHandle)
integer(HID_T), intent(in) :: fileHandle
integer(HID_T), dimension(2) :: groupHandle
integer :: ho
groupHandle(1) = HDF5_openGroup(fileHandle,'homogenization')
do ho = 1, size(material_name_homogenization)
groupHandle(2) = HDF5_openGroup(groupHandle(1),material_name_homogenization(ho))
call HDF5_write(groupHandle(2),homogState(ho)%state,'omega') ! ToDo: should be done by mech
call HDF5_closeGroup(groupHandle(2))
enddo
call HDF5_closeGroup(groupHandle(1))
end subroutine homogenization_restartRead
2012-08-10 21:28:17 +05:30
end module homogenization