focus on the physics

src/damage_local.f90

@@ -4,9 +4,13 @@
 !--------------------------------------------------------------------------------------------------
 module damage_local
  use prec
+ use material
+ use numerics
+ use config
 
  implicit none
  private
+ 
  integer,                       dimension(:,:),         allocatable, target, public :: &
    damage_local_sizePostResult                                                            !< size of each post result output
 
@@ -20,23 +24,22 @@ module damage_local
    enumerator :: undefined_ID, &
                  damage_ID
  end enum
- integer(kind(undefined_ID)),         dimension(:,:),         allocatable,          private :: & 
+ integer(kind(undefined_ID)),         dimension(:,:),         allocatable :: & 
    damage_local_outputID                                                                  !< ID of each post result output
    
- type, private :: tParameters
+ type :: tParameters
    integer(kind(undefined_ID)),         dimension(:),   allocatable   :: &
      outputID
  end type tParameters
  
- type(tparameters),          dimension(:), allocatable, private :: &
+ type(tparameters),          dimension(:), allocatable :: &
    param
    
  public :: &
    damage_local_init, &
    damage_local_updateState, &
    damage_local_postResults
- private :: &
+
-   damage_local_getSourceAndItsTangent  
 
 contains
 
@@ -45,21 +48,6 @@ contains
 !> @details reads in material parameters, allocates arrays, and does sanity checks
 !--------------------------------------------------------------------------------------------------
 subroutine damage_local_init
- use material, only: &
-   damage_type, &
-   damage_typeInstance, &
-   homogenization_Noutput, &
-   DAMAGE_local_label, &
-   DAMAGE_local_ID, &
-   material_homogenizationAt, & 
-   mappingHomogenization, & 
-   damageState, &
-   damageMapping, &
-   damage, &
-   damage_initialPhi
- use config, only: &
-   config_homogenization
- 
 
  integer :: maxNinstance,homog,instance,i
  integer :: sizeState
@@ -72,7 +60,7 @@ subroutine damage_local_init
  
  write(6,'(/,a)')   ' <<<+-  damage_'//DAMAGE_local_label//' init  -+>>>'
 
- maxNinstance = int(count(damage_type == DAMAGE_local_ID),pInt)
+ maxNinstance = count(damage_type == DAMAGE_local_ID)
  if (maxNinstance == 0) return
  
  allocate(damage_local_sizePostResult (maxval(homogenization_Noutput),maxNinstance),source=0)
@@ -135,14 +123,6 @@ end subroutine damage_local_init
 !> @brief  calculates local change in damage field   
 !--------------------------------------------------------------------------------------------------
 function damage_local_updateState(subdt, ip, el)
- use numerics, only: &
-   residualStiffness, &
-   err_damage_tolAbs, &
-   err_damage_tolRel
- use material, only: &
-   material_homogenizationAt, &
-   mappingHomogenization, &
-   damageState
  
  integer, intent(in) :: &
    ip, &                                                                                            !< integration point number
@@ -177,17 +157,6 @@ end function damage_local_updateState
 !> @brief  calculates homogenized local damage driving forces  
 !--------------------------------------------------------------------------------------------------
 subroutine damage_local_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el)
- use material, only: &
-   homogenization_Ngrains, &
-   material_homogenizationAt, &
-   phaseAt, &
-   phasememberAt, &
-   phase_source, &
-   phase_Nsources, &
-   SOURCE_damage_isoBrittle_ID, &
-   SOURCE_damage_isoDuctile_ID, &
-   SOURCE_damage_anisoBrittle_ID, &
-   SOURCE_damage_anisoDuctile_ID
  use source_damage_isoBrittle, only: &
    source_damage_isobrittle_getRateAndItsTangent
  use source_damage_isoDuctile, only: &
@@ -244,15 +213,11 @@ subroutine damage_local_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el
  
 end subroutine damage_local_getSourceAndItsTangent
 
+
 !--------------------------------------------------------------------------------------------------
 !> @brief return array of damage results
 !--------------------------------------------------------------------------------------------------
 function damage_local_postResults(ip,el)
- use material, only: &
-   material_homogenizationAt, &
-   damage_typeInstance, &
-   damageMapping, &
-   damage
 
  integer,              intent(in) :: &
    ip, &                                                                                            !< integration point

src/damage_none.f90

@@ -3,6 +3,8 @@
 !> @brief material subroutine for constant damage field
 !--------------------------------------------------------------------------------------------------
 module damage_none
+  use config
+  use material
 
   implicit none
   private
@@ -15,18 +17,8 @@ contains
 !--------------------------------------------------------------------------------------------------
 !> @brief allocates all neccessary fields, reads information from material configuration file
 !--------------------------------------------------------------------------------------------------
-subroutine damage_none_init()
+subroutine damage_none_init
-  use config, only: &
+
-    config_homogenization
-  use material, only: &
-    damage_initialPhi, &
-    damage, &
-    damage_type, &
-    material_homogenizationAt, &
-    damageState, &
-    DAMAGE_NONE_LABEL, &
-    DAMAGE_NONE_ID
-  
   integer :: &
     homog, &
     NofMyHomog

src/damage_nonlocal.f90

@@ -5,9 +5,16 @@
 !--------------------------------------------------------------------------------------------------
 module damage_nonlocal
  use prec
+ use material
+ use numerics
+ use config
+ use crystallite
+ use lattice
+ use mesh
 
  implicit none
  private
+ 
  integer,                       dimension(:,:),  allocatable, target, public :: &
    damage_nonlocal_sizePostResult                                                            !< size of each post result output
 
@@ -22,12 +29,12 @@ module damage_nonlocal
                  damage_ID
  end enum
 
- type, private :: tParameters
+ type :: tParameters
    integer(kind(undefined_ID)),         dimension(:),   allocatable   :: &
      outputID
  end type tParameters
  
- type(tparameters),          dimension(:), allocatable, private :: &
+ type(tparameters),          dimension(:), allocatable :: &
    param
 
  public :: &
@@ -45,21 +52,6 @@ contains
 !> @details reads in material parameters, allocates arrays, and does sanity checks
 !--------------------------------------------------------------------------------------------------
 subroutine damage_nonlocal_init
- use material, only: &
-   damage_type, &
-   damage_typeInstance, &
-   homogenization_Noutput, &
-   DAMAGE_nonlocal_label, &
-   DAMAGE_nonlocal_ID, &
-   material_homogenizationAt, & 
-   mappingHomogenization, & 
-   damageState, &
-   damageMapping, &
-   damage, &
-   damage_initialPhi
- use config, only: &
-   config_homogenization
-
 
  integer :: maxNinstance,homog,instance,o,i
  integer :: sizeState
@@ -72,7 +64,7 @@ subroutine damage_nonlocal_init
 
  write(6,'(/,a)')   ' <<<+-  damage_'//DAMAGE_nonlocal_label//' init  -+>>>'
  
- maxNinstance = int(count(damage_type == DAMAGE_nonlocal_ID))
+ maxNinstance = count(damage_type == DAMAGE_nonlocal_ID)
  if (maxNinstance == 0) return
  
  allocate(damage_nonlocal_sizePostResult (maxval(homogenization_Noutput),maxNinstance),source=0)
@@ -131,17 +123,6 @@ end subroutine damage_nonlocal_init
 !> @brief  calculates homogenized damage driving forces  
 !--------------------------------------------------------------------------------------------------
 subroutine damage_nonlocal_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el)
- use material, only: &
-   homogenization_Ngrains, &
-   material_homogenizationAt, &
-   phaseAt, &
-   phasememberAt, &
-   phase_source, &
-   phase_Nsources, &
-   SOURCE_damage_isoBrittle_ID, &
-   SOURCE_damage_isoDuctile_ID, &
-   SOURCE_damage_anisoBrittle_ID, &
-   SOURCE_damage_anisoDuctile_ID
  use source_damage_isoBrittle, only: &
    source_damage_isobrittle_getRateAndItsTangent
  use source_damage_isoDuctile, only: &
@@ -198,20 +179,11 @@ subroutine damage_nonlocal_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip,
  
 end subroutine damage_nonlocal_getSourceAndItsTangent
 
+
 !--------------------------------------------------------------------------------------------------
 !> @brief returns homogenized non local damage diffusion tensor in reference configuration
 !--------------------------------------------------------------------------------------------------
 function damage_nonlocal_getDiffusion33(ip,el)
- use numerics, only: &
-   charLength
- use lattice, only: &
-   lattice_DamageDiffusion33
- use material, only: &
-   homogenization_Ngrains, &
-   material_phase, &
-   material_homogenizationAt
- use crystallite, only: &
-   crystallite_push33ToRef
 
  integer, intent(in) :: &
    ip, &                                                                                            !< integration point number
@@ -234,17 +206,11 @@ function damage_nonlocal_getDiffusion33(ip,el)
  
 end function damage_nonlocal_getDiffusion33
  
+ 
 !--------------------------------------------------------------------------------------------------
 !> @brief Returns homogenized nonlocal damage mobility 
 !--------------------------------------------------------------------------------------------------
 real(pReal) function damage_nonlocal_getMobility(ip,el)
- use mesh, only: &
-   mesh_element
- use lattice, only: &
-   lattice_damageMobility
- use material, only: &
-   material_phase, &
-   homogenization_Ngrains
 
  integer, intent(in) :: &
    ip, &                                                                                            !< integration point number
@@ -263,14 +229,11 @@ real(pReal) function damage_nonlocal_getMobility(ip,el)
 
 end function damage_nonlocal_getMobility
 
+
 !--------------------------------------------------------------------------------------------------
 !> @brief updated nonlocal damage field with solution from damage phase field PDE
 !--------------------------------------------------------------------------------------------------
 subroutine damage_nonlocal_putNonLocalDamage(phi,ip,el)
- use material, only: &
-   material_homogenizationAt, &
-   damageMapping, &
-   damage
 
  integer, intent(in) :: &
    ip, &                                                                                            !< integration point number
@@ -286,16 +249,12 @@ subroutine damage_nonlocal_putNonLocalDamage(phi,ip,el)
  damage(homog)%p(offset) = phi
 
 end subroutine damage_nonlocal_putNonLocalDamage
- 
+
+
 !--------------------------------------------------------------------------------------------------
 !> @brief return array of damage results
 !--------------------------------------------------------------------------------------------------
 function damage_nonlocal_postResults(ip,el)
- use material, only: &
-   material_homogenizationAt, &
-   damage_typeInstance, &
-   damageMapping, &
-   damage
 
  integer,              intent(in) :: &
    ip, &                                                                                            !< integration point

src/kinematics_cleavage_opening.f90

@@ -5,13 +5,20 @@
 !> @details to be done
 !--------------------------------------------------------------------------------------------------
 module kinematics_cleavage_opening
- use prec
+  use prec
+  use IO
+  use config
+  use debug
+  use math
+  use lattice
+  use material
 
  implicit none
  private
- integer, dimension(:), allocatable, private :: kinematics_cleavage_opening_instance
 
- type, private :: tParameters                                                                       !< container type for internal constitutive parameters
+ integer, dimension(:), allocatable :: kinematics_cleavage_opening_instance
+
+ type :: tParameters                                                                                !< container type for internal constitutive parameters
    integer :: &
      totalNcleavage
    integer, dimension(:),   allocatable :: &
@@ -25,17 +32,17 @@ module kinematics_cleavage_opening
  end type
 
 ! Begin Deprecated
- integer,                       dimension(:),           allocatable,         private :: &
+ integer,                       dimension(:),           allocatable :: &
    kinematics_cleavage_opening_totalNcleavage                                                       !< total number of cleavage systems
    
- integer,                       dimension(:,:),         allocatable,         private :: &
+ integer,                       dimension(:,:),         allocatable :: &
    kinematics_cleavage_opening_Ncleavage                                                            !< number of cleavage systems per family
    
- real(pReal),                   dimension(:),           allocatable,         private :: &
+ real(pReal),                   dimension(:),           allocatable :: &
    kinematics_cleavage_opening_sdot_0, &
    kinematics_cleavage_opening_N
 
- real(pReal),                   dimension(:,:),         allocatable,         private :: &
+ real(pReal),                   dimension(:,:),         allocatable :: &
    kinematics_cleavage_opening_critDisp, &
    kinematics_cleavage_opening_critLoad
 ! End Deprecated
@@ -51,22 +58,7 @@ contains
 !> @brief module initialization
 !> @details reads in material parameters, allocates arrays, and does sanity checks
 !--------------------------------------------------------------------------------------------------
-subroutine kinematics_cleavage_opening_init()
+subroutine kinematics_cleavage_opening_init
- use debug, only: &
-   debug_level,&
-   debug_constitutive,&
-   debug_levelBasic
- use config, only: &
-   config_phase
- use IO, only: &
-   IO_error
- use material, only: &
-   phase_kinematics, &
-   KINEMATICS_cleavage_opening_label, &
-   KINEMATICS_cleavage_opening_ID
- use lattice, only: &
-   lattice_maxNcleavageFamily, &
-   lattice_NcleavageSystem
 
  integer, allocatable, dimension(:) :: tempInt
  real(pReal), allocatable, dimension(:) :: tempFloat
@@ -75,7 +67,7 @@ subroutine kinematics_cleavage_opening_init()
 
  write(6,'(/,a)')   ' <<<+-  kinematics_'//KINEMATICS_cleavage_opening_LABEL//' init  -+>>>'
 
- maxNinstance = int(count(phase_kinematics == KINEMATICS_cleavage_opening_ID))
+ maxNinstance = count(phase_kinematics == KINEMATICS_cleavage_opening_ID)
  if (maxNinstance == 0) return
  
  if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) &
@@ -127,17 +119,6 @@ end subroutine kinematics_cleavage_opening_init
 !> @brief  contains the constitutive equation for calculating the velocity gradient  
 !--------------------------------------------------------------------------------------------------
 subroutine kinematics_cleavage_opening_LiAndItsTangent(Ld, dLd_dTstar, S, ipc, ip, el)
- use math, only: &
-   math_mul33xx33
- use material, only: &
-   material_phase, &
-   material_homogenizationAt, &
-   damage, &
-   damageMapping
- use lattice, only: &
-   lattice_Scleavage, &
-   lattice_maxNcleavageFamily, &
-   lattice_NcleavageSystem
  
  integer, intent(in) :: &
    ipc, &                                                                                           !< grain number

src/kinematics_slipplane_opening.f90

@@ -6,12 +6,19 @@
 !--------------------------------------------------------------------------------------------------
 module kinematics_slipplane_opening
  use prec
+ use config
+ use IO
+ use debug
+ use math
+ use lattice
+ use material
 
  implicit none
  private
- integer, dimension(:), allocatable, private :: kinematics_slipplane_opening_instance
+ 
+ integer, dimension(:), allocatable :: kinematics_slipplane_opening_instance
    
- type, private :: tParameters                                                                       !< container type for internal constitutive parameters
+ type :: tParameters                                                                                !< container type for internal constitutive parameters
    integer :: &
      totalNslip
    integer, dimension(:),   allocatable :: &
@@ -19,7 +26,7 @@ module kinematics_slipplane_opening
    real(pReal) :: &
      sdot0, &
      n
-   real(pReal),   dimension(:),   allocatable :: &
+   real(pReal), dimension(:),   allocatable :: &
      critLoad
    real(pReal), dimension(:,:), allocatable     :: &
     slip_direction, &
@@ -27,7 +34,8 @@ module kinematics_slipplane_opening
     slip_transverse
  end type tParameters
 
-     type(tParameters), dimension(:), allocatable, private :: param                                     !< containers of constitutive parameters (len Ninstance)
+ type(tParameters), dimension(:), allocatable :: param                                            !< containers of constitutive parameters (len Ninstance)
+ 
  public :: &
    kinematics_slipplane_opening_init, &
    kinematics_slipplane_opening_LiAndItsTangent
@@ -39,23 +47,7 @@ contains
 !> @brief module initialization
 !> @details reads in material parameters, allocates arrays, and does sanity checks
 !--------------------------------------------------------------------------------------------------
-subroutine kinematics_slipplane_opening_init()
+subroutine kinematics_slipplane_opening_init
- use debug, only: &
-   debug_level,&
-   debug_constitutive,&
-   debug_levelBasic
- use config, only: &
-   config_phase
- use IO, only: &
-   IO_error
- use math, only: &
-   math_expand
- use material, only: &
-   phase_kinematics, &
-   KINEMATICS_slipplane_opening_label, &
-   KINEMATICS_slipplane_opening_ID
- use lattice
-
 
  integer :: maxNinstance,p,instance
 
@@ -111,14 +103,6 @@ end subroutine kinematics_slipplane_opening_init
 !> @brief  contains the constitutive equation for calculating the velocity gradient  
 !--------------------------------------------------------------------------------------------------
 subroutine kinematics_slipplane_opening_LiAndItsTangent(Ld, dLd_dTstar, S, ipc, ip, el)
- use math, only: &
-   math_mul33xx33, &
-   math_outer
- use material, only: &
-   material_phase, &
-   material_homogenizationAt, &
-   damage, &
-   damageMapping
 
  integer, intent(in) :: &
    ipc, &                                                                                           !< grain number

src/kinematics_thermal_expansion.f90

@@ -5,11 +5,17 @@
 !--------------------------------------------------------------------------------------------------
 module kinematics_thermal_expansion
   use prec
-
+  use IO
+  use config
+  use debug
+  use math
+  use lattice
+  use material
+  
   implicit none
   private
  
-  type, private :: tParameters
+  type :: tParameters
     real(pReal), allocatable, dimension(:,:,:) :: &
       expansion
   end type tParameters
@@ -28,19 +34,9 @@ contains
 !> @brief module initialization
 !> @details reads in material parameters, allocates arrays, and does sanity checks
 !--------------------------------------------------------------------------------------------------
-subroutine kinematics_thermal_expansion_init()
+subroutine kinematics_thermal_expansion_init
-  use debug, only: &
-    debug_level,&
-    debug_constitutive,&
-    debug_levelBasic
-  use material, only: &
-    phase_kinematics, &
-    KINEMATICS_thermal_expansion_label, &
-    KINEMATICS_thermal_expansion_ID
-  use config, only: &
-    config_phase
  
-  integer(pInt) :: &
+  integer :: &
     Ninstance, &
     p, i
   real(pReal),  dimension(:), allocatable :: &
@@ -48,14 +44,14 @@ subroutine kinematics_thermal_expansion_init()
   
   write(6,'(/,a)')   ' <<<+-  kinematics_'//KINEMATICS_thermal_expansion_LABEL//' init  -+>>>'
  
-  Ninstance = int(count(phase_kinematics == KINEMATICS_thermal_expansion_ID),pInt)
+  Ninstance = count(phase_kinematics == KINEMATICS_thermal_expansion_ID)
   
-  if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0_pInt) &
+  if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) &
     write(6,'(a16,1x,i5,/)') '# instances:',Ninstance
   
   allocate(param(Ninstance))
   
-  do p = 1_pInt, size(phase_kinematics)
+  do p = 1, size(phase_kinematics)
     if (all(phase_kinematics(:,p) /= KINEMATICS_thermal_expansion_ID)) cycle
     
     ! ToDo: Here we need to decide how to extend the concept of instances to
@@ -78,13 +74,8 @@ end subroutine kinematics_thermal_expansion_init
 !> @brief  report initial thermal strain based on current temperature deviation from reference
 !--------------------------------------------------------------------------------------------------
 pure function kinematics_thermal_expansion_initialStrain(homog,phase,offset)
-  use material, only: &
-    temperature
-  use lattice, only: &
-    lattice_thermalExpansion33, &
-    lattice_referenceTemperature
   
-  integer(pInt), intent(in) :: &
+  integer, intent(in) :: &
     phase, &
     homog, offset
   real(pReal), dimension(3,3) :: &
@@ -106,17 +97,8 @@ end function kinematics_thermal_expansion_initialStrain
 !> @brief  contains the constitutive equation for calculating the velocity gradient  
 !--------------------------------------------------------------------------------------------------
 subroutine kinematics_thermal_expansion_LiAndItsTangent(Li, dLi_dTstar, ipc, ip, el)
-  use material, only: &
-    material_phase, &
-   material_homogenizationAt, &
-    temperature, &
-    temperatureRate, &
-    thermalMapping
-  use lattice, only: &
-    lattice_thermalExpansion33, &
-    lattice_referenceTemperature
   
-  integer(pInt), intent(in) :: &
+  integer, intent(in) :: &
     ipc, &                                                                                           !< grain number
     ip, &                                                                                            !< integration point number
     el                                                                                               !< element number
@@ -124,7 +106,7 @@ subroutine kinematics_thermal_expansion_LiAndItsTangent(Li, dLi_dTstar, ipc, ip,
     Li                                                                                               !< thermal velocity gradient
   real(pReal),   intent(out), dimension(3,3,3,3) :: &
     dLi_dTstar                                                                                       !< derivative of Li with respect to Tstar (4th-order tensor defined to be zero)
-  integer(pInt) :: &
+  integer :: &
     phase, &
     homog, offset
   real(pReal) :: &

src/source_damage_anisoBrittle.f90

@@ -101,7 +101,7 @@ subroutine source_damage_anisoBrittle_init
 
  write(6,'(/,a)')   ' <<<+-  source_'//SOURCE_DAMAGE_ANISOBRITTLE_LABEL//' init  -+>>>'
 
- Ninstance = int(count(phase_source == SOURCE_damage_anisoBrittle_ID))
+ Ninstance = count(phase_source == SOURCE_damage_anisoBrittle_ID)
  if (Ninstance == 0) return
  
  if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) &

src/source_damage_isoBrittle.f90

@@ -84,7 +84,7 @@ subroutine source_damage_isoBrittle_init
  
  write(6,'(/,a)')   ' <<<+-  source_'//SOURCE_DAMAGE_ISOBRITTLE_LABEL//' init  -+>>>'
 
- Ninstance = int(count(phase_source == SOURCE_damage_isoBrittle_ID))
+ Ninstance = count(phase_source == SOURCE_damage_isoBrittle_ID)
  if (Ninstance == 0) return
  
  if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) &