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

3408 lines
180 KiB
Fortran
Raw Normal View History

changed enconding of all source files to UTF-8 without BOM (signature) Codepage 65001
2011-04-07 12:50:28 +05:30
! Copyright 2011 Max-Planck-Institut für Eisenforschung GmbH
added copyright text to all f90 (free) format files
2011-04-04 19:39:54 +05:30
!
! This file is part of DAMASK,
changed enconding of all source files to UTF-8 without BOM (signature) Codepage 65001
2011-04-07 12:50:28 +05:30
! the Düsseldorf Advanced MAterial Simulation Kit.
added copyright text to all f90 (free) format files
2011-04-04 19:39:54 +05:30
!
! DAMASK is free software: you can redistribute it and/or modify
! it under the terms of the GNU General Public License as published by
! the Free Software Foundation, either version 3 of the License, or
! (at your option) any later version.
!
! DAMASK is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with DAMASK. If not, see <http://www.gnu.org/licenses/>.
!
!##############################################################
added version information to all files do NOT edit text like this: $Id: constitutive_phenopowerlaw.f90 406 2009-08-31 14:13:10Z MPIE\f.roters $
2009-08-31 20:39:15 +05:30
!* $Id$
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!***************************************
!* Module: CRYSTALLITE *
!***************************************
!* contains: *
!* - _init *
!* - materialpoint_stressAndItsTangent *
!* - _partitionDeformation *
!* - _updateState *
transposed writing into t16 file (and screen/debug) did not work with just stating array(1:3,:)... fixed by using math_transpose3x3 (and similar) instead.
2011-01-24 20:32:19 +05:30
!* - _stressAndItsTangent *
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!* - _postResults *
!***************************************
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
MODULE crystallite
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
use prec, only: pReal, pInt
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
implicit none
private :: crystallite_integrateStateFPI, &
crystallite_integrateStateEuler, &
crystallite_integrateStateAdaptiveEuler, &
crystallite_integrateStateRK4, &
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
crystallite_integrateStateRKCK45, &
crystallite_integrateStress, &
crystallite_stateJump
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
! ****************************************************************
! *** General variables for the crystallite calculation ***
! ****************************************************************
Major Update: all modules are now correctly submitted
2009-07-01 16:25:31 +05:30
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
integer(pInt) crystallite_maxSizePostResults
integer(pInt), dimension(:), allocatable :: crystallite_sizePostResults
integer(pInt), dimension(:,:), allocatable :: crystallite_sizePostResult
character(len=64), dimension(:,:), allocatable :: crystallite_output ! name of each post result output
New array crystallite_symmetryID(i,g,e) is now filled during initialization run with 1 for bcc and fcc phase and 2 for hexagonal phase. The values are needed for misorientation calculations to apply the correct symmetry operators for cubic and hexagonal phases.
2010-04-19 15:33:34 +05:30
integer(pInt), dimension (:,:,:), allocatable :: &
crystallite_symmetryID ! crystallographic symmetry 1=cubic 2=hexagonal, needed in all orientation calcs
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
small readability improvement
2010-02-18 20:36:08 +05:30
real(pReal), dimension (:,:,:), allocatable :: &
crystallite_dt, & ! requested time increment of each grain
crystallite_subdt, & ! substepped time increment of each grain
crystallite_subFrac, & ! already calculated fraction of increment
crystallite_subStep, & ! size of next integration step
crystallite_Temperature, & ! Temp of each grain
crystallite_partionedTemperature0, & ! Temp of each grain at start of homog inc
statedamper has to be local (specific for each e,i,g); with a global damping we may produce spurious convergence
2010-04-29 13:11:29 +05:30
crystallite_subTemperature0, & ! Temp of each grain at start of crystallite inc
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_dotTemperature ! evolution of Temperature of each grain
small readability improvement
2010-02-18 20:36:08 +05:30
real(pReal), dimension (:,:,:,:), allocatable :: &
crystallite_Tstar_v, & ! current 2nd Piola-Kirchhoff stress vector (end of converged time step)
crystallite_Tstar0_v, & ! 2nd Piola-Kirchhoff stress vector at start of FE inc
crystallite_partionedTstar0_v, & ! 2nd Piola-Kirchhoff stress vector at start of homog inc
crystallite_subTstar0_v, & ! 2nd Piola-Kirchhoff stress vector at start of crystallite inc
New output can be requested from crystallite: (output) grainrotation it gives the deviation from the initial grain orientation in axis-angle representation with the angle in degrees.
2010-04-12 16:44:36 +05:30
crystallite_orientation, & ! orientation as quaternion
crystallite_orientation0, & ! initial orientation as quaternion
crystallite_rotation ! grain rotation away from initial orientation as axis-angle (in degrees)
small readability improvement
2010-02-18 20:36:08 +05:30
real(pReal), dimension (:,:,:,:,:), allocatable :: &
crystallite_Fe, & ! current "elastic" def grad (end of converged time step)
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
crystallite_subFe0,& ! "elastic" def grad at start of crystallite inc
small readability improvement
2010-02-18 20:36:08 +05:30
crystallite_Fp, & ! current plastic def grad (end of converged time step)
crystallite_invFp, & ! inverse of current plastic def grad (end of converged time step)
crystallite_Fp0, & ! plastic def grad at start of FE inc
crystallite_partionedFp0,& ! plastic def grad at start of homog inc
crystallite_subFp0,& ! plastic def grad at start of crystallite inc
crystallite_F0, & ! def grad at start of FE inc
crystallite_partionedF, & ! def grad to be reached at end of homog inc
crystallite_partionedF0, & ! def grad at start of homog inc
crystallite_subF, & ! def grad to be reached at end of crystallite inc
crystallite_subF0, & ! def grad at start of crystallite inc
crystallite_Lp, & ! current plastic velocitiy grad (end of converged time step)
crystallite_Lp0, & ! plastic velocitiy grad at start of FE inc
crystallite_partionedLp0,& ! plastic velocity grad at start of homog inc
crystallite_subLp0,& ! plastic velocity grad at start of crystallite inc
crystallite_P, & ! 1st Piola-Kirchhoff stress per grain
corrected (?) disorientation calc and introduced some new assisting functions
2010-04-28 22:49:58 +05:30
crystallite_disorientation ! disorientation between two neighboring ips (only calculated for single grain IPs)
small readability improvement
2010-02-18 20:36:08 +05:30
real(pReal), dimension (:,:,:,:,:,:,:), allocatable :: &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_dPdF, & ! current individual dPdF per grain (end of converged time step)
crystallite_dPdF0, & ! individual dPdF per grain at start of FE inc
crystallite_partioneddPdF0, & ! individual dPdF per grain at start of homog inc
small readability improvement
2010-02-18 20:36:08 +05:30
crystallite_fallbackdPdF ! dPdF fallback for non-converged grains (elastic prediction)
logical, dimension (:,:,:), allocatable :: &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_localPlasticity, & ! indicates this grain to have purely local constitutive law
small readability improvement
2010-02-18 20:36:08 +05:30
crystallite_requested, & ! flag to request crystallite calculation
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_todo, & ! flag to indicate need for further computation
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_converged ! convergence flag
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
CONTAINS
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!********************************************************************
! allocate and initialize per grain variables
!********************************************************************
Major Update: all modules are now correctly submitted
2009-07-01 16:25:31 +05:30
subroutine crystallite_init(Temperature)
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!*** variables and functions from other modules ***!
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
use, intrinsic :: iso_fortran_env ! to get compiler_version and compiler_options (at least for gfortran 4.6 at the moment)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
use debug, only: debug_info, &
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
debug_reset, &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
use math, only: math_I3, &
math_EulerToR, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_inv33, &
math_transpose33, &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
math_mul33xx33, &
math_mul33x33
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems, &
mesh_maxNips, &
mesh_maxNipNeighbors
use IO
use material
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
use lattice, only: lattice_symmetryType
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
use constitutive, only: constitutive_microstructure
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
use constitutive_phenopowerlaw, only: constitutive_phenopowerlaw_label, &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
constitutive_phenopowerlaw_structure
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
use constitutive_titanmod, only: constitutive_titanmod_label, &
constitutive_titanmod_structure
use constitutive_dislotwin, only: constitutive_dislotwin_label, &
constitutive_dislotwin_structure
use constitutive_nonlocal, only: constitutive_nonlocal_label, &
constitutive_nonlocal_structure
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
implicit none
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
integer(pInt), parameter :: myFile = 200_pInt, &
maxNchunks = 2_pInt
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!*** input variables ***!
real(pReal) Temperature
1) terminallyIll was reset before FE did cutback --> useless extra calculations of same problem over and over... 2) local stiffness calculation is now standard for non-local grains 3) stressLoopDistribution discriminates between (a) central solution and (b) stiffness perturbation 4) debugger is switched on as standard... (but verboseDebugger not!)
2010-09-06 21:36:41 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!*** output variables ***!
!*** local variables ***!
integer(pInt), dimension(1+2*maxNchunks) :: positions
integer(pInt) g, & ! grain number
i, & ! integration point number
e, & ! element number
gMax, & ! maximum number of grains
iMax, & ! maximum number of integration points
eMax, & ! maximum number of elements
nMax, & ! maximum number of ip neighbors
myNgrains, & ! number of grains in current IP
section, &
j, &
p, &
output, &
mySize, &
myStructure, & ! lattice structure
myPhase, &
removed unused variables
2011-04-13 19:46:22 +05:30
myMat
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
character(len=64) tag
character(len=1024) line
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP CRITICAL (write2out)
write(6,*)
write(6,*) '<<<+- crystallite init -+>>>'
write(6,*) '$Id$'
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
#include "compilation_info.f90"
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP END CRITICAL (write2out)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
gMax = homogenization_maxNgrains
iMax = mesh_maxNips
eMax = mesh_NcpElems
nMax = mesh_maxNipNeighbors
allocate(crystallite_Temperature(gMax,iMax,eMax)); crystallite_Temperature = Temperature
allocate(crystallite_partionedTemperature0(gMax,iMax,eMax)); crystallite_partionedTemperature0 = 0.0_pReal
allocate(crystallite_subTemperature0(gMax,iMax,eMax)); crystallite_subTemperature0 = 0.0_pReal
allocate(crystallite_dotTemperature(gMax,iMax,eMax)); crystallite_dotTemperature = 0.0_pReal
allocate(crystallite_Tstar0_v(6,gMax,iMax,eMax)); crystallite_Tstar0_v = 0.0_pReal
allocate(crystallite_partionedTstar0_v(6,gMax,iMax,eMax)); crystallite_partionedTstar0_v = 0.0_pReal
allocate(crystallite_subTstar0_v(6,gMax,iMax,eMax)); crystallite_subTstar0_v = 0.0_pReal
allocate(crystallite_Tstar_v(6,gMax,iMax,eMax)); crystallite_Tstar_v = 0.0_pReal
allocate(crystallite_P(3,3,gMax,iMax,eMax)); crystallite_P = 0.0_pReal
allocate(crystallite_F0(3,3,gMax,iMax,eMax)); crystallite_F0 = 0.0_pReal
allocate(crystallite_partionedF0(3,3,gMax,iMax,eMax)); crystallite_partionedF0 = 0.0_pReal
allocate(crystallite_partionedF(3,3,gMax,iMax,eMax)); crystallite_partionedF = 0.0_pReal
allocate(crystallite_subF0(3,3,gMax,iMax,eMax)); crystallite_subF0 = 0.0_pReal
allocate(crystallite_subF(3,3,gMax,iMax,eMax)); crystallite_subF = 0.0_pReal
allocate(crystallite_Fp0(3,3,gMax,iMax,eMax)); crystallite_Fp0 = 0.0_pReal
allocate(crystallite_partionedFp0(3,3,gMax,iMax,eMax)); crystallite_partionedFp0 = 0.0_pReal
allocate(crystallite_subFp0(3,3,gMax,iMax,eMax)); crystallite_subFp0 = 0.0_pReal
allocate(crystallite_Fp(3,3,gMax,iMax,eMax)); crystallite_Fp = 0.0_pReal
allocate(crystallite_invFp(3,3,gMax,iMax,eMax)); crystallite_invFp = 0.0_pReal
allocate(crystallite_Fe(3,3,gMax,iMax,eMax)); crystallite_Fe = 0.0_pReal
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
allocate(crystallite_subFe0(3,3,gMax,iMax,eMax)); crystallite_subFe0 = 0.0_pReal
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
allocate(crystallite_Lp0(3,3,gMax,iMax,eMax)); crystallite_Lp0 = 0.0_pReal
allocate(crystallite_partionedLp0(3,3,gMax,iMax,eMax)); crystallite_partionedLp0 = 0.0_pReal
allocate(crystallite_subLp0(3,3,gMax,iMax,eMax)); crystallite_subLp0 = 0.0_pReal
allocate(crystallite_Lp(3,3,gMax,iMax,eMax)); crystallite_Lp = 0.0_pReal
allocate(crystallite_dPdF(3,3,3,3,gMax,iMax,eMax)); crystallite_dPdF = 0.0_pReal
allocate(crystallite_dPdF0(3,3,3,3,gMax,iMax,eMax)); crystallite_dPdF0 = 0.0_pReal
allocate(crystallite_partioneddPdF0(3,3,3,3,gMax,iMax,eMax)); crystallite_partioneddPdF0 = 0.0_pReal
allocate(crystallite_fallbackdPdF(3,3,3,3,gMax,iMax,eMax)); crystallite_fallbackdPdF = 0.0_pReal
allocate(crystallite_dt(gMax,iMax,eMax)); crystallite_dt = 0.0_pReal
allocate(crystallite_subdt(gMax,iMax,eMax)); crystallite_subdt = 0.0_pReal
allocate(crystallite_subFrac(gMax,iMax,eMax)); crystallite_subFrac = 0.0_pReal
allocate(crystallite_subStep(gMax,iMax,eMax)); crystallite_subStep = 0.0_pReal
allocate(crystallite_orientation(4,gMax,iMax,eMax)); crystallite_orientation = 0.0_pReal
allocate(crystallite_orientation0(4,gMax,iMax,eMax)); crystallite_orientation0 = 0.0_pReal
allocate(crystallite_rotation(4,gMax,iMax,eMax)); crystallite_rotation = 0.0_pReal
allocate(crystallite_disorientation(4,nMax,gMax,iMax,eMax)); crystallite_disorientation = 0.0_pReal
missing line break
2012-02-13 20:51:03 +05:30
allocate(crystallite_symmetryID(gMax,iMax,eMax)); crystallite_symmetryID = 0_pInt
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
allocate(crystallite_localPlasticity(gMax,iMax,eMax)); crystallite_localPlasticity = .true.
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
allocate(crystallite_requested(gMax,iMax,eMax)); crystallite_requested = .false.
allocate(crystallite_todo(gMax,iMax,eMax)); crystallite_todo = .false.
allocate(crystallite_converged(gMax,iMax,eMax)); crystallite_converged = .true.
allocate(crystallite_output(maxval(crystallite_Noutput), &
material_Ncrystallite)) ; crystallite_output = ''
allocate(crystallite_sizePostResults(material_Ncrystallite)) ; crystallite_sizePostResults = 0_pInt
allocate(crystallite_sizePostResult(maxval(crystallite_Noutput), &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
material_Ncrystallite)) ; crystallite_sizePostResult = 0_pInt
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
if (.not. IO_open_jobFile_stat(myFile,material_localFileExt)) then ! no local material configuration present...
call IO_open_file(myFile,material_configFile) ! ...open material.config file
introduced alternative location for material configuration. If present, the >>>JOB.materialConfig<<< file takes precedence over the standard >>>material.config<<<
2011-08-02 15:44:16 +05:30
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
line = ''
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
section = 0_pInt
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
do while (IO_lc(IO_getTag(line,'<','>')) /= material_partCrystallite) ! wind forward to <crystallite>
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
read(myFile,'(a1024)',END=100) line
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo
do ! read thru sections of phase part
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
read(myFile,'(a1024)',END=100) line
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
if (IO_isBlank(line)) cycle ! skip empty lines
if (IO_getTag(line,'<','>') /= '') exit ! stop at next part
if (IO_getTag(line,'[',']') /= '') then ! next section
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
section = section + 1_pInt
output = 0_pInt ! reset output counter
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endif
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
if (section > 0_pInt) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
positions = IO_stringPos(line,maxNchunks)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
select case(tag)
case ('(output)')
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
output = output + 1_pInt
crystallite_output(output,section) = IO_lc(IO_stringValue(line,positions,2_pInt))
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
end select
endif
enddo
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
100 close(myFile)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do i = 1_pInt,material_Ncrystallite ! sanity checks
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do i = 1_pInt,material_Ncrystallite
do j = 1_pInt,crystallite_Noutput(i)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
select case(crystallite_output(j,i))
added "texture " as possible crystallite output => reports ID for later discrimination...
2011-03-22 19:10:27 +05:30
case('phase','texture','volume')
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
mySize = 1_pInt
added "texture " as possible crystallite output => reports ID for later discrimination...
2011-03-22 19:10:27 +05:30
case('orientation','grainrotation') ! orientation as quaternion, or deviation from initial grain orientation in axis-angle form (angle in degrees)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
mySize = 4_pInt
added "texture " as possible crystallite output => reports ID for later discrimination...
2011-03-22 19:10:27 +05:30
case('eulerangles') ! Bunge (3-1-3) Euler angles
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
mySize = 3_pInt
added total Green-Lagrange strain to crystallite outputs
2012-01-20 15:55:35 +05:30
case('defgrad','f','fe','fp','lp','e','ee','p','firstpiola','1stpiola','s','tstar','secondpiola','2ndpiola')
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
mySize = 9_pInt
added elastic stiffness matrix as crystallite output
2012-03-01 18:36:09 +05:30
case('elasmatrix')
mySize = 36_pInt
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
case default
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
mySize = 0_pInt
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
end select
if (mySize > 0_pInt) then ! any meaningful output found
crystallite_sizePostResult(j,i) = mySize
crystallite_sizePostResults(i) = crystallite_sizePostResults(i) + mySize
endif
enddo
enddo
max size of crystallite result is now based on actual use within the mesh, not just picking the largest chunk from the material.config file...
2011-06-08 14:46:48 +05:30
crystallite_maxSizePostResults = 0_pInt
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do j = 1_pInt,material_Nmicrostructure
max size of crystallite result is now based on actual use within the mesh, not just picking the largest chunk from the material.config file...
2011-06-08 14:46:48 +05:30
if (microstructure_active(j)) &
crystallite_maxSizePostResults = max(crystallite_maxSizePostResults,&
crystallite_sizePostResults(microstructure_crystallite(j)))
enddo
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
! write description file for crystallite output
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
call IO_write_jobFile(myFile,'outputCrystallite')
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do p = 1_pInt,material_Ncrystallite
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
write(myFile,*)
write(myFile,'(a)') '['//trim(crystallite_name(p))//']'
write(myFile,*)
do e = 1_pInt,crystallite_Noutput(p)
write(myFile,'(a,i4)') trim(crystallite_output(e,p))//char(9),crystallite_sizePostResult(e,p)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo
enddo
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
close(myFile)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP PARALLEL PRIVATE(myNgrains,myPhase,myMat,myStructure)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
* OpenMP does not like unbounded array subscripts in function calls * some write statements were still not enclosed by CRITICAL construct, some needed a MASTER construct
2010-11-11 18:44:53 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over all cp elements
myNgrains = homogenization_Ngrains(mesh_element(3,e)) ! look up homogenization-->grainCount
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do g = 1_pInt,myNgrains
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_Fp0(1:3,1:3,g,i,e) = math_EulerToR(material_EulerAngles(1:3,g,i,e)) ! plastic def gradient reflects init orientation
crystallite_F0(1:3,1:3,g,i,e) = math_I3
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_localPlasticity(g,i,e) = phase_localPlasticity(material_phase(g,i,e))
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP FLUSH(crystallite_Fp0)
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
crystallite_Fe(1:3,1:3,g,i,e) = math_transpose33(crystallite_Fp0(1:3,1:3,g,i,e))
crystallite_Fp has to be initialized in crystallite_init, cause it is used by constitutive_microstructure
2012-02-03 20:22:09 +05:30
crystallite_Fp(1:3,1:3,g,i,e) = crystallite_Fp0(1:3,1:3,g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
enddo
enddo
enddo
!$OMP ENDDO
crystallite_partionedTemperature0 = Temperature ! isothermal assumption
crystallite_partionedFp0 = crystallite_Fp0
crystallite_partionedF0 = crystallite_F0
crystallite_partionedF = crystallite_F0
crystallite_requested = .true.
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
homogenization_RGC.f90 >> just switching-off one of the debugging statement. crystallite.f90 >> optimizing the perturbation algorithm for local tangent.
2009-12-22 17:58:02 +05:30
New array crystallite_symmetryID(i,g,e) is now filled during initialization run with 1 for bcc and fcc phase and 2 for hexagonal phase. The values are needed for misorientation calculations to apply the correct symmetry operators for cubic and hexagonal phases.
2010-04-19 15:33:34 +05:30
! Initialize crystallite_symmetryID(g,i,e)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
New array crystallite_symmetryID(i,g,e) is now filled during initialization run with 1 for bcc and fcc phase and 2 for hexagonal phase. The values are needed for misorientation calculations to apply the correct symmetry operators for cubic and hexagonal phases.
2010-04-19 15:33:34 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
myNgrains = homogenization_Ngrains(mesh_element(3,e))
New array crystallite_symmetryID(i,g,e) is now filled during initialization run with 1 for bcc and fcc phase and 2 for hexagonal phase. The values are needed for misorientation calculations to apply the correct symmetry operators for cubic and hexagonal phases.
2010-04-19 15:33:34 +05:30
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do g = 1_pInt,myNgrains
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
myPhase = material_phase(g,i,e)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
myMat = phase_plasticityInstance(myPhase)
select case (phase_plasticity(myPhase))
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
case (constitutive_phenopowerlaw_label)
myStructure = constitutive_phenopowerlaw_structure(myMat)
case (constitutive_titanmod_label)
myStructure = constitutive_titanmod_structure(myMat)
case (constitutive_dislotwin_label)
myStructure = constitutive_dislotwin_structure(myMat)
case (constitutive_nonlocal_label)
myStructure = constitutive_nonlocal_structure(myMat)
case default
myStructure = -1_pInt ! does this happen for j2 material?
end select
if (myStructure > 0_pInt) then
crystallite_symmetryID(g,i,e) = lattice_symmetryType(myStructure) ! structure = 1(fcc) or 2(bcc) => 1; 3(hex)=>2
endif
New array crystallite_symmetryID(i,g,e) is now filled during initialization run with 1 for bcc and fcc phase and 2 for hexagonal phase. The values are needed for misorientation calculations to apply the correct symmetry operators for cubic and hexagonal phases.
2010-04-19 15:33:34 +05:30
enddo
enddo
enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
New output can be requested from crystallite: (output) grainrotation it gives the deviation from the initial grain orientation in axis-angle representation with the angle in degrees.
2010-04-12 16:44:36 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END PARALLEL
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
call crystallite_orientations()
crystallite_orientation0 = crystallite_orientation ! Store initial orientations for calculation of grain rotations
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
No need to call constitutive_microstructure at the beginning of each crystallite step, since it's already been done at the end of the previous step. Just do it once after initialization to start with correct values for the dependent state variables.
2011-03-21 16:05:42 +05:30
!$OMP PARALLEL DO PRIVATE(myNgrains)
do e = FEsolving_execElem(1),FEsolving_execElem(2)
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do g = 1_pInt,myNgrains
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
No need to call constitutive_microstructure at the beginning of each crystallite step, since it's already been done at the end of the previous step. Just do it once after initialization to start with correct values for the dependent state variables.
2011-03-21 16:05:42 +05:30
enddo
enddo
enddo
!$OMP END PARALLEL DO
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
call crystallite_stressAndItsTangent(.true.,.false.) ! request elastic answers
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_fallbackdPdF = crystallite_dPdF ! use initial elastic stiffness as fallback
! *** Output to MARC output file ***
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP CRITICAL (write2out)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Temperature: ', shape(crystallite_Temperature)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_dotTemperature: ', shape(crystallite_dotTemperature)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Fe: ', shape(crystallite_Fe)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Fp: ', shape(crystallite_Fp)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Lp: ', shape(crystallite_Lp)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_F0: ', shape(crystallite_F0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Fp0: ', shape(crystallite_Fp0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Lp0: ', shape(crystallite_Lp0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partionedF: ', shape(crystallite_partionedF)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partionedTemp0: ', shape(crystallite_partionedTemperature0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partionedF0: ', shape(crystallite_partionedF0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partionedFp0: ', shape(crystallite_partionedFp0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partionedLp0: ', shape(crystallite_partionedLp0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subF: ', shape(crystallite_subF)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subTemperature0: ', shape(crystallite_subTemperature0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_symmetryID: ', shape(crystallite_symmetryID)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subF0: ', shape(crystallite_subF0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subFe0: ', shape(crystallite_subFe0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subFp0: ', shape(crystallite_subFp0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subLp0: ', shape(crystallite_subLp0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_P: ', shape(crystallite_P)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Tstar_v: ', shape(crystallite_Tstar_v)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_Tstar0_v: ', shape(crystallite_Tstar0_v)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partionedTstar0_v: ', shape(crystallite_partionedTstar0_v)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subTstar0_v: ', shape(crystallite_subTstar0_v)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_dPdF: ', shape(crystallite_dPdF)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_dPdF0: ', shape(crystallite_dPdF0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_partioneddPdF0: ', shape(crystallite_partioneddPdF0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_fallbackdPdF: ', shape(crystallite_fallbackdPdF)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_orientation: ', shape(crystallite_orientation)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_orientation0: ', shape(crystallite_orientation0)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_rotation: ', shape(crystallite_rotation)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_disorientation: ', shape(crystallite_disorientation)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_dt: ', shape(crystallite_dt)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subdt: ', shape(crystallite_subdt)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subFrac: ', shape(crystallite_subFrac)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_subStep: ', shape(crystallite_subStep)
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
write(6,'(a35,1x,7(i8,1x))') 'crystallite_localPlasticity: ', shape(crystallite_localPlasticity)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a35,1x,7(i8,1x))') 'crystallite_requested: ', shape(crystallite_requested)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_todo: ', shape(crystallite_todo)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_converged: ', shape(crystallite_converged)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_sizePostResults: ', shape(crystallite_sizePostResults)
write(6,'(a35,1x,7(i8,1x))') 'crystallite_sizePostResult: ', shape(crystallite_sizePostResult)
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
write(6,*)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
write(6,*) 'Number of nonlocal grains: ',count(.not. crystallite_localPlasticity)
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
call flush(6)
!$OMP END CRITICAL (write2out)
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
call debug_info
call debug_reset
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_init
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!********************************************************************
! calculate stress (P) and tangent (dPdF) for crystallites
!********************************************************************
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
subroutine crystallite_stressAndItsTangent(updateJaco,rate_sensitivity)
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!*** variables and functions from other modules ***!
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
use numerics, only: subStepMinCryst, &
subStepSizeCryst, &
stepIncreaseCryst, &
pert_Fg, &
pert_method, &
nCryst, &
numerics_integrator, &
numerics_integrationMode, &
relevantStrain, &
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
analyticJaco
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
debug_e, &
debug_i, &
debug_g, &
debug_CrystalliteLoopDistribution
use IO, only: IO_warning
use math, only: math_inv33, &
math_identity2nd, &
math_transpose33, &
math_mul33x33, &
math_mul66x6, &
math_Mandel6to33, &
math_Mandel33to6, &
math_I3, &
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
math_mul3333xx3333
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems, &
mesh_maxNips
use material, only: homogenization_Ngrains, &
homogenization_maxNgrains
use constitutive, only: constitutive_sizeState, &
constitutive_sizeDotState, &
constitutive_state, &
constitutive_state_backup, &
constitutive_subState0, &
constitutive_partionedState0, &
constitutive_homogenizedC, &
constitutive_dotState, &
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
constitutive_dotState_backup, &
constitutive_TandItsTangent
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
implicit none
!*** input variables ***!
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
logical, intent(in) :: updateJaco, rate_sensitivity ! flag indicating wehther we want to update the Jacobian (stiffness) or not
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!*** local variables ***!
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
real(pReal) myPert, & ! perturbation with correct sign
formerSubStep
real(pReal), dimension(3,3) :: invFp, & ! inverse of the plastic deformation gradient
Fe_guess, & ! guess for elastic deformation gradient
Tstar ! 2nd Piola-Kirchhoff stress tensor
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
real(pReal), dimension(3,3,3,3,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
dPdF_perturbation1, &
dPdF_perturbation2
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
real(pReal), dimension(3,3,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
F_backup, &
Fp_backup, &
InvFp_backup, &
Fe_backup, &
Lp_backup, &
P_backup
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
real(pReal), dimension(6,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
Tstar_v_backup
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
real(pReal), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
Temperature_backup
integer(pInt) NiterationCrystallite, & ! number of iterations in crystallite loop
e, & ! element index
i, & ! integration point index
g, & ! grain index
k, &
l, &
o, &
p, &
perturbation , & ! loop counter for forward,backward perturbation mode
myNgrains, &
mySizeState, &
mySizeDotState
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
logical, dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
convergenceFlag_backup
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
! local variables used for calculating analytic Jacobian
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
real(pReal), dimension(3,3):: Fpinv_rate, &
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
FDot_inv, &
junk
real(pReal), dimension(3,3,3,3) :: dSdFe, &
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
dFedF, &
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
dFedFdot, &
dSdF, &
dSdFdot, &
first calculation of Tstar still used hard coded Hooke, now usese constitutive_TandItsTangent(...)
2012-06-18 12:56:34 +05:30
dFp_invdFdot, &
junk2
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
real(pReal) :: counter
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! --+>> INITIALIZE TO STARTING CONDITION <<+--
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if(iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt&
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. debug_e > 0 .and. debug_e <= mesh_NcpElems &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
.and. debug_i > 0 .and. debug_i <= mesh_maxNips &
.and. debug_g > 0 .and. debug_g <= homogenization_maxNgrains) then
!$OMP CRITICAL (write2out)
write (6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write (6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> crystallite start at el ip g ', debug_e, debug_i, debug_g
write (6,'(a,/,12x,f14.9)') '<< CRYST >> Temp0', crystallite_partionedTemperature0(debug_g,debug_i,debug_e)
write (6,'(a,/,3(12x,3(f14.9,1x)/))') '<< CRYST >> F0 ', &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33(crystallite_partionedF0(1:3,1:3,debug_g,debug_i,debug_e))
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write (6,'(a,/,3(12x,3(f14.9,1x)/))') '<< CRYST >> Fp0', &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33(crystallite_partionedFp0(1:3,1:3,debug_g,debug_i,debug_e))
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write (6,'(a,/,3(12x,3(f14.9,1x)/))') '<< CRYST >> Lp0', &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33(crystallite_partionedLp0(1:3,1:3,debug_g,debug_i,debug_e))
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
!$OMP END CRITICAL (write2out)
endif
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_subStep = 0.0_pReal
!$OMP PARALLEL DO PRIVATE(myNgrains)
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over elements to be processed
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element to be processed
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do g = 1_pInt,myNgrains
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
if (crystallite_requested(g,i,e)) then ! initialize restoration point of ...
crystallite_subTemperature0(g,i,e) = crystallite_partionedTemperature0(g,i,e) ! ...temperature
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
constitutive_subState0(g,i,e)%p = constitutive_partionedState0(g,i,e)%p ! ...microstructure
crystallite_subFp0(1:3,1:3,g,i,e) = crystallite_partionedFp0(1:3,1:3,g,i,e) ! ...plastic def grad
crystallite_subLp0(1:3,1:3,g,i,e) = crystallite_partionedLp0(1:3,1:3,g,i,e) ! ...plastic velocity grad
crystallite_dPdF0(1:3,1:3,1:3,1:3,g,i,e) = crystallite_partioneddPdF0(1:3,1:3,1:3,1:3,g,i,e) ! ...stiffness
crystallite_subF0(1:3,1:3,g,i,e) = crystallite_partionedF0(1:3,1:3,g,i,e) ! ...def grad
crystallite_subTstar0_v(1:6,g,i,e) = crystallite_partionedTstar0_v(1:6,g,i,e) !...2nd PK stress
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
crystallite_subFe0(1:3,1:3,g,i,e) = math_mul33x33(crystallite_subF0(1:3,1:3,g,i,e), &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_inv33(crystallite_subFp0(1:3,1:3,g,i,e))) ! only needed later on for stiffness calculation
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_subFrac(g,i,e) = 0.0_pReal
crystallite_subStep(g,i,e) = 1.0_pReal/subStepSizeCryst
crystallite_todo(g,i,e) = .true.
crystallite_converged(g,i,e) = .false. ! pretend failed step of twice the required size
endif
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
enddo
enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo
!$OMP END PARALLEL DO
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! --+>> CRYSTALLITE CUTBACK LOOP <<+--
homogenization_RGC.f90 >> just switching-off one of the debugging statement. crystallite.f90 >> optimizing the perturbation algorithm for local tangent.
2009-12-22 17:58:02 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
NiterationCrystallite = 0_pInt
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
numerics_integrationMode = 1_pInt
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
do while (any(crystallite_subStep(:,:,FEsolving_execELem(1):FEsolving_execElem(2)) > subStepMinCryst)) ! cutback loop for crystallites
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP PARALLEL DO PRIVATE(myNgrains,formerSubStep)
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over elements to be processed
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element to be processed
do g = 1,myNgrains
! --- wind forward ---
if (crystallite_converged(g,i,e)) then
formerSubStep = crystallite_subStep(g,i,e)
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
crystallite_subFrac(g,i,e) = crystallite_subFrac(g,i,e) + crystallite_subStep(g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP FLUSH(crystallite_subFrac)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_subStep(g,i,e) = min( 1.0_pReal - crystallite_subFrac(g,i,e), &
stepIncreaseCryst * crystallite_subStep(g,i,e) )
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP FLUSH(crystallite_subStep)
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
if (crystallite_subStep(g,i,e) > 0.0_pReal) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_subTemperature0(g,i,e) = crystallite_Temperature(g,i,e) ! wind forward...
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_subF0(1:3,1:3,g,i,e) = crystallite_subF(1:3,1:3,g,i,e) ! ...def grad
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
!$OMP FLUSH(crystallite_subF0)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_subFp0(1:3,1:3,g,i,e) = crystallite_Fp(1:3,1:3,g,i,e) ! ...plastic def grad
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
crystallite_subFe0(1:3,1:3,g,i,e) = math_mul33x33(crystallite_subF(1:3,1:3,g,i,e), crystallite_invFp(1:3,1:3,g,i,e)) ! only needed later on for stiffness calculation
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_subLp0(1:3,1:3,g,i,e) = crystallite_Lp(1:3,1:3,g,i,e) ! ...plastic velocity gradient
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
constitutive_subState0(g,i,e)%p = constitutive_state(g,i,e)%p ! ...microstructure
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_subTstar0_v(1:6,g,i,e) = crystallite_Tstar_v(1:6,g,i,e) ! ...2nd PK stress
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
crystallite_todo(g,i,e) = .true.
#ifndef _OPENMP
if (iand(debug_level(debug_crystallite),debug_levelBasic) /= 0_pInt &
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
write(6,'(a,f12.8,a,f12.8,a)') '<< CRYST >> winding forward from ', &
crystallite_subFrac(g,i,e)-formerSubStep,' to current crystallite_subfrac ', &
crystallite_subFrac(g,i,e),' in crystallite_stressAndItsTangent'
write(6,*)
endif
#endif
elseif (formerSubStep > 0.0_pReal) then ! this crystallite just converged
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite),debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP CRITICAL (distributionCrystallite)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
debug_CrystalliteLoopDistribution(min(nCryst+1_pInt,NiterationCrystallite)) = &
debug_CrystalliteLoopDistribution(min(nCryst+1_pInt,NiterationCrystallite)) + 1_pInt
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP END CRITICAL (distributionCrystallite)
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endif
! --- cutback ---
else
crystallite_subStep(g,i,e) = subStepSizeCryst * crystallite_subStep(g,i,e) ! cut step in half and restore...
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
!$OMP FLUSH(crystallite_subStep)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) ! ...temperature
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_Fp(1:3,1:3,g,i,e) = crystallite_subFp0(1:3,1:3,g,i,e) ! ...plastic def grad
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
crystallite_invFp(1:3,1:3,g,i,e) = math_inv33(crystallite_Fp(1:3,1:3,g,i,e))
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
!$OMP FLUSH(crystallite_invFp)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_Lp(1:3,1:3,g,i,e) = crystallite_subLp0(1:3,1:3,g,i,e) ! ...plastic velocity grad
constitutive_state(g,i,e)%p = constitutive_subState0(g,i,e)%p ! ...microstructure
crystallite_Tstar_v(1:6,g,i,e) = crystallite_subTstar0_v(1:6,g,i,e) ! ...2nd PK stress
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! cant restore dotState here, since not yet calculated in first cutback after initialization
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
crystallite_todo(g,i,e) = crystallite_subStep(g,i,e) > subStepMinCryst ! still on track or already done (beyond repair)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
if (crystallite_todo(g,i,e) &
.and. iand(debug_level(debug_crystallite),debug_levelBasic) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
added LF=UNIX to a bunch of files
2012-02-22 19:00:00 +05:30
write(6,'(a,f12.8)') '<< CRYST >> cutback step in crystallite_stressAndItsTangent with new crystallite_subStep: ',&
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
crystallite_subStep(g,i,e)
write(6,*)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endif
! --- prepare for integration ---
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_subF(1:3,1:3,g,i,e) = crystallite_subF0(1:3,1:3,g,i,e) &
+ crystallite_subStep(g,i,e) &
* (crystallite_partionedF(1:3,1:3,g,i,e) - crystallite_partionedF0(1:3,1:3,g,i,e))
!$OMP FLUSH(crystallite_subF)
crystallite_Fe(1:3,1:3,g,i,e) = math_mul33x33(crystallite_subF(1:3,1:3,g,i,e), crystallite_invFp(1:3,1:3,g,i,e))
crystallite_subdt(g,i,e) = crystallite_subStep(g,i,e) * crystallite_dt(g,i,e)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_converged(g,i,e) = .false. ! start out non-converged
endif
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
enddo
enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo
!$OMP END PARALLEL DO
homogenization_RGC.f90 >> just switching-off one of the debugging statement. crystallite.f90 >> optimizing the perturbation algorithm for local tangent.
2009-12-22 17:58:02 +05:30
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
! --- integrate --- requires fully defined state array (basic + dependent state)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
if (any(crystallite_todo)) then
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
select case(numerics_integrator(numerics_integrationMode))
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(1_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateFPI()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(2_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateEuler()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(3_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateAdaptiveEuler()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(4_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateRK4()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(5_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateRKCK45()
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endselect
endif
constitutive_nonlocal.f90 - completed postResults output function - connecting vector of neighboring material points is mapped to intermediate configuration of my neighbor crystallite.f90 - zero out dotState only when crystallite is non-finished - set nonfinished flag to false if crystallite is not on Track after state update - in updateState: set onTrack flag to false if encounter NaN - removed some old debugging outputs and added others homogenization.f90 - in debugging mode now telling when a cutback happens
2009-08-24 13:46:01 +05:30
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
NiterationCrystallite = NiterationCrystallite + 1_pInt
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo ! cutback loop
! --+>> CHECK FOR NON-CONVERGED CRYSTALLITES <<+--
!$OMP PARALLEL DO PRIVATE(myNgrains,invFp,Fe_guess,Tstar)
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over elements to be processed
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element to be processed
do g = 1,myNgrains
if (.not. crystallite_converged(g,i,e)) then ! respond fully elastically (might be not required due to becoming terminally ill anyway)
before turning terminally ill report at which g,i,e crystallite did not converge
2012-03-30 18:46:45 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if(iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
before turning terminally ill report at which g,i,e crystallite did not converge
2012-03-30 18:46:45 +05:30
write (6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> no convergence : respond fully elastic at el ip g ',e,i,g
write (6,*)
endif
#endif
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
invFp = math_inv33(crystallite_partionedFp0(1:3,1:3,g,i,e))
* OpenMP does not like unbounded array subscripts in function calls * some write statements were still not enclosed by CRITICAL construct, some needed a MASTER construct
2010-11-11 18:44:53 +05:30
Fe_guess = math_mul33x33(crystallite_partionedF(1:3,1:3,g,i,e), invFp)
first calculation of Tstar still used hard coded Hooke, now usese constitutive_TandItsTangent(...)
2012-06-18 12:56:34 +05:30
call constitutive_TandItsTangent(Tstar, junk2, Fe_guess,g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_P(1:3,1:3,g,i,e) = math_mul33x33(Fe_guess,math_mul33x33(Tstar,transpose(invFp)))
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if(iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite),debug_levelSelective) /= 0_pInt)) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write (6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> central solution of cryst_StressAndTangent at el ip g ',e,i,g
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write (6,*)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
write (6,'(a,/,3(12x,3(f12.4,1x)/))') '<< CRYST >> P / MPa', math_transpose33(crystallite_P(1:3,1:3,g,i,e))/1.0e6_pReal
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write (6,'(a,/,3(12x,3(f14.9,1x)/))') '<< CRYST >> Fp', math_transpose33(crystallite_Fp(1:3,1:3,g,i,e))
write (6,'(a,/,3(12x,3(f14.9,1x)/))') '<< CRYST >> Lp', math_transpose33(crystallite_Lp(1:3,1:3,g,i,e))
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write (6,*)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
enddo
enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo
!$OMP END PARALLEL DO
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! --+>> STIFFNESS CALCULATION <<+--
Tstar_v is now restored at different stages of cutbacking; we need this because preguess of state relies on consistent Tstar_v
2009-06-16 14:33:30 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
if(updateJaco) then ! Jacobian required
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
if (.not. analyticJaco) then ! Calculate Jacobian using perturbations
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
numerics_integrationMode = 2_pInt
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! --- BACKUP ---
!$OMP PARALLEL DO PRIVATE(myNgrains,mySizeState,mySizeDotState)
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over elements to be processed
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
myNgrains = homogenization_Ngrains(mesh_element(3,e))
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element to be processed
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
do g = 1,myNgrains
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
mySizeState = constitutive_sizeState(g,i,e) ! number of state variables for this grain
mySizeDotState = constitutive_sizeDotState(g,i,e) ! number of dotStates for this grain
leaner memory requirement to store states and their rates when calculating the crystallite stiffness
2010-09-13 14:43:25 +05:30
constitutive_state_backup(g,i,e)%p(1:mySizeState) = &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
constitutive_state(g,i,e)%p(1:mySizeState) ! remember unperturbed, converged state, ...
leaner memory requirement to store states and their rates when calculating the crystallite stiffness
2010-09-13 14:43:25 +05:30
constitutive_dotState_backup(g,i,e)%p(1:mySizeDotState) = &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
constitutive_dotState(g,i,e)%p(1:mySizeDotState) ! ... dotStates, ...
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END PARALLEL DO
Temperature_backup = crystallite_Temperature ! ... Temperature, ...
F_backup = crystallite_subF ! ... and kinematics
Fp_backup = crystallite_Fp
InvFp_backup = crystallite_invFp
Fe_backup = crystallite_Fe
Lp_backup = crystallite_Lp
Tstar_v_backup = crystallite_Tstar_v
P_backup = crystallite_P
convergenceFlag_backup = crystallite_converged
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! --- CALCULATE STATE AND STRESS FOR PERTURBATION ---
dPdF_perturbation1 = crystallite_dPdF0 ! initialize stiffness with known good values from last increment
dPdF_perturbation2 = crystallite_dPdF0 ! initialize stiffness with known good values from last increment
do perturbation = 1,2 ! forward and backward perturbation
if (iand(pert_method,perturbation) > 0) then ! mask for desired direction
myPert = -pert_Fg * (-1.0_pReal)**perturbation ! set perturbation step
do k = 1,3; do l = 1,3 ! ...alter individual components
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (write2out)
some f2008 standard related correction i didn't check in last time
2012-02-02 01:50:05 +05:30
write(6,'(a,2(1x,i1),1x,a)') '<< CRYST >> [[[[[[ Stiffness perturbation',k,l,']]]]]]'
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
write(6,*)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (write2out)
endif
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
#endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- INITIALIZE UNPERTURBED STATE ---
select case(numerics_integrator(numerics_integrationMode))
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(1_pInt) ! Fix-point method: restore to last converged state at end of subinc, since this is probably closest to perturbed state
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP PARALLEL DO PRIVATE(myNgrains,mySizeState,mySizeDotState)
do e = FEsolving_execElem(1),FEsolving_execElem(2)
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do g = 1_pInt,myNgrains
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
mySizeState = constitutive_sizeState(g,i,e)
mySizeDotState = constitutive_sizeDotState(g,i,e)
constitutive_state(g,i,e)%p(1:mySizeState) = constitutive_state_backup(g,i,e)%p(1:mySizeState)
constitutive_dotState(g,i,e)%p(1:mySizeDotState) = constitutive_dotState_backup(g,i,e)%p(1:mySizeDotState)
enddo; enddo; enddo
!OMP END PARALLEL DO
crystallite_Temperature = Temperature_backup
crystallite_Fp = Fp_backup
crystallite_invFp = InvFp_backup
crystallite_Fe = Fe_backup
crystallite_Lp = Lp_backup
crystallite_Tstar_v = Tstar_v_backup
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(2_pInt,3_pInt) ! explicit Euler methods: nothing to restore (except for F), since we are only doing a stress integration step
case(4_pInt,5_pInt) ! explicit Runge-Kutta methods: restore to start of subinc, since we are doing a full integration of state and stress
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP PARALLEL DO PRIVATE(myNgrains,mySizeState,mySizeDotState)
do e = FEsolving_execElem(1),FEsolving_execElem(2)
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do g = 1_pInt,myNgrains
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
mySizeState = constitutive_sizeState(g,i,e)
mySizeDotState = constitutive_sizeDotState(g,i,e)
constitutive_state(g,i,e)%p(1:mySizeState) = constitutive_subState0(g,i,e)%p(1:mySizeState)
constitutive_dotState(g,i,e)%p(1:mySizeDotState) = constitutive_dotState_backup(g,i,e)%p(1:mySizeDotState)
enddo; enddo; enddo
!OMP END PARALLEL DO
crystallite_Temperature = crystallite_subTemperature0
crystallite_Fp = crystallite_subFp0
crystallite_Fe = crystallite_subFe0
crystallite_Tstar_v = crystallite_subTstar0_v
end select
! --- PERTURB EITHER FORWARD OR BACKWARD ---
crystallite_subF = F_backup
crystallite_subF(k,l,:,:,:) = crystallite_subF(k,l,:,:,:) + myPert
crystallite_converged = convergenceFlag_backup
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
crystallite_todo = crystallite_requested .and. crystallite_converged
where (crystallite_todo) crystallite_converged = .false. ! start out non-converged
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
select case(numerics_integrator(numerics_integrationMode))
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(1_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateFPI()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(2_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateEuler()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(3_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateAdaptiveEuler()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(4_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateRK4()
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(5_pInt)
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
call crystallite_integrateStateRKCK45()
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
end select
!OMP PARALLEL DO PRIVATE(myNgrains)
- corrected an if statement in the state loop - nonlocal stiffness calculation: we perturb all material points at the same time, so instead of N^2 loops we just need N - set "forceLocalStiffnessCalculation" to false as standard
2010-03-04 22:57:39 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2)
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do g = 1_pInt,myNgrains
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
if (crystallite_requested(g,i,e) .and. crystallite_converged(g,i,e)) then ! converged state warrants stiffness update
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
select case(perturbation)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(1_pInt)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
dPdF_perturbation1(1:3,1:3,k,l,g,i,e) = (crystallite_P(1:3,1:3,g,i,e) - P_backup(1:3,1:3,g,i,e)) / myPert ! tangent dP_ij/dFg_kl
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(2_pInt)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
dPdF_perturbation2(1:3,1:3,k,l,g,i,e) = (crystallite_P(1:3,1:3,g,i,e) - P_backup(1:3,1:3,g,i,e)) / myPert ! tangent dP_ij/dFg_kl
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
end select
- corrected an if statement in the state loop - nonlocal stiffness calculation: we perturb all material points at the same time, so instead of N^2 loops we just need N - set "forceLocalStiffnessCalculation" to false as standard
2010-03-04 22:57:39 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!OMP END PARALLEL DO
enddo; enddo ! k,l loop
endif
enddo ! perturbation direction
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
! --- STIFFNESS ACCORDING TO PERTURBATION METHOD AND CONVERGENCE ---
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP PARALLEL DO PRIVATE(myNgrains)
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2)
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do g = 1_pInt,myNgrains
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
if (crystallite_requested(g,i,e) .and. convergenceFlag_backup(g,i,e)) then ! central solution converged
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
select case(pert_method)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(1_pInt)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dPdF(1:3,1:3,1:3,1:3,g,i,e) = dPdF_perturbation1(1:3,1:3,1:3,1:3,g,i,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(2_pInt)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dPdF(1:3,1:3,1:3,1:3,g,i,e) = dPdF_perturbation2(1:3,1:3,1:3,1:3,g,i,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
case(3_pInt)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dPdF(1:3,1:3,1:3,1:3,g,i,e) = 0.5_pReal* ( dPdF_perturbation1(1:3,1:3,1:3,1:3,g,i,e) &
+ dPdF_perturbation2(1:3,1:3,1:3,1:3,g,i,e))
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
end select
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
elseif (crystallite_requested(g,i,e) .and. .not. convergenceFlag_backup(g,i,e)) then ! central solution did not converge
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dPdF(1:3,1:3,1:3,1:3,g,i,e) = crystallite_fallbackdPdF(1:3,1:3,1:3,1:3,g,i,e) ! use (elastic) fallback
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
endif
did a lot of polishing: - removed unnecessary "return" before end of subroutine or function: - changed undetermined array length (:) to (1:3) To prevent problems with some code analysing tools: - "3D oneliner loops" (with ";) only for "do" and "enddo" at the same time - removed line continuation in OMP statements made the makefile more flexible, removed heap-arrays switch
2011-09-13 21:24:06 +05:30
enddo
enddo
enddo
!$OMP END PARALLEL DO
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- RESTORE ---
!$OMP PARALLEL DO PRIVATE(myNgrains,mySizeState,mySizeDotState)
do e = FEsolving_execElem(1),FEsolving_execElem(2)
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
do g = 1_pInt,myNgrains
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
mySizeState = constitutive_sizeState(g,i,e)
mySizeDotState = constitutive_sizeDotState(g,i,e)
constitutive_state(g,i,e)%p(1:mySizeState) = constitutive_state_backup(g,i,e)%p(1:mySizeState)
constitutive_dotState(g,i,e)%p(1:mySizeDotState) = constitutive_dotState_backup(g,i,e)%p(1:mySizeDotState)
enddo; enddo; enddo
!OMP END PARALLEL DO
crystallite_Temperature = Temperature_backup
crystallite_subF = F_backup
crystallite_Fp = Fp_backup
crystallite_invFp = InvFp_backup
crystallite_Fe = Fe_backup
crystallite_Lp = Lp_backup
crystallite_Tstar_v = Tstar_v_backup
crystallite_P = P_backup
crystallite_converged = convergenceFlag_backup
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
else ! Calculate Jacobian using analytical expression
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
! --- CALCULATE ANALYTIC dPdF ---
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
!$OMP PARALLEL DO PRIVATE(dFedF,dSdF,dSdFe,myNgrains)
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over elements to be processed
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element to be processed
do g = 1_pInt,myNgrains
dFedF = 0.0_pReal
do p=1_pInt,3_pInt; do o=1_pInt,3_pInt
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
dFedF(p,o,o,1:3) = crystallite_invFp(1:3,p,g,i,e) ! dFe^T_ij/dF_kl = delta_jk * (Fp current^-1)_li
enddo; enddo
call constitutive_TandItsTangent(junk,dSdFe,crystallite_subFe0(1:3,1:3,g,i,e),g,i,e) ! call constitutive law to calculate 2nd Piola-Kirchhoff stress and its derivative
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
dSdF = math_mul3333xx3333(dSdFe,dFedF) ! dS/dF = dS/dFe * dFe/dF
do p=1_pInt,3_pInt; do o=1_pInt,3_pInt
crystallite_dPdF(1:3,1:3,o,p,g,i,e) = math_mul33x33(math_mul33x33(dFedF(1:3,1:3,o,p),&
math_Mandel6to33(crystallite_Tstar_v)),math_transpose33(&
crystallite_invFp(1:3,1:3,g,i,e))) & ! dP/dF = dFe/dF * S * Fp^-T...
+ math_mul33x33(crystallite_subFe0(1:3,1:3,g,i,e),&
math_mul33x33(dSdF(1:3,1:3,o,p),math_transpose33(crystallite_invFp(1:3,1:3,g,i,e)))) ! + Fe * dS/dF * Fp^-T
enddo; enddo
enddo; enddo; enddo
!$OMP END PARALLEL DO
endif
if (rate_sensitivity) then
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
!$OMP PARALLEL DO PRIVATE(dFedFdot,dSdFdot,dSdFe,Fpinv_rate,FDot_inv,counter,dFp_invdFdot,myNgrains)
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2) ! iterate over elements to be processed
myNgrains = homogenization_Ngrains(mesh_element(3,e))
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) ! iterate over IPs of this element to be processed
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
do g = 1_pInt,myNgrains
Fpinv_rate = math_mul33x33(crystallite_invFp(1:3,1:3,g,i,e),crystallite_Lp(1:3,1:3,g,i,e)) ! dFp^-1 = dFp^-1/dt *dt... dFp may overshoot dF by small ammount as
FDot_inv = crystallite_subF(1:3,1:3,g,i,e) - crystallite_F0(1:3,1:3,g,i,e)
Added stress-order terms to analytic stiffness
2012-02-27 23:10:28 +05:30
counter = 0.0_pReal
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
do p=1_pInt,3_pInt; do o=1_pInt,3_pInt
if (abs(FDot_inv(o,p)) .lt. relevantStrain) then
FDot_inv(o,p) = 0.0_pReal
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
else
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
counter = counter + 1.0_pReal
FDot_inv(o,p) = crystallite_dt(g,i,e)/FDot_inv(o,p)
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
endif
enddo; enddo
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
if (counter .gt. 0.0_pReal) FDot_inv = FDot_inv/counter
do p=1_pInt,3_pInt; do o=1_pInt,3_pInt
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
dFp_invdFdot(o,p,1:3,1:3) = Fpinv_rate(o,p)*FDot_inv
added time_sensitive flag to ignore or add time sensitive component to analytic jacobian (should be close to perturbed jacobian when ignored) now uses sub_dt for analytic jacobian calculations bug fixes
2012-03-02 01:12:43 +05:30
enddo; enddo
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
do p=1_pInt,3_pInt; do o=1_pInt,3_pInt
dFedFdot(1:3,1:3,o,p) = math_transpose33(math_mul33x33(crystallite_subF(1:3,1:3,g,i,e), &
dFp_invdFdot(1:3,1:3,o,p)))
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
enddo; enddo
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
call constitutive_TandItsTangent(junk,dSdFe,crystallite_subFe0(1:3,1:3,g,i,e),g,i,e) ! call constitutive law to calculate 2nd Piola-Kirchhoff stress and its derivative
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
dSdFdot = math_mul3333xx3333(dSdFe,dFedFdot)
do p=1_pInt,3_pInt; do o=1_pInt,3_pInt
crystallite_dPdF(1:3,1:3,o,p,g,i,e) = crystallite_dPdF(1:3,1:3,o,p,g,i,e) - &
(math_mul33x33(math_mul33x33(dFedFdot(1:3,1:3,o,p), &
math_Mandel6to33(crystallite_Tstar_v)),math_transpose33( &
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
crystallite_invFp(1:3,1:3,g,i,e))) + & ! dP/dFdot = dFe/dFdot * S * Fp^-T...
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
math_mul33x33(math_mul33x33(crystallite_subFe0(1:3,1:3,g,i,e), &
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
math_Mandel6to33(crystallite_Tstar_v)),math_transpose33(dFp_invdFdot(1:3,1:3,o,p))) & ! + Fe * S * dFp^-T/dFdot...
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
+ math_mul33x33(crystallite_subFe0(1:3,1:3,g,i,e), &
dPdF calculations made consistent with constitutive_TandItsTangent
2012-03-21 20:30:36 +05:30
math_mul33x33(dSdFdot(1:3,1:3,o,p),math_transpose33(crystallite_invFp(1:3,1:3,g,i,e))))) ! + Fe * dS/dFdot * Fp^-T
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
enddo; enddo
simplified analytic jacobian calculation. removed Lpfrac, time_sensitive. introduced rate_sensitivity flag when calling crystallite_stressAndItsTangent that is currently set to .false. and is to be set according to which dPdF the FE solver is asking for
2012-03-14 19:26:50 +05:30
enddo; enddo; enddo
fixed bug in calculation of analytic jacobian (should work much better now). parallelized analytic jacobian calculation loop
2012-02-24 19:37:46 +05:30
!$OMP END PARALLEL DO
crystallite.f90: can now calculate analytic jacobian by setting analyticJaco = 1 in numerics.config math.f90: added math_mul3333xx3333… numerics.f90: to read in analyticJaco and Lp_frac
2012-02-23 01:41:09 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif ! jacobian calculation
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_stressAndItsTangent
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
!********************************************************************
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! integrate stress, state and Temperature with
! 4h order explicit Runge Kutta method
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
!********************************************************************
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
subroutine crystallite_integrateStateRK4(gg,ii,ee)
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** variables and functions from other modules ***!
use prec, only: pInt, &
pReal
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
use numerics, only: numerics_integrationMode
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
debug_e, &
debug_i, &
debug_g, &
debug_StateLoopDistribution
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems, &
mesh_maxNips
use material, only: homogenization_Ngrains, &
homogenization_maxNgrains
use constitutive, only: constitutive_sizeDotState, &
constitutive_state, &
constitutive_subState0, &
constitutive_dotState, &
constitutive_RK4dotState, &
constitutive_collectDotState, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
constitutive_deltaState, &
constitutive_collectDeltaState, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
constitutive_dotTemperature, &
constitutive_microstructure
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
implicit none
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
replaced variable fraction by "timefraction"
2012-01-26 18:18:59 +05:30
real(pReal), dimension(4), parameter :: timeStepFraction = (/0.5_pReal, 0.5_pReal, 1.0_pReal, 1.0_pReal/) ! factor giving the fraction of the original timestep used for Runge Kutta Integration
real(pReal), dimension(4), parameter :: weight = (/1.0_pReal, 2.0_pReal, 2.0_pReal, 1.0_pReal/) ! weight of slope used for Runge Kutta integration
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** input variables ***!
integer(pInt), optional, intent(in):: ee, & ! element index
ii, & ! integration point index
gg ! grain index
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** output variables ***!
quite some changes: # non-greedy memory allocation # generation of outputConstitutive to allow for script-based T16 extraction # exchange of phenomenological by more general phenopowerlaw # lattice is based on slip and twin families which can be treated as individual entities (switched on/off, separate hardening, etc.) # nicer debugging output # changed some error/warning codes # plus potentially some minor additional brushes here and there
2009-07-22 21:37:19 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** local variables ***!
integer(pInt) e, & ! element index in element loop
i, & ! integration point index in ip loop
g, & ! grain index in grain loop
n, &
mySizeDotState
integer(pInt), dimension(2) :: eIter ! bounds for element iteration
integer(pInt), dimension(2,mesh_NcpElems) :: iIter, & ! bounds for ip iteration
gIter ! bounds for grain iteration
real(pReal), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
RK4dotTemperature ! evolution of Temperature of each grain for Runge Kutta integration
logical singleRun ! flag indicating computation for single (g,i,e) triple
if (present(ee) .and. present(ii) .and. present(gg)) then
eIter = ee
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,ee) = ii
gIter(1:2,ee) = gg
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
singleRun = .true.
else
eIter = FEsolving_execElem(1:2)
do e = eIter(1),eIter(2)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,e) = FEsolving_execIP(1:2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
gIter(1:2,e) = [ 1_pInt,homogenization_Ngrains(mesh_element(3,e))]
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo
singleRun = .false.
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP PARALLEL PRIVATE(mySizeDotState)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- FIRST RUNGE KUTTA STEP ---
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
RK4dotTemperature = 0.0_pReal ! initialize Runge-Kutta dotTemperature
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
constitutive_RK4dotState(g,i,e)%p = 0.0_pReal ! initialize Runge-Kutta dotState
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
* removed calculations for dipole formation/dissociation by stress change, since it is not used anyways; also removed associated constitutive outputs from material.config * removed input variables in constitutive_collectDotState and constitutive_postResults that are not needed anymore (because of recent changes in constitutive_nonlocal)
2011-02-25 15:23:20 +05:30
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_Temperature(g,i,e),g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p /= constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e) /= crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- SECOND TO FOURTH RUNGE KUTTA STEP PLUS FINAL INTEGRATION ---
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do n = 1_pInt,4_pInt
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- state update ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
if (n < 4) then
constitutive_RK4dotState(g,i,e)%p = constitutive_RK4dotState(g,i,e)%p + weight(n)*constitutive_dotState(g,i,e)%p
RK4dotTemperature(g,i,e) = RK4dotTemperature(g,i,e) + weight(n)*crystallite_dotTemperature(g,i,e)
elseif (n == 4) then
edited lines exceeding 132 chars (before any comment started)
2012-01-11 22:26:35 +05:30
constitutive_dotState(g,i,e)%p = (constitutive_RK4dotState(g,i,e)%p + &
weight(n)*constitutive_dotState(g,i,e)%p) / 6.0_pReal ! use weighted RKdotState for final integration
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dotTemperature(g,i,e) = (RK4dotTemperature(g,i,e) + weight(n)*crystallite_dotTemperature(g,i,e)) / 6.0_pReal
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
+ constitutive_dotState(g,i,e)%p(1:mySizeDotState) * crystallite_subdt(g,i,e) * timeStepFraction(n)
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) &
+ crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e) * timeStepFraction(n)
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
if (n == 4) then ! final integration step
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
mySizeDotState = constitutive_sizeDotState(g,i,e)
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> updateState at el ip g ',e,i,g
write(6,*)
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> dotState', constitutive_dotState(g,i,e)%p(1:mySizeDotState)
write(6,*)
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> new state', constitutive_state(g,i,e)%p(1:mySizeDotState)
write(6,*)
endif
#endif
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- update dependent states ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- stress integration ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
if (.not. crystallite_integrateStress(g,i,e,timeStepFraction(n))) then ! fraction of original times step
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- dot state and RK dot state---
if (n < 4) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
* removed calculations for dipole formation/dissociation by stress change, since it is not used anyways; also removed associated constitutive outputs from material.config * removed input variables in constitutive_collectDotState and constitutive_postResults that are not needed anymore (because of recent changes in constitutive_nonlocal)
2011-02-25 15:23:20 +05:30
crystallite_Temperature(g,i,e), timeStepFraction(n)*crystallite_subdt(g,i,e), & ! fraction of original timestep
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
crystallite_orientation, g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_Temperature(g,i,e),g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p /= constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e) /= crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- STATE JUMP ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e) .and. crystallite_converged(g,i,e)) then
if (.not. crystallite_stateJump(g,i,e)) then
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
else ! broken local ...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
! --- SET CONVERGENCE FLAG ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
crystallite_converged(g,i,e) = .true. ! if still "to do" then converged per definitionem
crystallite_todo(g,i,e) = .false. ! ... integration done
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
!$OMP CRITICAL (distributionState)
debug_StateLoopDistribution(6,numerics_integrationMode) = &
debug_StateLoopDistribution(6,numerics_integrationMode) + 1_pInt
!$OMP END CRITICAL (distributionState)
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END PARALLEL
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- CHECK NONLOCAL CONVERGENCE ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
* check convergence for nonlocals also in stiffness calculation mode
2011-02-09 14:09:07 +05:30
if (.not. singleRun) then ! if not requesting Integration of just a single IP
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (any(.not. crystallite_converged .and. .not. crystallite_localPlasticity)) then ! any non-local not yet converged (or broken)...
crystallite_converged = crystallite_converged .and. crystallite_localPlasticity ! ...restart all non-local as not converged
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_integrateStateRK4
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!********************************************************************
! integrate stress, state and Temperature with
! 5th order Runge-Kutta Cash-Karp method with adaptive step size
! (use 5th order solution to advance = "local extrapolation")
!********************************************************************
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
subroutine crystallite_integrateStateRKCK45(gg,ii,ee)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** variables and functions from other modules ***!
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
debug_e, &
debug_i, &
debug_g, &
debug_StateLoopDistribution
use numerics, only: rTol_crystalliteState, &
rTol_crystalliteTemperature, &
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
numerics_integrationMode
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
use FEsolving, only: FEsolving_execElem, &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
FEsolving_execIP
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
use mesh, only: mesh_element, &
mesh_NcpElems, &
mesh_maxNips
use material, only: homogenization_Ngrains, &
homogenization_maxNgrains
use constitutive, only: constitutive_sizeDotState, &
constitutive_maxSizeDotState, &
constitutive_state, &
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
constitutive_aTolState, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
constitutive_subState0, &
constitutive_dotState, &
constitutive_RKCK45dotState, &
constitutive_collectDotState, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
constitutive_deltaState, &
constitutive_collectDeltaState, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
constitutive_dotTemperature, &
constitutive_microstructure
implicit none
!*** input variables ***!
integer(pInt), optional, intent(in):: ee, & ! element index
ii, & ! integration point index
gg ! grain index
!*** local variables ***!
integer(pInt) e, & ! element index in element loop
i, & ! integration point index in ip loop
g, & ! grain index in grain loop
n, & ! stage index in integration stage loop
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
mySizeDotState, & ! size of dot State
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
s ! state index
integer(pInt), dimension(2) :: eIter ! bounds for element iteration
integer(pInt), dimension(2,mesh_NcpElems) :: iIter, & ! bounds for ip iteration
gIter ! bounds for grain iteration
real(pReal), dimension(6,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
RKCK45dotTemperature ! evolution of Temperature of each grain for Runge Kutta Cash Karp integration
real(pReal), dimension(5,5) :: a ! coefficients in Butcher tableau (used for preliminary integration in stages 2 to 6)
real(pReal), dimension(6) :: b, db ! coefficients in Butcher tableau (used for final integration and error estimate)
real(pReal), dimension(5) :: c ! coefficients in Butcher tableau (fractions of original time step in stages 2 to 6)
real(pReal), dimension(constitutive_maxSizeDotState,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
stateResiduum, & ! residuum from evolution in micrstructure
relStateResiduum ! relative residuum from evolution in microstructure
real(pReal), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
temperatureResiduum, & ! residuum from evolution in temperature
relTemperatureResiduum ! relative residuum from evolution in temperature
logical singleRun ! flag indicating computation for single (g,i,e) triple
! --- FILL BUTCHER TABLEAU ---
a = 0.0_pReal
b = 0.0_pReal
db = 0.0_pReal
c = 0.0_pReal
a(1,1) = 0.2_pReal
a(1,2) = 0.075_pReal
a(2,2) = 0.225_pReal
a(1,3) = 0.3_pReal
a(2,3) = -0.9_pReal
a(3,3) = 1.2_pReal
a(1,4) = -11.0_pReal / 54.0_pReal
a(2,4) = 2.5_pReal
a(3,4) = -70.0_pReal / 27.0_pReal
a(4,4) = 35.0_pReal / 27.0_pReal
a(1,5) = 1631.0_pReal / 55296.0_pReal
a(2,5) = 175.0_pReal / 512.0_pReal
a(3,5) = 575.0_pReal / 13824.0_pReal
a(4,5) = 44275.0_pReal / 110592.0_pReal
a(5,5) = 253.0_pReal / 4096.0_pReal
b(1) = 37.0_pReal / 378.0_pReal
b(3) = 250.0_pReal / 621.0_pReal
b(4) = 125.0_pReal / 594.0_pReal
b(6) = 512.0_pReal / 1771.0_pReal
db(1) = b(1) - 2825.0_pReal / 27648.0_pReal
db(3) = b(3) - 18575.0_pReal / 48384.0_pReal
db(4) = b(4) - 13525.0_pReal / 55296.0_pReal
db(5) = - 277.0_pReal / 14336.0_pReal
db(6) = b(6) - 0.25_pReal
c(1) = 0.2_pReal
c(2) = 0.3_pReal
c(3) = 0.6_pReal
c(4) = 1.0_pReal
c(5) = 0.875_pReal
! --- LOOP ITERATOR FOR ELEMENT, GRAIN, IP ---
if (present(ee) .and. present(ii) .and. present(gg)) then
eIter = ee
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,ee) = ii
gIter(1:2,ee) = gg
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
singleRun = .true.
else
eIter = FEsolving_execElem(1:2)
do e = eIter(1),eIter(2)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,e) = FEsolving_execIP(1:2,e)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
gIter(1:2,e) = [1_pInt,homogenization_Ngrains(mesh_element(3,e))]
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo
singleRun = .false.
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP PARALLEL PRIVATE(mySizeDotState)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- FIRST RUNGE KUTTA STEP ---
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,1x,i1)') '<< CRYST >> RUNGE KUTTA STEP',1
* OpenMP does not like unbounded array subscripts in function calls * some write statements were still not enclosed by CRITICAL construct, some needed a MASTER construct
2010-11-11 18:44:53 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
* removed calculations for dipole formation/dissociation by stress change, since it is not used anyways; also removed associated constitutive outputs from material.config * removed input variables in constitutive_collectDotState and constitutive_postResults that are not needed anymore (because of recent changes in constitutive_nonlocal)
2011-02-25 15:23:20 +05:30
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_Temperature(g,i,e),g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
enddo; enddo; enddo
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p /= constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e) /= crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- SECOND TO SIXTH RUNGE KUTTA STEP ---
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do n = 1_pInt,5_pInt
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- state update ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
mySizeDotState = constitutive_sizeDotState(g,i,e)
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
constitutive_RKCK45dotState(n,g,i,e)%p = constitutive_dotState(g,i,e)%p ! store Runge-Kutta dotState
RKCK45dotTemperature(n,g,i,e) = crystallite_dotTemperature(g,i,e) ! store Runge-Kutta dotTemperature
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if (n == 1) then ! NEED TO DO THE ADDITION IN THIS LENGTHY WAY BECAUSE OF PARALLELIZATION (CAN'T USE A REDUCTION CLAUSE ON A POINTER OR USER DEFINED TYPE)
constitutive_dotState(g,i,e)%p = a(1,1) * constitutive_RKCK45dotState(1,g,i,e)%p
crystallite_dotTemperature(g,i,e) = a(1,1) * RKCK45dotTemperature(1,g,i,e)
elseif (n == 2) then
constitutive_dotState(g,i,e)%p = a(1,2) * constitutive_RKCK45dotState(1,g,i,e)%p &
+ a(2,2) * constitutive_RKCK45dotState(2,g,i,e)%p
crystallite_dotTemperature(g,i,e) = a(1,2) * RKCK45dotTemperature(1,g,i,e) &
+ a(2,2) * RKCK45dotTemperature(2,g,i,e)
elseif (n == 3) then
constitutive_dotState(g,i,e)%p = a(1,3) * constitutive_RKCK45dotState(1,g,i,e)%p &
+ a(2,3) * constitutive_RKCK45dotState(2,g,i,e)%p &
+ a(3,3) * constitutive_RKCK45dotState(3,g,i,e)%p
crystallite_dotTemperature(g,i,e) = a(1,3) * RKCK45dotTemperature(1,g,i,e) &
+ a(2,3) * RKCK45dotTemperature(2,g,i,e) &
+ a(3,3) * RKCK45dotTemperature(3,g,i,e)
elseif (n == 4) then
constitutive_dotState(g,i,e)%p = a(1,4) * constitutive_RKCK45dotState(1,g,i,e)%p &
+ a(2,4) * constitutive_RKCK45dotState(2,g,i,e)%p &
+ a(3,4) * constitutive_RKCK45dotState(3,g,i,e)%p &
+ a(4,4) * constitutive_RKCK45dotState(4,g,i,e)%p
crystallite_dotTemperature(g,i,e) = a(1,4) * RKCK45dotTemperature(1,g,i,e) &
+ a(2,4) * RKCK45dotTemperature(2,g,i,e) &
+ a(3,4) * RKCK45dotTemperature(3,g,i,e) &
+ a(4,4) * RKCK45dotTemperature(4,g,i,e)
elseif (n == 5) then
constitutive_dotState(g,i,e)%p = a(1,5) * constitutive_RKCK45dotState(1,g,i,e)%p &
+ a(2,5) * constitutive_RKCK45dotState(2,g,i,e)%p &
+ a(3,5) * constitutive_RKCK45dotState(3,g,i,e)%p &
+ a(4,5) * constitutive_RKCK45dotState(4,g,i,e)%p &
+ a(5,5) * constitutive_RKCK45dotState(5,g,i,e)%p
crystallite_dotTemperature(g,i,e) = a(1,5) * RKCK45dotTemperature(1,g,i,e) &
+ a(2,5) * RKCK45dotTemperature(2,g,i,e) &
+ a(3,5) * RKCK45dotTemperature(3,g,i,e) &
+ a(4,5) * RKCK45dotTemperature(4,g,i,e) &
+ a(5,5) * RKCK45dotTemperature(5,g,i,e)
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
+ constitutive_dotState(g,i,e)%p(1:mySizeDotState) * crystallite_subdt(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) &
+ crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
endif
enddo; enddo; enddo
* enclose wall time measurement for LpAndItsTangent and count of leapfrogbreaks by CRITICAL construct * better use SINGLE (having an implicit barrier at the end) instead of MASTER construct * deleted all explicit BARRIERs after do loops since parallel loop construct implies barrier at the end
2010-11-19 22:59:29 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- update dependent states ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- stress integration ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
if (.not. crystallite_integrateStress(g,i,e,c(n))) then ! fraction of original time step
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
parallelization now works properly (not yet tested extensively though): * had to add some BARRIER constructs * only the master thread is allowed to increase the state counter yet parallelization seems not to give a significant decrease in calculation time with nonlocal model (because of too many CRITICAL statements?)
2010-11-11 21:46:05 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- dot state and RK dot state---
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
write(6,'(a,1x,i1)') '<< CRYST >> RUNGE KUTTA STEP',n+1_pInt
* OpenMP does not like unbounded array subscripts in function calls * some write statements were still not enclosed by CRITICAL construct, some needed a MASTER construct
2010-11-11 18:44:53 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
* removed calculations for dipole formation/dissociation by stress change, since it is not used anyways; also removed associated constitutive outputs from material.config * removed input variables in constitutive_collectDotState and constitutive_postResults that are not needed anymore (because of recent changes in constitutive_nonlocal)
2011-02-25 15:23:20 +05:30
crystallite_Temperature(g,i,e), c(n)*crystallite_subdt(g,i,e), & ! fraction of original timestep
* had to correct nonlocal slip system compatibility and flux calculation. last update gave wrong results.
2010-10-15 18:49:26 +05:30
crystallite_orientation, g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_Temperature(g,i,e),g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if ( any(constitutive_dotState(g,i,e)%p/=constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e)/=crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo
! --- STATE UPDATE WITH ERROR ESTIMATE FOR STATE AND TEMPERATURE ---
relStateResiduum = 0.0_pReal
relTemperatureResiduum = 0.0_pReal
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
mySizeDotState = constitutive_sizeDotState(g,i,e)
in RKCK45 state integration: dotState was not saved in last Runge-Kutta step
2010-10-27 14:18:04 +05:30
constitutive_RKCK45dotState(6,g,i,e)%p = constitutive_dotState(g,i,e)%p ! store Runge-Kutta dotState
RKCK45dotTemperature(6,g,i,e) = crystallite_dotTemperature(g,i,e) ! store Runge-Kutta dotTemperature
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- absolute residuum in state and temperature ---
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
! NEED TO DO THE ADDITION IN THIS LENGTHY WAY BECAUSE OF PARALLELIZATION
! CAN'T USE A REDUCTION CLAUSE ON A POINTER OR USER DEFINED TYPE
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
stateResiduum(1:mySizeDotState,g,i,e) = &
( db(1) * constitutive_RKCK45dotState(1,g,i,e)%p(1:mySizeDotState) &
+ db(2) * constitutive_RKCK45dotState(2,g,i,e)%p(1:mySizeDotState) &
+ db(3) * constitutive_RKCK45dotState(3,g,i,e)%p(1:mySizeDotState) &
+ db(4) * constitutive_RKCK45dotState(4,g,i,e)%p(1:mySizeDotState) &
+ db(5) * constitutive_RKCK45dotState(5,g,i,e)%p(1:mySizeDotState) &
+ db(6) * constitutive_RKCK45dotState(6,g,i,e)%p(1:mySizeDotState)) &
* crystallite_subdt(g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
temperatureResiduum(g,i,e) = ( db(1) * RKCK45dotTemperature(1,g,i,e) &
+ db(2) * RKCK45dotTemperature(2,g,i,e) &
+ db(3) * RKCK45dotTemperature(3,g,i,e) &
+ db(4) * RKCK45dotTemperature(4,g,i,e) &
+ db(5) * RKCK45dotTemperature(5,g,i,e) &
+ db(6) * RKCK45dotTemperature(6,g,i,e)) &
* crystallite_subdt(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- dot state and dot temperature ---
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
constitutive_dotState(g,i,e)%p = b(1) * constitutive_RKCK45dotState(1,g,i,e)%p &
+ b(2) * constitutive_RKCK45dotState(2,g,i,e)%p &
+ b(3) * constitutive_RKCK45dotState(3,g,i,e)%p &
+ b(4) * constitutive_RKCK45dotState(4,g,i,e)%p &
+ b(5) * constitutive_RKCK45dotState(5,g,i,e)%p &
+ b(6) * constitutive_RKCK45dotState(6,g,i,e)%p
crystallite_dotTemperature(g,i,e) = b(1) * RKCK45dotTemperature(1,g,i,e) &
+ b(2) * RKCK45dotTemperature(2,g,i,e) &
+ b(3) * RKCK45dotTemperature(3,g,i,e) &
+ b(4) * RKCK45dotTemperature(4,g,i,e) &
+ b(5) * RKCK45dotTemperature(5,g,i,e) &
+ b(6) * RKCK45dotTemperature(6,g,i,e)
endif
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
! --- state and temperature update ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
+ constitutive_dotState(g,i,e)%p(1:mySizeDotState) * crystallite_subdt(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) &
+ crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
! --- relative residui and state convergence ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
forall (s = 1_pInt:mySizeDotState, abs(constitutive_state(g,i,e)%p(s)) > 0.0_pReal) &
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
relStateResiduum(s,g,i,e) = stateResiduum(s,g,i,e) / constitutive_state(g,i,e)%p(s)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_Temperature(g,i,e) > 0) &
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
relTemperatureResiduum(g,i,e) = temperatureResiduum(g,i,e) / crystallite_Temperature(g,i,e)
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP FLUSH(relStateResiduum,relTemperatureResiduum)
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
crystallite_todo(g,i,e) = &
( all( abs(relStateResiduum(:,g,i,e)) < rTol_crystalliteState &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
.or. abs(stateResiduum(1:mySizeDotState,g,i,e)) < constitutive_aTolState(g,i,e)%p(1:mySizeDotState) ) &
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
.and. abs(relTemperatureResiduum(g,i,e)) < rTol_crystalliteTemperature )
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt&
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i3,1x,i3)') '<< CRYST >> updateState at el ip g ',e,i,g
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(f12.1,1x)))') '<< CRYST >> absolute residuum tolerance', &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
stateResiduum(1:mySizeDotState,g,i,e) / constitutive_aTolState(g,i,e)%p(1:mySizeDotState)
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(f12.1,1x)))') '<< CRYST >> relative residuum tolerance', &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
relStateResiduum(1:mySizeDotState,g,i,e) / rTol_crystalliteState
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> dotState', constitutive_dotState(g,i,e)%p(1:mySizeDotState)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> new state', constitutive_state(g,i,e)%p(1:mySizeDotState)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- UPDATE DEPENDENT STATES IF RESIDUUM BELOW TOLERANCE ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- FINAL STRESS INTEGRATION STEP IF RESIDUUM BELOW TOLERANCE ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
small corrections for how to treat the new deltaState in FPI and euler integration; all integrators successfully tested with j2
2012-05-18 18:30:15 +05:30
crystallite_todo(g,i,e) = crystallite_integrateStress(g,i,e)
if (.not. crystallite_todo(g,i,e) .and. .not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- STATE JUMP ---
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
if (.not. crystallite_stateJump(g,i,e)) then
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
else ! brken local...
crystallite_todo(g,i,e) = .false. ! ...skip this one next time
endif
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
! --- SET CONVERGENCE FLAG ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
crystallite_converged(g,i,e) = .true. ! if still "to do" then converged per definitionem
crystallite_todo(g,i,e) = .false. ! ... integration done
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP CRITICAL (distributionState)
debug_StateLoopDistribution(6,numerics_integrationMode) = &
debug_StateLoopDistribution(6,numerics_integrationMode) + 1_pInt
!$OMP END CRITICAL (distributionState)
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END PARALLEL
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- nonlocal convergence check ---
* removed last remnants of old debugger * replaced "dble" intrinsic function by "real" with pReal kind in constitutive_nonlocal.f90 * removed useless line breaks in output of state in CPFEM.f90
2011-04-04 14:04:52 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
* removed last remnants of old debugger * replaced "dble" intrinsic function by "real" with pReal kind in constitutive_nonlocal.f90 * removed useless line breaks in output of state in CPFEM.f90
2011-04-04 14:04:52 +05:30
write(6,'(a,i8,a,i2)') '<< CRYST >> ', count(crystallite_converged(:,:,:)), ' grains converged'
write(6,*)
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* check convergence for nonlocals also in stiffness calculation mode
2011-02-09 14:09:07 +05:30
if (.not. singleRun) then ! if not requesting Integration of just a single IP
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if ( any(.not. crystallite_converged .and. .not. crystallite_localPlasticity)) then ! any non-local not yet converged (or broken)...
crystallite_converged = crystallite_converged .and. crystallite_localPlasticity ! ...restart all non-local as not converged
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_integrateStateRKCK45
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!********************************************************************
! integrate stress, state and Temperature with
! 1nd order Euler method with adaptive step size
!********************************************************************
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
subroutine crystallite_integrateStateAdaptiveEuler(gg,ii,ee)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** variables and functions from other modules ***!
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
debug_e, &
debug_i, &
debug_g, &
debug_StateLoopDistribution
use numerics, only: rTol_crystalliteState, &
rTol_crystalliteTemperature, &
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
numerics_integrationMode
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems, &
mesh_maxNips
use material, only: homogenization_Ngrains, &
homogenization_maxNgrains
use constitutive, only: constitutive_sizeDotState, &
constitutive_maxSizeDotState, &
constitutive_state, &
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
constitutive_aTolState, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
constitutive_subState0, &
constitutive_dotState, &
constitutive_collectDotState, &
constitutive_dotTemperature, &
constitutive_microstructure
implicit none
!*** input variables ***!
integer(pInt), optional, intent(in):: ee, & ! element index
ii, & ! integration point index
gg ! grain index
!*** local variables ***!
integer(pInt) e, & ! element index in element loop
i, & ! integration point index in ip loop
g, & ! grain index in grain loop
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
mySizeDotState, & ! size of dot State
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
s ! state index
integer(pInt), dimension(2) :: eIter ! bounds for element iteration
integer(pInt), dimension(2,mesh_NcpElems) :: iIter, & ! bounds for ip iteration
gIter ! bounds for grain iteration
real(pReal), dimension(constitutive_maxSizeDotState,homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
stateResiduum, & ! residuum from evolution in micrstructure
relStateResiduum ! relative residuum from evolution in microstructure
real(pReal), dimension(homogenization_maxNgrains,mesh_maxNips,mesh_NcpElems) :: &
temperatureResiduum, & ! residuum from evolution in temperature
relTemperatureResiduum ! relative residuum from evolution in temperature
logical singleRun ! flag indicating computation for single (g,i,e) triple
! --- LOOP ITERATOR FOR ELEMENT, GRAIN, IP ---
if (present(ee) .and. present(ii) .and. present(gg)) then
eIter = ee
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,ee) = ii
gIter(1:2,ee) = gg
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
singleRun = .true.
else
eIter = FEsolving_execElem(1:2)
do e = eIter(1),eIter(2)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,e) = FEsolving_execIP(1:2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
gIter(1:2,e) = [1_pInt,homogenization_Ngrains(mesh_element(3,e))]
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo
singleRun = .false.
endif
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP PARALLEL PRIVATE(mySizeDotState)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
if (numerics_integrationMode < 2) then
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- DOT STATE AND TEMPERATURE (EULER INTEGRATION) ---
stateResiduum = 0.0_pReal
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
crystallite_Temperature(g,i,e),g,i,e)
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p /= constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e) /= crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP END CRITICAL (checkTodo)
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- STATE UPDATE (EULER INTEGRATION) ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
stateResiduum(1:mySizeDotState,g,i,e) = - 0.5_pReal * constitutive_dotState(g,i,e)%p * crystallite_subdt(g,i,e) ! contribution to absolute residuum in state and temperature
temperatureResiduum(g,i,e) = - 0.5_pReal * crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
+ constitutive_dotState(g,i,e)%p(1:mySizeDotState) * crystallite_subdt(g,i,e)
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) &
+ crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
endif
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- UPDATE DEPENDENT STATES (EULER INTEGRATION) ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
endif
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
enddo; enddo; enddo
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP ENDDO
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- STRESS INTEGRATION (EULER INTEGRATION) ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
if (.not. crystallite_integrateStress(g,i,e)) then
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
if (numerics_integrationMode < 2) then
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- DOT STATE AND TEMPERATURE (HEUN METHOD) ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
crystallite_Temperature(g,i,e),g,i,e)
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p /= constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e) /= crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- ERROR ESTIMATE FOR STATE AND TEMPERATURE (HEUN METHOD) ---
relStateResiduum = 0.0_pReal
relTemperatureResiduum = 0.0_pReal
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
mySizeDotState = constitutive_sizeDotState(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- contribution of heun step to absolute residui ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
stateResiduum(1:mySizeDotState,g,i,e) = stateResiduum(1:mySizeDotState,g,i,e) &
dotState does not have to be reset to zero. this is a remnant from older versions when the dotState for the nonlocal model used to be updated by the neighboring integration point
2012-05-16 21:05:14 +05:30
+ 0.5_pReal * constitutive_dotState(g,i,e)%p * crystallite_subdt(g,i,e) ! contribution to absolute residuum in state and temperature
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
temperatureResiduum(g,i,e) = temperatureResiduum(g,i,e) &
* former "relevantRho" and "relevantResistance" is renamed to "atol_rho" and "atol_resistance" and now used as an absolute tolerance for the state residuum. before it was used rather as significant state, so whenever the state dropped below that value it was considered converged. (In dislotwin and titanmod constitutive law there is only one value atol_rho which is used for all the states, though the state array consists not only of densities. We need further parameters here!) * somewhat simplified convergence check for adaptive euler and runge-kutta
2010-10-26 18:46:37 +05:30
+ 0.5_pReal * crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP FLUSH(stateResiduum,temperatureResiduum)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- relative residui ---
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
forall (s = 1_pInt:mySizeDotState, abs(constitutive_state(g,i,e)%p(s)) > 0.0_pReal) &
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
relStateResiduum(s,g,i,e) = stateResiduum(s,g,i,e) / constitutive_state(g,i,e)%p(s)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
if (crystallite_Temperature(g,i,e) > 0_pInt) &
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
relTemperatureResiduum(g,i,e) = temperatureResiduum(g,i,e) / crystallite_Temperature(g,i,e)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP FLUSH(relStateResiduum,relTemperatureResiduum)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> updateState at el ip g ',e,i,g
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(f12.1,1x)))') '<< CRYST >> absolute residuum tolerance', &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
stateResiduum(1:mySizeDotState,g,i,e) / constitutive_aTolState(g,i,e)%p(1:mySizeDotState)
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(f12.1,1x)))') '<< CRYST >> relative residuum tolerance', &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
relStateResiduum(1:mySizeDotState,g,i,e) / rTol_crystalliteState
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> dotState', constitutive_dotState(g,i,e)%p(1:mySizeDotState) &
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
- 2.0_pReal * stateResiduum(1:mySizeDotState,g,i,e) / crystallite_subdt(g,i,e) ! calculate former dotstate from higher order solution and state residuum
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> new state', constitutive_state(g,i,e)%p(1:mySizeDotState)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
#endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- converged ? ---
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
if ( all( abs(relStateResiduum(:,g,i,e)) < rTol_crystalliteState &
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
.or. abs(stateResiduum(1:mySizeDotState,g,i,e)) < constitutive_aTolState(g,i,e)%p(1:mySizeDotState)) &
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
.and. abs(relTemperatureResiduum(g,i,e)) < rTol_crystalliteTemperature ) then
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
crystallite_converged(g,i,e) = .true. ! ... converged per definitionem
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP CRITICAL (distributionState)
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
debug_StateLoopDistribution(2,numerics_integrationMode) = &
debug_StateLoopDistribution(2,numerics_integrationMode) + 1_pInt
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP END CRITICAL (distributionState)
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- STATE JUMP ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e) .and. crystallite_converged(g,i,e)) then ! converged and still alive...
crystallite_todo(g,i,e) = .false. ! ... integration done
crystallite_converged(g,i,e) = crystallite_stateJump(g,i,e) ! if state jump fails, then convergence is broken
if (.not. crystallite_converged(g,i,e)) then
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
endif
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END PARALLEL
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- NONLOCAL CONVERGENCE CHECK ---
* removed last remnants of old debugger * replaced "dble" intrinsic function by "real" with pReal kind in constitutive_nonlocal.f90 * removed useless line breaks in output of state in CPFEM.f90
2011-04-04 14:04:52 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
* removed last remnants of old debugger * replaced "dble" intrinsic function by "real" with pReal kind in constitutive_nonlocal.f90 * removed useless line breaks in output of state in CPFEM.f90
2011-04-04 14:04:52 +05:30
write(6,'(a,i8,a,i2)') '<< CRYST >> ', count(crystallite_converged(:,:,:)), ' grains converged'
write(6,*)
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* check convergence for nonlocals also in stiffness calculation mode
2011-02-09 14:09:07 +05:30
if (.not. singleRun) then ! if not requesting Integration of just a single IP
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if ( any(.not. crystallite_converged .and. .not. crystallite_localPlasticity)) then ! any non-local not yet converged (or broken)...
crystallite_converged = crystallite_converged .and. crystallite_localPlasticity ! ...restart all non-local as not converged
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_integrateStateAdaptiveEuler
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!********************************************************************
! integrate stress, state and Temperature with
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! 1st order explicit Euler method
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!********************************************************************
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
subroutine crystallite_integrateStateEuler(gg,ii,ee)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** variables and functions from other modules ***!
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
use numerics, only: numerics_integrationMode
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
debug_e, &
debug_i, &
debug_g, &
debug_StateLoopDistribution
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems
use material, only: homogenization_Ngrains
use constitutive, only: constitutive_sizeDotState, &
constitutive_state, &
constitutive_subState0, &
constitutive_dotState, &
constitutive_collectDotState, &
constitutive_dotTemperature, &
constitutive_microstructure
implicit none
!*** input variables ***!
integer(pInt), optional, intent(in):: ee, & ! element index
ii, & ! integration point index
gg ! grain index
!*** local variables ***!
integer(pInt) e, & ! element index in element loop
i, & ! integration point index in ip loop
g, & ! grain index in grain loop
mySizeDotState
integer(pInt), dimension(2) :: eIter ! bounds for element iteration
integer(pInt), dimension(2,mesh_NcpElems) :: iIter, & ! bounds for ip iteration
gIter ! bounds for grain iteration
logical singleRun ! flag indicating computation for single (g,i,e) triple
if (present(ee) .and. present(ii) .and. present(gg)) then
eIter = ee
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,ee) = ii
gIter(1:2,ee) = gg
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
singleRun = .true.
else
eIter = FEsolving_execElem(1:2)
do e = eIter(1),eIter(2)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,e) = FEsolving_execIP(1:2,e)
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
gIter(1:2,e) = [1_pInt,homogenization_Ngrains(mesh_element(3,e))]
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo
singleRun = .false.
endif
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP PARALLEL
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
if (numerics_integrationMode < 2) then ! in stiffness calculation mode we do not need to do the state integration again, since this is not influenced by a small perturbation in F
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- DOT STATE AND TEMPERATURE ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
crystallite_Temperature(g,i,e),g,i,e)
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p/=constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e)/=crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP END CRITICAL (checkTodo)
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- UPDATE STATE AND TEMPERATURE ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP DO PRIVATE(mySizeDotState)
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
mySizeDotState = constitutive_sizeDotState(g,i,e)
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
+ constitutive_dotState(g,i,e)%p(1:mySizeDotState) * crystallite_subdt(g,i,e)
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) &
+ crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
moved some write statements within stateIntegrationEuler
2011-04-14 15:05:56 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> update state at el ip g ',e,i,g
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> dotState', constitutive_dotState(g,i,e)%p(1:mySizeDotState)
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> new state', constitutive_state(g,i,e)%p(1:mySizeDotState)
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
write(6,*)
endif
moved some write statements within stateIntegrationEuler
2011-04-14 15:05:56 +05:30
#endif
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
! --- UPDATE DEPENDENT STATES ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
dislocation stress does not add to stress field anymore, but is only available as constitutive output for purposes of postprocessing. instead, we now use a backstress term (which is added to the resolved shear stress) that depends on the gradient of excess density on the same slip system.
2012-01-17 15:56:57 +05:30
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
Depending on which state integrator one uses for the stiffness calculation, the initial state has to be chosen accordingly: e.g. for FPI choose last converged state, but for explicit RK choose converged state from start of increment (in case of explicit euler no state integration at all, but only stress integration). For this purpose we also need to remember "Fe" which now follows the cutbacking procedure as it is used for "Fp".
2011-11-04 18:14:50 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- STRESS INTEGRATION ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
small corrections for how to treat the new deltaState in FPI and euler integration; all integrators successfully tested with j2
2012-05-18 18:30:15 +05:30
crystallite_todo(g,i,e) = crystallite_integrateStress(g,i,e)
if (.not. crystallite_todo(g,i,e) .and. .not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
enddo; enddo; enddo
small corrections for how to treat the new deltaState in FPI and euler integration; all integrators successfully tested with j2
2012-05-18 18:30:15 +05:30
!$OMP ENDDO
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- STATE JUMP ---
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
crystallite_todo(g,i,e) = crystallite_stateJump(g,i,e)
if (.not. crystallite_todo(g,i,e) .and. .not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
endif
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
endif
enddo; enddo; enddo
!$OMP ENDDO
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- SET CONVERGENCE FLAG ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
crystallite_converged(g,i,e) = .true. ! if still "to do" then converged per definitionem
crystallite_todo(g,i,e) = .false. ! done with integration
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP CRITICAL (distributionState)
debug_StateLoopDistribution(1,numerics_integrationMode) = &
debug_StateLoopDistribution(1,numerics_integrationMode) + 1_pInt
!$OMP END CRITICAL (distributionState)
endif
endif
enddo; enddo; enddo
!$OMP ENDDO
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP END PARALLEL
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- CHECK NON-LOCAL CONVERGENCE ---
* check convergence for nonlocals also in stiffness calculation mode
2011-02-09 14:09:07 +05:30
if (.not. singleRun) then ! if not requesting Integration of just a single IP
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (any(.not. crystallite_converged .and. .not. crystallite_localPlasticity)) then ! any non-local not yet converged (or broken)...
crystallite_converged = crystallite_converged .and. crystallite_localPlasticity ! ...restart all non-local as not converged
stiffness calculation now only needs a single function call to the respective integrator method instead of one call per grain (which seems to heavily slow down the computation). also no special treatment for non-local material points anymore.
2010-10-15 20:27:13 +05:30
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_integrateStateEuler
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!********************************************************************
! integrate stress, state and Temperature with
! adaptive 1st order explicit Euler method
! using Fixed Point Iteration to adapt the stepsize
!********************************************************************
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
subroutine crystallite_integrateStateFPI(gg,ii,ee)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
!*** variables and functions from other modules ***!
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
use debug, only: debug_e, &
debug_i, &
debug_g, &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
debug_level,&
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
debug_levelSelective, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
debug_StateLoopDistribution
* new global integer variable "numerics_integrationMode" (1 indicating integration of central solution, 2 indicating integration of perturbed state) * combined "integrator" and "integratorStiffness" in new global variable "numerics_integrator"
2011-02-23 13:59:51 +05:30
use numerics, only: nState, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
numerics_integrationMode, &
rTol_crystalliteState, &
rTol_crystalliteTemperature
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems
use material, only: homogenization_Ngrains
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
use constitutive, only: constitutive_subState0, &
constitutive_state, &
constitutive_sizeDotState, &
constitutive_maxSizeDotState, &
constitutive_dotState, &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
constitutive_collectDotState, &
constitutive_dotTemperature, &
constitutive_microstructure, &
constitutive_previousDotState, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
constitutive_previousDotState2, &
constitutive_aTolState
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
implicit none
!*** input variables ***!
integer(pInt), optional, intent(in):: ee, & ! element index
ii, & ! integration point index
gg ! grain index
!*** output variables ***!
!*** local variables ***!
integer(pInt) NiterationState, & ! number of iterations in state loop
e, & ! element index in element loop
i, & ! integration point index in ip loop
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
g, & ! grain index in grain loop
mySizeDotState
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
integer(pInt), dimension(2) :: eIter ! bounds for element iteration
integer(pInt), dimension(2,mesh_NcpElems) :: iIter, & ! bounds for ip iteration
gIter ! bounds for grain iteration
real(pReal) dot_prod12, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
dot_prod22, &
stateDamper, & ! damper for integration of state
temperatureResiduum
real(pReal), dimension(constitutive_maxSizeDotState) :: &
stateResiduum
logical singleRun ! flag indicating computation for single (g,i,e) triple
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (present(ee) .and. present(ii) .and. present(gg)) then
eIter = ee
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,ee) = ii
gIter(1:2,ee) = gg
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
singleRun = .true.
else
eIter = FEsolving_execElem(1:2)
do e = eIter(1),eIter(2)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
iIter(1:2,e) = FEsolving_execIP(1:2,e)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
gIter(1:2,e) = [1_pInt,homogenization_Ngrains(mesh_element(3,e))]
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo
singleRun = .false.
endif
! --+>> PREGUESS FOR STATE <<+--
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
!$OMP PARALLEL
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
constitutive_previousDotState(g,i,e)%p = 0.0_pReal
constitutive_previousDotState2(g,i,e)%p = 0.0_pReal
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- DOT STATES ---
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
* removed calculations for dipole formation/dissociation by stress change, since it is not used anyways; also removed associated constitutive outputs from material.config * removed input variables in constitutive_collectDotState and constitutive_postResults that are not needed anymore (because of recent changes in constitutive_nonlocal)
2011-02-25 15:23:20 +05:30
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
crystallite_Temperature(g,i,e),g,i,e)
endif
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p/=constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e)/=crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- UPDATE STATE AND TEMPERATURE ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP DO PRIVATE(mySizeDotState)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
mySizeDotState = constitutive_sizeDotState(g,i,e)
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
+ constitutive_dotState(g,i,e)%p * crystallite_subdt(g,i,e)
crystallite_Temperature(g,i,e) = crystallite_subTemperature0(g,i,e) &
+ crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
split parallel region in integrateStateFPI into two
2011-03-21 20:00:10 +05:30
!$OMP END PARALLEL
* have to reset dotState to zero before call to collectDotState (only important for nonlocal calculation) * in Fixed Point Iteration: update dependent states after state preguess was missing; on the other hand, the first call to constitutive_microstructure was obsolete
2010-10-26 19:34:33 +05:30
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --+>> STATE LOOP <<+--
small corrections for how to treat the new deltaState in FPI and euler integration; all integrators successfully tested with j2
2012-05-18 18:30:15 +05:30
statedamper = 1.0_pReal
split parallel region in integrateStateFPI into two
2011-03-21 20:00:10 +05:30
NiterationState = 0_pInt
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
do while (any(crystallite_todo) .and. NiterationState < nState ) ! convergence loop for crystallite
split parallel region in integrateStateFPI into two
2011-03-21 20:00:10 +05:30
NiterationState = NiterationState + 1_pInt
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
!$OMP PARALLEL
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- UPDATE DEPENDENT STATES ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
endif
constitutive_previousDotState2(g,i,e)%p = constitutive_previousDotState(g,i,e)%p ! age previous dotState
constitutive_previousDotState(g,i,e)%p = constitutive_dotState(g,i,e)%p ! age previous dotState
enddo; enddo; enddo
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- STRESS INTEGRATION ---
* enclose wall time measurement for LpAndItsTangent and count of leapfrogbreaks by CRITICAL construct * better use SINGLE (having an implicit barrier at the end) instead of MASTER construct * deleted all explicit BARRIERs after do loops since parallel loop construct implies barrier at the end
2010-11-19 22:59:29 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
if (.not. crystallite_integrateStress(g,i,e)) then ! if broken ...
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. crystallite_localPlasticity(g,i,e)) then ! ... and non-local...
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP CRITICAL (checkTodo)
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ... then all non-locals skipped
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP END CRITICAL (checkTodo)
else ! ... and local...
crystallite_todo(g,i,e) = .false. ! ... then skip only me
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,'(a,i8,a)') '<< CRYST >> ', count(crystallite_todo(:,:,:)),' grains todo after stress integration'
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- DOT STATE AND TEMPERATURE ---
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
call constitutive_collectDotState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Fe, crystallite_Fp, &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
crystallite_Temperature(g,i,e), crystallite_subdt(g,i,e), crystallite_orientation, g,i,e)
crystallite_dotTemperature(g,i,e) = constitutive_dotTemperature(crystallite_Tstar_v(1:6,g,i,e), &
crystallite_Temperature(g,i,e),g,i,e)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
enddo; enddo; enddo
!$OMP ENDDO
!$OMP DO
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e)) then
if ( any(constitutive_dotState(g,i,e)%p/=constitutive_dotState(g,i,e)%p) & ! NaN occured in dotState
.or. crystallite_dotTemperature(g,i,e)/=crystallite_dotTemperature(g,i,e) ) then ! NaN occured in dotTemperature
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
else ! if broken local...
crystallite_todo(g,i,e) = .false. ! ... skip this one next time
endif
endif
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- UPDATE STATE AND TEMPERATURE ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
!$OMP DO PRIVATE(dot_prod12,dot_prod22,statedamper,mySizeDotState,stateResiduum,temperatureResiduum)
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
if (crystallite_todo(g,i,e)) then
* enclose wall time measurement for LpAndItsTangent and count of leapfrogbreaks by CRITICAL construct * better use SINGLE (having an implicit barrier at the end) instead of MASTER construct * deleted all explicit BARRIERs after do loops since parallel loop construct implies barrier at the end
2010-11-19 22:59:29 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
! --- state damper ---
dot_prod12 = dot_product( constitutive_dotState(g,i,e)%p - constitutive_previousDotState(g,i,e)%p, &
constitutive_previousDotState(g,i,e)%p - constitutive_previousDotState2(g,i,e)%p )
dot_prod22 = dot_product( constitutive_previousDotState(g,i,e)%p - constitutive_previousDotState2(g,i,e)%p, &
constitutive_previousDotState(g,i,e)%p - constitutive_previousDotState2(g,i,e)%p )
if ( dot_prod22 > 0.0_pReal &
.and. ( dot_prod12 < 0.0_pReal &
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
.or. dot_product(constitutive_dotState(g,i,e)%p, constitutive_previousDotState(g,i,e)%p) < 0.0_pReal) ) then
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
statedamper = 0.75_pReal + 0.25_pReal * tanh(2.0_pReal + 4.0_pReal * dot_prod12 / dot_prod22)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- get residui ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
mySizeDotState = constitutive_sizeDotState(g,i,e)
stateResiduum(1:mySizeDotState) = constitutive_state(g,i,e)%p(1:mySizeDotState) &
- constitutive_subState0(g,i,e)%p(1:mySizeDotState) &
- (constitutive_dotState(g,i,e)%p * statedamper &
+ constitutive_previousDotState(g,i,e)%p * (1.0_pReal - statedamper)) * crystallite_subdt(g,i,e)
temperatureResiduum = crystallite_Temperature(g,i,e) &
- crystallite_subTemperature0(g,i,e) &
- crystallite_dotTemperature(g,i,e) * crystallite_subdt(g,i,e)
! --- correct state and temperature with residuum ---
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_state(g,i,e)%p(1:mySizeDotState) &
small corrections for how to treat the new deltaState in FPI and euler integration; all integrators successfully tested with j2
2012-05-18 18:30:15 +05:30
- stateResiduum(1:mySizeDotState)
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
crystallite_Temperature(g,i,e) = crystallite_Temperature(g,i,e) - temperatureResiduum
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> update state at el ip g ',e,i,g
write(6,*)
write(6,'(a,f6.1)') '<< CRYST >> statedamper ',statedamper
write(6,*)
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> state residuum',stateResiduum(1:mySizeDotState)
write(6,*)
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> new state',constitutive_state(g,i,e)%p(1:mySizeDotState)
write(6,*)
endif
#endif
! --- store corrected dotState --- (cannot do this before state update, because not sure how to flush pointers in openmp)
constitutive_dotState(g,i,e)%p = constitutive_dotState(g,i,e)%p * statedamper &
+ constitutive_previousDotState(g,i,e)%p * (1.0_pReal - statedamper)
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- converged ? ---
if ( all( abs(stateResiduum(1:mySizeDotState)) < constitutive_aTolState(g,i,e)%p(1:mySizeDotState) &
.or. abs(stateResiduum(1:mySizeDotState)) < rTol_crystalliteState &
* abs(constitutive_state(g,i,e)%p(1:mySizeDotState)) ) &
.and. (abs(temperatureResiduum) < rTol_crystalliteTemperature * crystallite_Temperature(g,i,e) &
.or. crystallite_Temperature(g,i,e) == 0.0_pReal) ) then
crystallite_converged(g,i,e) = .true. ! ... converged per definitionem
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP CRITICAL (distributionState)
debug_StateLoopDistribution(NiterationState,numerics_integrationMode) = &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
debug_StateLoopDistribution(NiterationState,numerics_integrationMode) + 1_pInt
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP END CRITICAL (distributionState)
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
! --- STATE JUMP ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP DO
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
do e = eIter(1),eIter(2); do i = iIter(1,e),iIter(2,e); do g = gIter(1,e),gIter(2,e) ! iterate over elements, ips and grains
if (crystallite_todo(g,i,e) .and. crystallite_converged(g,i,e)) then ! converged and still alive...
crystallite_todo(g,i,e) = .false. ! ... integration done
crystallite_converged(g,i,e) = crystallite_stateJump(g,i,e) ! if state jump fails, then convergence is broken
if (.not. crystallite_converged(g,i,e)) then
if (.not. crystallite_localPlasticity(g,i,e)) then ! if broken non-local...
!$OMP CRITICAL (checkTodo)
crystallite_todo = crystallite_todo .and. crystallite_localPlasticity ! ...all non-locals skipped
!$OMP END CRITICAL (checkTodo)
endif
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
enddo; enddo; enddo
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
!$OMP ENDDO
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
split parallel region in integrateStateFPI into two
2011-03-21 20:00:10 +05:30
!$OMP END PARALLEL
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,'(a,i8,a,i2)') '<< CRYST >> ', count(crystallite_converged(:,:,:)), &
' grains converged after state integration no. ', NiterationState
write(6,*)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
instantaneous jumps in the state by constitutive_deltaState are now incorporated for all state integrators. still they (should) not influence the result, since all constitutive laws simply return zero for the deltaState
2012-05-17 20:55:21 +05:30
! --- NON-LOCAL CONVERGENCE CHECK ---
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
* check convergence for nonlocals also in stiffness calculation mode
2011-02-09 14:09:07 +05:30
if (.not. singleRun) then ! if not requesting Integration of just a single IP
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (any(.not. crystallite_converged .and. .not. crystallite_localPlasticity)) then ! any non-local not yet converged (or broken)...
crystallite_converged = crystallite_converged .and. crystallite_localPlasticity ! ...restart all non-local as not converged
split parallel region in integrateStateFPI into two
2011-03-21 20:00:10 +05:30
endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
split parallel region in integrateStateFPI into two
2011-03-21 20:00:10 +05:30
crystallite_todo = crystallite_todo .and. .not. crystallite_converged ! skip all converged
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,'(a,i8,a)') '<< CRYST >> ', count(crystallite_converged(:,:,:)),' grains converged after non-local check'
write(6,'(a,i8,a,i2)') '<< CRYST >> ', count(crystallite_todo(:,:,:)),' grains todo after state integration no. ',&
NiterationState
write(6,*)
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
enddo ! crystallite convergence loop
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_integrateStateFPI
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
!***********************************************************
!* calculates a jump in the state according to the current *
!* state and the current stress *
!***********************************************************
function crystallite_stateJump(g,i,e)
!*** variables and functions from other modules ***!
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
debug_crystallite, &
debug_levelExtensive, &
debug_levelSelective, &
debug_e, &
debug_i, &
debug_g
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use mesh, only: mesh_element, &
mesh_NcpElems
use material, only: homogenization_Ngrains
use constitutive, only: constitutive_sizeDotState, &
constitutive_state, &
constitutive_deltaState, &
constitutive_collectDeltaState, &
constitutive_microstructure
implicit none
!*** input variables ***!
integer(pInt), intent(in):: e, & ! element index
i, & ! integration point index
g ! grain index
!*** output variables ***!
logical crystallite_stateJump
!*** local variables ***!
integer(pInt) mySizeDotState
crystallite_stateJump = .false.
call constitutive_collectDeltaState(crystallite_Tstar_v(1:6,g,i,e), crystallite_Temperature(g,i,e), g,i,e)
mySizeDotState = constitutive_sizeDotState(g,i,e)
if (any(constitutive_deltaState(g,i,e)%p(1:mySizeDotState) /= constitutive_deltaState(g,i,e)%p(1:mySizeDotState))) then
return
endif
constitutive_state(g,i,e)%p(1:mySizeDotState) = constitutive_state(g,i,e)%p(1:mySizeDotState) &
+ constitutive_deltaState(g,i,e)%p(1:mySizeDotState)
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
new function stateJump, which takes care of immediate changes in the state (deltaState); this introduces discontinuities in the state evolution; therefore this is always and only once done after each integration step, so no evaluation of deltaState for intermediate steps of e.g. the Runge-Kutta integrator; otherwise integration becomes a pain without significant gain in accuracy deltaState now successfully tested for nonlocal model; was not correct for integrators 1,4,5 before
2012-06-06 20:41:30 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> update state at el ip g ',e,i,g
write(6,*)
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> deltaState', constitutive_deltaState(g,i,e)%p(1:mySizeDotState)
write(6,*)
write(6,'(a,/,(12x,12(e12.5,1x)))') '<< CRYST >> new state', constitutive_state(g,i,e)%p(1:mySizeDotState)
write(6,*)
endif
#endif
call constitutive_microstructure(crystallite_Temperature(g,i,e), crystallite_Fe(1:3,1:3,g,i,e), &
crystallite_Fp(1:3,1:3,g,i,e), g, i, e) ! update dependent state variables to be consistent with basic states
crystallite_stateJump = .true.
end function crystallite_stateJump
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!***********************************************************************
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
!*** calculation of stress (P) with time integration ***
!*** based on a residuum in Lp and intermediate ***
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!*** acceleration of the Newton-Raphson correction ***
!***********************************************************************
* checked and corrected parallelization of code. compiles now successfully, but simply aborts computation with first parallel directive without any comment :-((( * also put a call to constitutive_microstructure at the start of each crystallite_integration subroutine like it was before. need that for nonlocal model in case of crystallite cutback
2010-11-03 22:52:48 +05:30
function crystallite_integrateStress(&
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
g,& ! grain number
i,& ! integration point number
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
e,& ! element number
replaced variable fraction by "timefraction"
2012-01-26 18:18:59 +05:30
timeFraction &
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
)
1) terminallyIll was reset before FE did cutback --> useless extra calculations of same problem over and over... 2) local stiffness calculation is now standard for non-local grains 3) stressLoopDistribution discriminates between (a) central solution and (b) stiffness perturbation 4) debugger is switched on as standard... (but verboseDebugger not!)
2010-09-06 21:36:41 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
use prec, only: pLongInt
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
use numerics, only: nStress, &
aTol_crystalliteStress, &
rTol_crystalliteStress, &
iJacoLpresiduum, &
numerics_integrationMode
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
use debug, only: debug_level, &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
debug_crystallite, &
debug_levelBasic, &
debug_levelExtensive, &
debug_levelSelective, &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
debug_e, &
debug_i, &
debug_g, &
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
debug_cumLpCalls, &
debug_cumLpTicks, &
debug_StressLoopDistribution, &
debug_LeapfrogBreakDistribution
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
use constitutive, only: constitutive_LpAndItsTangent, &
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
constitutive_TandItsTangent, &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
constitutive_homogenizedC
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
use math, only: math_mul33x33, &
corrected stress integration scheme: now use norm(Lpresiduum) as a target function for Armijo's rule instead of whole tensor Lp; also corrected the guess for the improvement in Lp
2011-11-04 18:27:12 +05:30
math_mul33xx33, &
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
math_mul66x6, &
math_mul99x99, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33, &
math_inv33, &
math_invert33, &
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
math_invert, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_det33, &
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
math_norm33, &
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
math_I3, &
math_identity2nd, &
math_Mandel66to3333, &
math_Mandel6to33, &
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
math_Mandel33to6, &
math_Plain3333to99
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
implicit none
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!*** input variables ***!
integer(pInt), intent(in):: e, & ! element index
i, & ! integration point index
g ! grain index
replaced variable fraction by "timefraction"
2012-01-26 18:18:59 +05:30
real(pReal), optional, intent(in) :: timeFraction ! fraction of timestep
* now able to choose method for state integration (integrator and integratorStiffness in numerics.config); standard is "Fixed Point Iteration", which is basically the same as before; others available are "Explicit Euler", "AdaptiveEuler", "Classical Runge-Kutta" and "Runge-Kutta Cash-Karp" * now remembering stiffness similar to how we do it for Lp etc.; avoids undefined stiffness values for nonconverged stiffness calculation * non-local stuff: * changed non-local kinetics (Gilman2002) * enforce zero shearrate for overall carrrier density below relevant density * enforce zero density for those states that become negative and were below relevant density before * dislocation velocity is not limited by V^(1/3) / dt anymore
2010-10-01 17:48:49 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!*** output variables ***!
logical crystallite_integrateStress ! flag indicating if integration suceeded
constitutive_nonlocal: - dipole dislocations with evolution crystallite.f90: - collect state uses subdt and subTstar0_v - in nonlocal modus: set all crystallites to broken if one is not on track anymore after either stress integration or state update - constitutive_microstructure is now called inside state update and not in integrate_stress anymore material.config: - new parameter for nonlocal constitution CPFEM.f90: - age Tstar after increment was finished
2009-08-28 19:20:47 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!*** local variables ***!
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
real(pReal), dimension(3,3):: Fg_new, & ! deformation gradient at end of timestep
Fp_current, & ! plastic deformation gradient at start of timestep
Fp_new, & ! plastic deformation gradient at end of timestep
Fe_new, & ! elastic 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
residuum, & ! current residuum of plastic velocity gradient
residuum_old, & ! last residuum of plastic velocity gradient
deltaLp, & ! direction of next guess
gradientR, & ! derivative of the residuum norm
Tstar,& ! 2nd Piola-Kirchhoff Stress
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
A,&
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
B, &
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
Fe ! elastic deformation gradient
real(pReal), dimension(6):: Tstar_v ! 2nd Piola-Kirchhoff Stress in Mandel-Notation
real(pReal), dimension(9):: work ! needed for matrix inversion by LAPACK
integer(pInt), dimension(9) :: ipiv ! needed for matrix inversion by LAPACK
real(pReal), dimension(9,9) :: dLp_dT_constitutive, & ! partial derivative of plastic velocity gradient calculated by constitutive law
dT_dFe_constitutive, & ! partial derivative of 2nd Piola-Kirchhoff stress calculated by constitutive law
dFe_dLp, & ! partial derivative of elastic deformation gradient
dR_dLp, & ! partial derivative of residuum (Jacobian for NEwton-Raphson scheme)
inv_dR_dLp ! inverse of dRdLp
real(pReal), dimension(3,3,3,3):: dT_dFe3333, & ! partial derivative of 2nd Piola-Kirchhoff stress
dFe_dLp3333 ! partial derivative of elastic deformation gradient
real(pReal) p_hydro, & ! volumetric part of 2nd Piola-Kirchhoff Stress
det, & ! determinant
corrected stress integration scheme: now use norm(Lpresiduum) as a target function for Armijo's rule instead of whole tensor Lp; also corrected the guess for the improvement in Lp
2011-11-04 18:27:12 +05:30
expectedImprovement, &
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
steplength0, &
steplength, &
steplength_max, &
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
dt, & ! time increment
aTol
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
logical error ! flag indicating an error
integer(pInt) NiterationStress, & ! number of stress integrations
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
k, &
l, &
m, &
n, &
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
o, &
p, &
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
jacoCounter ! counter to check for Jacobian update
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
integer(pLongInt) tick, &
tock, &
tickrate, &
maxticks
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* be pessimistic
crystallite_integrateStress = .false.
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> integrateStress at el ip g ',e,i,g
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* only integrate over fraction of timestep?
replaced variable fraction by "timefraction"
2012-01-26 18:18:59 +05:30
if (present(timeFraction)) then
dt = crystallite_subdt(g,i,e) * timeFraction
Fg_new = crystallite_subF0(1:3,1:3,g,i,e) + (crystallite_subF(1:3,1:3,g,i,e) - crystallite_subF0(1:3,1:3,g,i,e)) * timeFraction
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
else
dt = crystallite_subdt(g,i,e)
Fg_new = crystallite_subF(1:3,1:3,g,i,e)
endif
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* feed local variables
Fp_current = crystallite_subFp0(1:3,1:3,g,i,e)
Lpguess_old = crystallite_Lp(1:3,1:3,g,i,e) ! consider present Lp good (i.e. worth remembering) ...
Lpguess = crystallite_Lp(1:3,1:3,g,i,e) ! ... and take it as first guess
!* inversion of Fp_current...
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
invFp_current = math_inv33(Fp_current)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
if (all(invFp_current == 0.0_pReal)) then ! ... failed?
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> integrateStress failed on invFp_current inversion at el ip g ',e,i,g
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelSelective) > 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(f12.7,1x)/))') '<< CRYST >> invFp_new',math_transpose33(invFp_new(1:3,1:3))
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
return
endif
maximum relative step length in stress integration cannot decrease below 1 intermediate tensor "A" is calculated only once before the Lp loop in "integrateStress"
2012-08-21 14:23:36 +05:30
A = math_mul33x33(Fg_new,invFp_current) ! intermediate tensor needed later to calculate dFe_dLp
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
!* start LpLoop with normal step length
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
NiterationStress = 0_pInt
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
steplength0 = 1.0_pReal
steplength = steplength0
steplength_max = 16.0_pReal
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
jacoCounter = 0_pInt
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
LpLoop: do
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
NiterationStress = NiterationStress + 1_pInt
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* too many loops required ?
if (NiterationStress > nStress) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3)') '<< CRYST >> integrateStress reached loop limit at el ip g ',e,i,g
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
return
endif
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
maximum relative step length in stress integration cannot decrease below 1 intermediate tensor "A" is calculated only once before the Lp loop in "integrateStress"
2012-08-21 14:23:36 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* calculate 2nd Piola-Kirchhoff stress tensor
maximum relative step length in stress integration cannot decrease below 1 intermediate tensor "A" is calculated only once before the Lp loop in "integrateStress"
2012-08-21 14:23:36 +05:30
B = math_I3 - dt*Lpguess
Fe = math_mul33x33(A,B) ! current elastic deformation tensor
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
call constitutive_TandItsTangent(Tstar, dT_dFe3333, Fe, g,i,e) ! call constitutive law to calculate 2nd Piola-Kirchhoff stress and its derivative
Tstar_v = math_Mandel33to6(Tstar)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
p_hydro = sum(Tstar_v(1:3)) / 3.0_pReal
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
forall(n=1_pInt:3_pInt) Tstar_v(n) = Tstar_v(n) - p_hydro ! get deviatoric stress tensor
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* calculate plastic velocity gradient and its tangent according to constitutive law
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
call system_clock(count=tick,count_rate=tickrate,count_max=maxticks)
endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
call constitutive_LpAndItsTangent(Lp_constitutive, dLp_dT_constitutive, Tstar_v, crystallite_Temperature(g,i,e), g, i, e)
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
call system_clock(count=tock,count_rate=tickrate,count_max=maxticks)
!$OMP CRITICAL (debugTimingLpTangent)
debug_cumLpCalls = debug_cumLpCalls + 1_pInt
debug_cumLpTicks = debug_cumLpTicks + tock-tick
!$OMP FLUSH (debug_cumLpTicks)
if (tock < tick) debug_cumLpTicks = debug_cumLpTicks + maxticks
!$OMP END CRITICAL (debugTimingLpTangent)
endif
* enclose wall time measurement for LpAndItsTangent and count of leapfrogbreaks by CRITICAL construct * better use SINGLE (having an implicit barrier at the end) instead of MASTER construct * deleted all explicit BARRIERs after do loops since parallel loop construct implies barrier at the end
2010-11-19 22:59:29 +05:30
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt) &
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
.and. numerics_integrationMode == 1_pInt) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,'(a,i3)') '<< CRYST >> iteration ', NiterationStress
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(e20.7,1x)/))') '<< CRYST >> Lp_constitutive', math_transpose33(Lp_constitutive)
write(6,'(a,/,3(12x,3(e20.7,1x)/))') '<< CRYST >> Lpguess', math_transpose33(Lpguess)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* update current residuum and check for convergence of loop
residuum = Lpguess - Lp_constitutive
stressAndItsTangent: when winding forward to last substep in increment, also do the calculation if this substep is below "subStepMinCryst"; output of "wind forward" and "cutback" info only for crystallites that are still "todo" integrateStress: maximum component in Lp determines absolute convergence criterium: aTol = max(maxLpComp * rTol_fromConfig , aTol_fromConfig) this ensures that small values in Lp do not spoil the convergence, similar to the effect of the relevantStrain parameter before (not needed anymore in the stress integration)
2012-08-14 17:37:59 +05:30
aTol = max(rTol_crystalliteStress * maxval(max(abs(Lpguess),abs(Lp_constitutive))), & ! absolute tolerance from largest acceptable relative error
aTol_crystalliteStress) ! minimum lower cutoff
if (.not. any(residuum /= residuum) & ! no convergence if NaN in residuum
.and. maxval(abs(residuum)) < aTol ) then ! converged if all below absolute tolerance...
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
exit LpLoop
endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
!* NaN occured at regular speed -> return
if (steplength >= steplength0 .and. any(residuum /= residuum)) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3,a,i3,a)') '<< CRYST >> integrateStress encountered NaN at el ip g ',e,i,g,&
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
' ; iteration ', NiterationStress,&
' >> returning..!'
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
return
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
if (NiterationStress > 1_pInt) then
!* not at regular speed
if (steplength <= steplength0) then
!* Armijo rule is fullfilled (norm of residuum was reduced by at least 0.01 of what was expected)
corrected stress integration scheme: now use norm(Lpresiduum) as a target function for Armijo's rule instead of whole tensor Lp; also corrected the guess for the improvement in Lp
2011-11-04 18:27:12 +05:30
if (math_norm33(residuum) <= math_norm33(residuum_old) + 0.01_pReal * steplength * expectedImprovement) then
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
!* reduced step length -> return to normal step length
if (steplength < steplength0) then
steplength = steplength0
!* normal step length without change in sign of residuum -> accelerate if not yet at maximum speed
elseif (sum(residuum * residuum_old) >= 0.0_pReal .and. steplength + 1_pInt <= steplength_max) then
steplength = steplength + 1.0_pReal
endif
!* Armijo rule not fullfilled -> try smaller step size in same direction
else
steplength = 0.5_pReal * steplength
Lpguess = Lpguess_old + steplength * deltaLp
cycle LpLoop
endif
!* at high-speed
else
!* no NaN, Armijo rule fullfilled, and sign of residuum did not change -> accelerate if not yet at maximum speed
if (.not. any(residuum /= residuum) &
corrected stress integration scheme: now use norm(Lpresiduum) as a target function for Armijo's rule instead of whole tensor Lp; also corrected the guess for the improvement in Lp
2011-11-04 18:27:12 +05:30
.and. math_norm33(residuum) <= math_norm33(residuum_old) + 0.01_pReal * steplength * expectedImprovement &
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
.and. sum(residuum * residuum_old) >= 0.0_pReal) then
if (steplength + 1_pInt <= steplength_max) then
steplength = steplength + 1.0_pReal
endif
!* something went wrong at accelerated speed? -> return to regular speed and try again
else
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3,1x,a,i3)') '<< CRYST >> integrateStress encountered high-speed crash at el ip g ',e,i,g,&
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
'; iteration ', NiterationStress
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
!* NaN occured -> use old guess and residuum
if (any(residuum /= residuum)) then
Lpguess = Lpguess_old
residuum = residuum_old
endif
maximum relative step length in stress integration cannot decrease below 1 intermediate tensor "A" is calculated only once before the Lp loop in "integrateStress"
2012-08-21 14:23:36 +05:30
steplength_max = max(steplength - 1.0_pReal, 1.0_pReal) ! limit acceleration
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
steplength = steplength0 ! grinding halt
jacoCounter = 0_pInt ! reset counter for Jacobian update (we want to do an update next time!)
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
!$OMP CRITICAL (distributionLeapfrogBreak)
debug_LeapfrogBreakDistribution(NiterationStress,numerics_integrationMode) = &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
debug_LeapfrogBreakDistribution(NiterationStress,numerics_integrationMode) + 1_pInt
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
!$OMP END CRITICAL (distributionLeapfrogBreak)
endif
endif
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
endif
!* calculate Jacobian for correction term and remember current residuum and Lpguess
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
if (mod(jacoCounter, iJacoLpresiduum) == 0_pInt) then
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
dFe_dLp3333 = 0.0_pReal
do o=1_pInt,3_pInt; do p=1_pInt,3_pInt
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
dFe_dLp3333(p,o,1:3,p) = A(o,1:3) ! dFe_dLp(i,j,k,l) = -dt * A(i,k) delta(j,l)
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
enddo; enddo
dFe_dLp3333 = -dt * dFe_dLp3333
dFe_dLp = math_Plain3333to99(dFe_dLp3333)
dT_dFe_constitutive = math_Plain3333to99(dT_dFe3333)
dR_dLp = math_identity2nd(9_pInt) - &
substituted hand written matrix inversion by LAPACK version with precision selection. also introduced check for inversion into DAMASK_spectral_Utilities.f90 for the stress BC calculation. This part is further improved by using 5% of the reference stiffness to avoid trouble in the fully plastic regime (where the stiffness is underestimated) Test for Marc 2010 is updated because the new inversion give slightly different results near 0 (order of e-13)
2012-08-28 22:29:45 +05:30
math_mul99x99(dLp_dT_constitutive, math_mul99x99(dT_dFe_constitutive , dFe_dLp))
inv_dR_dLp = dR_dLp ! will be changed in first call to LAPACK
#if(FLOAT==8)
call dgetrf(9,9,inv_dR_dLp,9,ipiv,error) ! invert dR/dLp --> dLp/dR
call dgetri(9,inv_dR_dLp,9,ipiv,work,9,error)
#elif(FLOAT==4)
call sgetrf(9,9,inv_dR_dLp,9,ipiv,error) ! invert dR/dLp --> dLp/dR
call sgetri(9,inv_dR_dLp,9,ipiv,work,9,error)
#else
NO SUITABLE PRECISION SELECTED, COMPILATION ABORTED
#endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
if (error) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,i8,1x,i2,1x,i3,a,i3)') '<< CRYST >> integrateStress failed on dR/dLp inversion at el ip g ',e,i,g
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g)&
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,9(12x,9(e15.3,1x)/))') '<< CRYST >> dR_dLp',transpose(dR_dLp)
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
write(6,'(a,/,9(12x,9(e15.3,1x)/))') '<< CRYST >> dFe_dLp',transpose(dFe_dLp)
write(6,'(a,/,9(12x,9(e15.3,1x)/))') '<< CRYST >> dT_dFe_constitutive',transpose(dT_dFe_constitutive)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,9(12x,9(e15.3,1x)/))') '<< CRYST >> dLp_dT_constitutive',transpose(dLp_dT_constitutive)
stress iteration loop now uses generalized elasticity by calling TandItsTangent the anlalytical tangent calculation should now be adopted to also use TandItsTangent
2012-03-21 16:27:27 +05:30
write(6,'(a,/,3(12x,3(e20.7,1x)/))') '<< CRYST >> A',math_transpose33(A)
write(6,'(a,/,3(12x,3(e20.7,1x)/))') '<< CRYST >> B',math_transpose33(B)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(e20.7,1x)/))') '<< CRYST >> Lp_constitutive',math_transpose33(Lp_constitutive)
write(6,'(a,/,3(12x,3(e20.7,1x)/))') '<< CRYST >> Lpguess',math_transpose33(Lpguess)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
#endif
return
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
deltaLp = 0.0_pReal
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do k=1_pInt,3_pInt; do l=1_pInt,3_pInt; do m=1_pInt,3_pInt; do n=1_pInt,3_pInt
deltaLp(k,l) = deltaLp(k,l) - inv_dR_dLp(3_pInt*(k-1_pInt)+l,3_pInt*(m-1_pInt)+n) * residuum(m,n)
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
enddo; enddo; enddo; enddo
corrected stress integration scheme: now use norm(Lpresiduum) as a target function for Armijo's rule instead of whole tensor Lp; also corrected the guess for the improvement in Lp
2011-11-04 18:27:12 +05:30
gradientR = 0.0_pReal
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do k=1_pInt,3_pInt; do l=1_pInt,3_pInt; do m=1_pInt,3_pInt; do n=1_pInt,3_pInt
gradientR(k,l) = gradientR(k,l) + dR_dLp(3*(k-1)+l,3_pInt*(m-1_pInt)+n) * residuum(m,n)
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
enddo; enddo; enddo; enddo
corrected stress integration scheme: now use norm(Lpresiduum) as a target function for Armijo's rule instead of whole tensor Lp; also corrected the guess for the improvement in Lp
2011-11-04 18:27:12 +05:30
gradientR = gradientR / math_norm33(gradientR)
expectedImprovement = math_mul33xx33(deltaLp, gradientR)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
Stress integration now uses Armijo rule to find an appropriate correction of Lp: decreases step in case that residuum does not improve significantly, accelerates as usual in case of good convergence. This turned out to improve convergence behavior.
2011-08-02 16:59:08 +05:30
jacoCounter = jacoCounter + 1_pInt ! increase counter for jaco update
residuum_old = residuum
Lpguess_old = Lpguess
Lpguess = Lpguess + steplength * deltaLp
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
enddo LpLoop
!* calculate new plastic and elastic deformation gradient
invFp_new = math_mul33x33(invFp_current,B)
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
invFp_new = invFp_new/math_det33(invFp_new)**(1.0_pReal/3.0_pReal) ! regularize by det
call math_invert33(invFp_new,Fp_new,det,error)
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
if (error) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
write(6,'(a,i8,1x,i2,1x,i3,a,i3)') '<< CRYST >> integrateStress failed on invFp_new inversion at el ip g ',&
e,i,g, ' ; iteration ', NiterationStress
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelExtensive) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt)) then
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
write(6,*)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(f12.7,1x)/))') '<< CRYST >> invFp_new',math_transpose33(invFp_new)
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
return
endif
Fe_new = math_mul33x33(Fg_new,invFp_new) ! calc resulting Fe
!* add volumetric component to 2nd Piola-Kirchhoff stress and calculate 1st Piola-Kirchhoff stress
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
forall (n=1_pInt:3_pInt) Tstar_v(n) = Tstar_v(n) + p_hydro
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
crystallite_P(1:3,1:3,g,i,e) = math_mul33x33(Fe_new, math_mul33x33(math_Mandel6to33(Tstar_v), math_transpose33(invFp_new)))
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!* store local values in global variables
crystallite_Lp(1:3,1:3,g,i,e) = Lpguess
crystallite_Tstar_v(1:6,g,i,e) = Tstar_v
crystallite_Fp(1:3,1:3,g,i,e) = Fp_new
crystallite_Fe(1:3,1:3,g,i,e) = Fe_new
crystallite_invFp(1:3,1:3,g,i,e) = invFp_new
!* set return flag to true
crystallite_integrateStress = .true.
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#ifndef _OPENMP
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite),debug_levelExtensive) /= 0_pInt &
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
.and. ((e == debug_e .and. i == debug_i .and. g == debug_g) &
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
.or. .not. iand(debug_level(debug_crystallite), debug_levelSelective) /= 0_pInt) &
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
.and. numerics_integrationMode == 1_pInt) then
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
write(6,'(a,/,3(12x,3(f12.7,1x)/))') '<< CRYST >> P / MPa',math_transpose33(crystallite_P(1:3,1:3,g,i,e))/1.0e6_pReal
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(f12.7,1x)/))') '<< CRYST >> Cauchy / MPa', &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
math_mul33x33(crystallite_P(1:3,1:3,g,i,e), math_transpose33(Fg_new)) / 1.0e6_pReal / math_det33(Fg_new)
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(f12.7,1x)/))') '<< CRYST >> Fe Lp Fe^-1', &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
math_transpose33(math_mul33x33(Fe_new, math_mul33x33(crystallite_Lp(1:3,1:3,g,i,e), math_inv33(Fe_new)))) ! transpose to get correct print out order
made code standard conform to Fortran 2008 (ignoring warning concerning comments beyond character 132). Basically, changing "x" format specifier to "Nx" ("1x") plus removing $ format specifier added compiler switches for gfortran and ifort to check for standard conformity old gnu compilers <4.4 are not longer supported because they don't provide the c binding for fftw
2012-02-01 00:48:55 +05:30
write(6,'(a,/,3(12x,3(f12.7,1x)/))') '<< CRYST >> Fp',math_transpose33(crystallite_Fp(1:3,1:3,g,i,e))
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
endif
* Introduced preprocessor directives in order to suppress compilation of most write statements when using openmp. This tremendously improves efficiency of parallelization. * Also added some more openmp directives to increase percentage of parallelized code. * "implicit none" was missing in two subroutines of homogenization and constitutive.
2011-03-29 12:57:19 +05:30
#endif
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
changed variable name "debug_what" to "debug_level"
2012-07-05 15:24:50 +05:30
if (iand(debug_level(debug_crystallite), debug_levelBasic) /= 0_pInt) then
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP CRITICAL (distributionStress)
debug_StressLoopDistribution(NiterationStress,numerics_integrationMode) = &
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
debug_StressLoopDistribution(NiterationStress,numerics_integrationMode) + 1_pInt
debugging output is now controlled by the "verbosity" parameter in the debug.config ranging from 0 (=almost no output) to 8 (=very detailed output) 0 : only version infos and all from "hypela2"/"umat" 1 : basic outputs from "CPFEM.f90", basic output from initialization routines, debug_info 2 : extensive outputs from "CPFEM.f90", extensive output from initialization routines 3 : basic outputs from "homogenization.f90" 4 : extensive outputs from "homogenization.f90" 5 : basic outputs from "crystallite.f90" 6 : extensive outputs from "crystallite.f90" 7 : basic outputs from the constitutive files 8 : extensive outputs from the constitutive files If verbosity is equal to zero, all counters in debug are not set during calculation (e.g. debug_StressLoopDistribution or debug_cumDotStateTicks). This might speed up parallel calculation, because all these need critical statements which extremely slow down parallel computation.
2011-03-21 16:01:17 +05:30
!$OMP END CRITICAL (distributionStress)
endif
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end function crystallite_integrateStress
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
!********************************************************************
corrected (?) disorientation calc and introduced some new assisting functions
2010-04-28 22:49:58 +05:30
! calculates orientations and disorientations (in case of single grain ips)
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
!********************************************************************
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
subroutine crystallite_orientations
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
!*** variables and functions from other modules ***!
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
detabbed file for better readability
2010-02-19 19:14:38 +05:30
use math, only: math_pDecomposition, &
changed internal representation of orientation and misorientation from euler angles to quaternions (this should also fix some bugs in the math_misorientation subroutine). includes a couple of new functions in math.f90 and some changes in crystallite.f90. beware that crystallite output "orientation" now by default returns the orientation as quaternion. if you want euler angles instead, you have to add "eulerangles" as a crystallite output in your material.config file (see material.config template). for input of orientations in the texture block of the material.config you still have to specify the rotation in terms of euler angles, quaternions are not yet supported for input.
2010-03-18 17:53:17 +05:30
math_RtoQuaternion, &
corrected (?) disorientation calc and introduced some new assisting functions
2010-04-28 22:49:58 +05:30
math_QuaternionDisorientation, &
Like this Euler angles AND grain rotation should be OK.
2010-05-11 20:36:21 +05:30
math_qConj
detabbed file for better readability
2010-02-19 19:14:38 +05:30
use FEsolving, only: FEsolving_execElem, &
FEsolving_execIP
use IO, only: IO_warning
use material, only: material_phase, &
homogenization_Ngrains, &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
phase_localPlasticity, &
phase_plasticityInstance
detabbed file for better readability
2010-02-19 19:14:38 +05:30
use mesh, only: mesh_element, &
mesh_ipNeighborhood, &
FE_NipNeighbors
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
use constitutive_nonlocal, only: constitutive_nonlocal_structure, &
constitutive_nonlocal_updateCompatibility
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
implicit none
!*** input variables ***!
!*** output variables ***!
!*** local variables ***!
detabbed file for better readability
2010-02-19 19:14:38 +05:30
integer(pInt) e, & ! element index
i, & ! integration point index
g, & ! grain index
n, & ! neighbor index
neighboring_e, & ! element index of my neighbor
neighboring_i, & ! integration point index of my neighbor
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
myPhase, & ! phase
neighboringPhase, &
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
myInstance, & ! instance of plasticity
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
neighboringInstance, &
myStructure, & ! lattice structure
neighboringStructure
changed internal representation of orientation and misorientation from euler angles to quaternions (this should also fix some bugs in the math_misorientation subroutine). includes a couple of new functions in math.f90 and some changes in crystallite.f90. beware that crystallite output "orientation" now by default returns the orientation as quaternion. if you want euler angles instead, you have to add "eulerangles" as a crystallite output in your material.config file (see material.config template). for input of orientations in the texture block of the material.config you still have to specify the rotation in terms of euler angles, quaternions are not yet supported for input.
2010-03-18 17:53:17 +05:30
real(pReal), dimension(3,3) :: U, R
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
real(pReal), dimension(4) :: orientation
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
logical error
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
! --- CALCULATE ORIENTATION AND LATTICE ROTATION ---
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
!$OMP PARALLEL DO PRIVATE(error,U,R,orientation)
detabbed file for better readability
2010-02-19 19:14:38 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2)
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do g = 1_pInt,homogenization_Ngrains(mesh_element(3,e))
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
* OpenMP does not like unbounded array subscripts in function calls * some write statements were still not enclosed by CRITICAL construct, some needed a MASTER construct
2010-11-11 18:44:53 +05:30
call math_pDecomposition(crystallite_Fe(1:3,1:3,g,i,e), U, R, error) ! polar decomposition of Fe
detabbed file for better readability
2010-02-19 19:14:38 +05:30
if (error) then
polishing, adding _pInt etc. where applicable post_results now handels zero increment different (like FEM, it is always there even if it is not counted)
2012-02-13 19:48:07 +05:30
call IO_warning(650_pInt, e, i, g)
orientation = [1.0_pReal, 0.0_pReal, 0.0_pReal, 0.0_pReal] ! fake orientation
detabbed file for better readability
2010-02-19 19:14:38 +05:30
else
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
orientation = math_RtoQuaternion(transpose(R))
detabbed file for better readability
2010-02-19 19:14:38 +05:30
endif
simplified disorientation calculation. performed FEM check that "grainrotation" reflects the *active* rotation from the starting orientation to the current one with respect to the lab coord system (as expected).
2011-04-15 00:39:44 +05:30
crystallite_rotation(1:4,g,i,e) = math_QuaternionDisorientation(crystallite_orientation0(1:4,g,i,e), & ! active rotation from ori0
orientation, & ! to current orientation
0_pInt ) ! we don't want symmetry here
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_orientation(1:4,g,i,e) = orientation
New output can be requested from crystallite: (output) grainrotation it gives the deviation from the initial grain orientation in axis-angle representation with the angle in degrees.
2010-04-12 16:44:36 +05:30
enddo
enddo
enddo
* enclose wall time measurement for LpAndItsTangent and count of leapfrogbreaks by CRITICAL construct * better use SINGLE (having an implicit barrier at the end) instead of MASTER construct * deleted all explicit BARRIERs after do loops since parallel loop construct implies barrier at the end
2010-11-19 22:59:29 +05:30
!$OMP END PARALLEL DO
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
! --- UPDATE SOME ADDITIONAL VARIABLES THAT ARE NEEDED FOR NONLOCAL MATERIAL ---
! --- we use crystallite_orientation from above, so need a seperate loop
made DAMASK to work with gfortran: -removed to long lines -restructured f2py modules and merged make_DAMASK2Python into setup processing -setup_code.py now sets library path in makefile and asks for compile switches for spectral code -substituted \ in format strings with $ restructured DAMASK_spectral: -more logical output and structure of code -better input for spectral debug parameters
2011-12-06 22:28:17 +05:30
!$OMP PARALLEL DO PRIVATE(myPhase,myInstance,myStructure,neighboring_e,neighboring_i,neighboringPhase,&
!$OMP neighboringInstance,neighboringStructure)
New output can be requested from crystallite: (output) grainrotation it gives the deviation from the initial grain orientation in axis-angle representation with the angle in degrees.
2010-04-12 16:44:36 +05:30
do e = FEsolving_execElem(1),FEsolving_execElem(2)
do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e)
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
myPhase = material_phase(1,i,e) ! get my phase
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. phase_localPlasticity(myPhase)) then ! if nonlocal model
myInstance = phase_plasticityInstance(myPhase)
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
myStructure = constitutive_nonlocal_structure(myInstance) ! get my crystal structure
New array crystallite_symmetryID(i,g,e) is now filled during initialization run with 1 for bcc and fcc phase and 2 for hexagonal phase. The values are needed for misorientation calculations to apply the correct symmetry operators for cubic and hexagonal phases.
2010-04-19 15:33:34 +05:30
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
! --- calculate disorientation between me and my neighbor ---
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do n = 1_pInt,FE_NipNeighbors(mesh_element(2,e)) ! loop through my neighbors
detabbed file for better readability
2010-02-19 19:14:38 +05:30
neighboring_e = mesh_ipNeighborhood(1,n,i,e)
neighboring_i = mesh_ipNeighborhood(2,n,i,e)
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
if ((neighboring_e > 0) .and. (neighboring_i > 0)) then ! if neighbor exists
neighboringPhase = material_phase(1,neighboring_i,neighboring_e) ! get my neighbor's phase
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
if (.not. phase_localPlasticity(neighboringPhase)) then ! neighbor got also nonlocal plasticity
neighboringInstance = phase_plasticityInstance(neighboringPhase)
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
neighboringStructure = constitutive_nonlocal_structure(neighboringInstance) ! get my neighbor's crystal structure
if (myStructure == neighboringStructure) then ! if my neighbor has same crystal structure like me
crystallite_disorientation(:,n,1,i,e) = &
* OpenMP does not like unbounded array subscripts in function calls * some write statements were still not enclosed by CRITICAL construct, some needed a MASTER construct
2010-11-11 18:44:53 +05:30
math_QuaternionDisorientation( crystallite_orientation(1:4,1,i,e), &
crystallite_orientation(1:4,1,neighboring_i,neighboring_e), &
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
crystallite_symmetryID(1,i,e)) ! calculate disorientation
else ! for neighbor with different phase
crystallite_disorientation(:,n,1,i,e) = (/0.0_pReal, 1.0_pReal, 0.0_pReal, 0.0_pReal/) ! 180 degree rotation about 100 axis
endif
replaced keyword constitution with plasticity in preparation of upcomming generalized elasticity
2012-03-12 19:39:37 +05:30
else ! for neighbor with local plasticity
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
crystallite_disorientation(:,n,1,i,e) = (/-1.0_pReal, 0.0_pReal, 0.0_pReal, 0.0_pReal/) ! homomorphic identity
detabbed file for better readability
2010-02-19 19:14:38 +05:30
endif
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
else ! no existing neighbor
crystallite_disorientation(:,n,1,i,e) = (/-1.0_pReal, 0.0_pReal, 0.0_pReal, 0.0_pReal/) ! homomorphic identity
statedamper has to be local (specific for each e,i,g); with a global damping we may produce spurious convergence
2010-04-29 13:11:29 +05:30
endif
detabbed file for better readability
2010-02-19 19:14:38 +05:30
enddo
* in nonlocal model: dislocation flux now with valid description also for large angle grain boundaries; transfer of dislocations from one slip system to the other according to new variable "constitutive_nonlocal_compatibility" which depends on the angle between slip plane normals and slip directions and is updated once per cycle in function "crystallite_orientations" * reactivated debugging functionality for "non-standard" integration methods
2010-10-12 18:38:54 +05:30
! --- calculate compatibility and transmissivity between me and my neighbor ---
call constitutive_nonlocal_updateCompatibility(crystallite_orientation,i,e)
detabbed file for better readability
2010-02-19 19:14:38 +05:30
endif
enddo
enddo
* enclose wall time measurement for LpAndItsTangent and count of leapfrogbreaks by CRITICAL construct * better use SINGLE (having an implicit barrier at the end) instead of MASTER construct * deleted all explicit BARRIERs after do loops since parallel loop construct implies barrier at the end
2010-11-19 22:59:29 +05:30
!$OMP END PARALLEL DO
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end subroutine crystallite_orientations
new subroutine crystallite_orientations: calculates the orientation matrix and the euler angles and - in case of single grain ips - the misorientation for each neighboring ip. The calculation of the misorientation is now done once in crystallite init and at the end of every FE increment. This saves a lot of time compared to doing it in dotState for every crystallite subinc.
2009-12-18 21:16:33 +05:30
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
!********************************************************************
! return results of particular grain
!********************************************************************
function crystallite_postResults(&
dt,& ! time increment
g,& ! grain number
i,& ! integration point number
e & ! element number
)
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
!*** variables and functions from other modules ***!
New output can be requested from crystallite: (output) grainrotation it gives the deviation from the initial grain orientation in axis-angle representation with the angle in degrees.
2010-04-12 16:44:36 +05:30
use math, only: math_QuaternionToEuler, &
crystallite: - grainrotation calculation now is done with symmetryID 0, i.e. without symmetry reduction since we want the absolute misorientation. - While math has everything in radians, post results eulerangles and axisangle are given in degrees. And: grain rotation seems OK after the previous changes in math module.
2010-05-07 17:31:46 +05:30
math_QuaternionToAxisAngle, &
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
math_mul33x33, &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33, &
math_det33, &
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
math_I3, &
inDeg, &
math_Mandel6to33
Calculation of current ip volumes now working. Crystallite output also reflects current grain volume, not reference volume. However, this is only available for Marc. Abaqus and spectral method still return the reference ip volume. The ip coordinates though are correctly updated for all solver types.
2011-08-10 22:07:17 +05:30
use mesh, only: mesh_element, &
mesh_ipVolume
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
use material, only: microstructure_crystallite, &
crystallite_Noutput, &
material_phase, &
added "texture " as possible crystallite output => reports ID for later discrimination...
2011-03-22 19:10:27 +05:30
material_texture, &
Calculation of current ip volumes now working. Crystallite output also reflects current grain volume, not reference volume. However, this is only available for Marc. Abaqus and spectral method still return the reference ip volume. The ip coordinates though are correctly updated for all solver types.
2011-08-10 22:07:17 +05:30
homogenization_Ngrains
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
use constitutive, only: constitutive_sizePostResults, &
added elastic stiffness matrix as crystallite output
2012-03-01 18:36:09 +05:30
constitutive_postResults, &
constitutive_homogenizedC
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
implicit none
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
!*** input variables ***!
integer(pInt), intent(in):: e, & ! element index
i, & ! integration point index
g ! grain index
constitutive_nonlocal: - read in activation energy for dislocation glide from material.config - changed naming of dDipMin/Max to dLower/dUpper - added new outputs: rho_dot, rho_dot_dip, rho_dot_gen, rho_dot_sgl2dip, rho_dot_dip2sgl, rho_dot_ann_ath, rho_dot_ann_the, rho_dot_flux, d_upper_edge, d_upper_screw, d_upper_dot_edge, d_upper_dot_screw - poisson's ratio is now calculated from elastic constants - microstrucutre has state as first argument, since this is our output variable - periodic boundary conditions are taken into account for fluxes and internal stresses. for the moment, flag has to be set in constitutive_nonlocal. - corrected calculation for dipole formation by glide - added terms for dipole formation/annihilation by stress decrease/increase constitutive: - passing of arguments is adapted for constitutive_nonlocal model crystallite: - in stiffness calculation: call to collect_dotState used wrong arguments - crystallite_postResults uses own Tstar_v and temperature, no need for passing them from materialpoint_postResults homogenization: - crystallite_postResults uses own Tstar_v and temperature, no need for passing them from materialpoint_postResults IO: - changed error message 229 material.config: - changed example for nonlocal constitution according to constitutive_nonlocal all: - added some flush statements
2009-10-20 20:06:03 +05:30
real(pReal), intent(in):: dt ! time increment
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
!*** output variables ***!
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
real(pReal), dimension(1+crystallite_sizePostResults(microstructure_crystallite(mesh_element(4,e)))+ &
1+constitutive_sizePostResults(g,i,e)) :: crystallite_postResults
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
in crystallite_stressAndItsTangent we now update the state first (explicit integration) and then integrate the stress (implicit integration) also inside the stress integration, it is now possible to define the frequency of the Jacobian update oin the LpLoop through iJacoLpResiduum. The frequency of the Jacobian update for the stiffness in the crystallite loop is controlled by the parameter iJacoStiffness. also updated the corresponding stuctograms in the documentation
2009-06-09 16:35:29 +05:30
!*** local variables ***!
sorry, in rev 568 some variables were not declared in crystallite_postResults
2010-05-18 18:06:09 +05:30
real(pReal), dimension(3,3) :: Ee
ip volume is now based on the determinant of F. "mesh_ipVolume" represents the initial volume and is multiplied with det(F) wherever the current volume is needed. Since this works for all solver types, the "volume" output in crystallite is now also correct for spectral method and abaqus.
2011-08-19 16:48:56 +05:30
real(pReal) detF
removed unused variables
2011-04-13 19:46:22 +05:30
integer(pInt) o,c,crystID,mySize
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
crystID = microstructure_crystallite(mesh_element(4,e))
crystallite_postResults = 0.0_pReal
c = 0_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1) = real(crystallite_sizePostResults(crystID),pReal) ! size of results from cryst
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
c = c + 1_pInt
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
again: adding pInt, removing redundant use statments, chang in dble to real(,pReal)
2012-02-21 22:01:37 +05:30
do o = 1_pInt,crystallite_Noutput(crystID)
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 0_pInt
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
select case(crystallite_output(o,crystID))
case ('phase')
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 1_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1) = real(material_phase(g,i,e),pReal) ! phaseID of grain
added "texture " as possible crystallite output => reports ID for later discrimination...
2011-03-22 19:10:27 +05:30
case ('texture')
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 1_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1) = real(material_texture(g,i,e),pReal) ! textureID of grain
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
case ('volume')
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 1_pInt
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
detF = math_det33(crystallite_partionedF(1:3,1:3,g,i,e)) ! V_current = det(F) * V_reference
ip volume is now based on the determinant of F. "mesh_ipVolume" represents the initial volume and is multiplied with det(F) wherever the current volume is needed. Since this works for all solver types, the "volume" output in crystallite is now also correct for spectral method and abaqus.
2011-08-19 16:48:56 +05:30
crystallite_postResults(c+1) = detF * mesh_ipVolume(i,e) / homogenization_Ngrains(mesh_element(3,e)) ! grain volume (not fraction but absolute)
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
case ('orientation')
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 4_pInt
crystallite_postResults(c+1:c+mySize) = crystallite_orientation(1:4,g,i,e) ! grain orientation as quaternion
changed internal representation of orientation and misorientation from euler angles to quaternions (this should also fix some bugs in the math_misorientation subroutine). includes a couple of new functions in math.f90 and some changes in crystallite.f90. beware that crystallite output "orientation" now by default returns the orientation as quaternion. if you want euler angles instead, you have to add "eulerangles" as a crystallite output in your material.config file (see material.config template). for input of orientations in the texture block of the material.config you still have to specify the rotation in terms of euler angles, quaternions are not yet supported for input.
2010-03-18 17:53:17 +05:30
case ('eulerangles')
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 3_pInt
crystallite_postResults(c+1:c+mySize) = inDeg * math_QuaternionToEuler(crystallite_orientation(1:4,g,i,e)) ! grain orientation as Euler angles in degree
New output can be requested from crystallite: (output) grainrotation it gives the deviation from the initial grain orientation in axis-angle representation with the angle in degrees.
2010-04-12 16:44:36 +05:30
case ('grainrotation')
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
mySize = 4_pInt
crystallite_postResults(c+1:c+mySize) = math_QuaternionToAxisAngle(crystallite_rotation(1:4,g,i,e)) ! grain rotation away from initial orientation as axis-angle
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
crystallite_postResults(c+4) = inDeg * crystallite_postResults(c+4) ! angle in degree
new substructure with 'include' and 'config' directories renaming of mpie_... to DAMASK for main usersubroutines extension of element outputs from 5 to 8 digits (FFT!!!)
2011-05-11 22:08:45 +05:30
! remark: tensor output is of the form 11,12,13, 21,22,23, 31,32,33
! thus row index i is slow, while column index j is fast. reminder: "row is slow"
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
case ('defgrad','f')
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(math_transpose33(crystallite_partionedF(1:3,1:3,g,i,e)),[mySize])
added total Green-Lagrange strain to crystallite outputs
2012-01-20 15:55:35 +05:30
case ('e')
mySize = 9_pInt
crystallite_postResults(c+1:c+mySize) = 0.5_pReal * reshape((math_mul33x33( &
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
math_transpose33(crystallite_partionedF(1:3,1:3,g,i,e)), &
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_partionedF(1:3,1:3,g,i,e)) - math_I3),[mySize])
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
case ('fe')
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(math_transpose33(crystallite_Fe(1:3,1:3,g,i,e)),[mySize])
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
case ('ee')
added new math function "math_deviatoric33" which returns the deviatoric part of a 3x3 tensor renamed some math functions, so that we have a universal naming scheme: for matrix multiplications use an "x" (e.g. math_mul33x3); don't use the "x" to describe the shape of the tensor that the function is applied to (e.g. math_invert33 instead of math_invert3x3)
2012-01-26 19:20:00 +05:30
Ee = 0.5_pReal * (math_mul33x33(math_transpose33(crystallite_Fe(1:3,1:3,g,i,e)), crystallite_Fe(1:3,1:3,g,i,e)) - math_I3)
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(Ee,[mySize])
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
case ('fp')
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(math_transpose33(crystallite_Fp(1:3,1:3,g,i,e)),[mySize])
added "Lp" as crystallite output
2011-02-25 13:45:26 +05:30
case ('lp')
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(math_transpose33(crystallite_Lp(1:3,1:3,g,i,e)),[mySize])
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
case ('p','firstpiola','1stpiola')
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(math_transpose33(crystallite_P(1:3,1:3,g,i,e)),[mySize])
added some output variables in crystallite: F, Fe, Fp, Ee, P, S
2010-05-18 13:27:13 +05:30
case ('s','tstar','secondpiola','2ndpiola')
mySize = 9_pInt
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1:c+mySize) = reshape(math_Mandel6to33(crystallite_Tstar_v(1:6,g,i,e)),[mySize])
added elastic stiffness matrix as crystallite output
2012-03-01 18:36:09 +05:30
case ('elasmatrix')
mySize = 36_pInt
crystallite_postResults(c+1:c+mySize) = reshape(constitutive_homogenizedC(g,i,e),(/mySize/))
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
end select
shape mismatch in crystallite, invalid names for variables(pos, size) in homogenization corrected. polishing of DAMASK_spectral_interface and makefile
2011-08-01 23:40:55 +05:30
c = c + mySize
reworked crystallite part to allow for flexible user output --> new "crystallite" part in config file --> new "crystallite" option for microstructures --> new output file "...job.outputCrystallite" to be used in conjunction with marc_addUserOutput for meaningful naming of User Defined Vars.
2010-02-25 23:09:11 +05:30
enddo
new substructure with 'include' and 'config' directories renaming of mpie_... to DAMASK for main usersubroutines extension of element outputs from 5 to 8 digits (FFT!!!)
2011-05-11 22:08:45 +05:30
polishing: removed variable names like 'unit' and 'data' that are keywords of fortran and ensured that integer and real precision matches independent of machine standard. removed cut_off parameter for damask_spectral removed outpot of derived divergence measures and added RMS output in brackets added comments and options to the makefile
2012-02-16 00:28:38 +05:30
crystallite_postResults(c+1) = real(constitutive_sizePostResults(g,i,e),pReal) ! size of constitutive results
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
c = c + 1_pInt
check whether there is any constitutive output
2012-05-11 13:08:20 +05:30
if (constitutive_sizePostResults(g,i,e) > 0_pInt) &
crystallite_postResults(c+1:c+constitutive_sizePostResults(g,i,e)) = constitutive_postResults(crystallite_Tstar_v(1:6,g,i,e), &
crystallite_Fe, &
crystallite_Temperature(g,i,e), &
dt, g, i, e)
constitutive_nonlocal: - corrected flux term - multiplication is now aware of dislocation type - corrected change rate for "dipole size" dupper - corrected term for dipole dissociation by stress change - added transmissivity term in fluxes which accounts for misorientation between two neighboring grains (yet hardcoded transmissivity according to misorientation angle) - added more output variables constitutive: - 2 additional variables "previousDotState" and "previousDotState2", which are used to store the previous and second previous dotState (used in crystallite for acceleration/stabilization of state integration) - timer for dotState now measures the time for calls to constitutive_ collectState (used to reside in crystallite_updateState, which is not critical in terms of calculation time anymore) crystallite: - convergence check for nonlocal elments is now done at end of crystallite loop, not at the beginning; we simple set all elements to not converged if there is at least one nonlocal element that did not converge - need call to microstructure before first call to collect dotState for dependent states - stiffness calculation (jacobian): if there are nonlocal elements, we also have to consider changes in our neighborhood's states; so for every perturbed component in a single ip, we have to loop over all elements; since this is extremely time-consuming, we just perturb one component per cycle, starting with the one that changes the most during regular time step. - updateState gets a damping prefactor for our dotState that helps to improve convergence; prefactor is calculated according to change of dotState IO: - additional warning message for unknown crystal symmetry
2009-12-15 13:50:31 +05:30
c = c + constitutive_sizePostResults(g,i,e)
did a lot of polishing: - removed unnecessary "return" before end of subroutine or function: - changed undetermined array length (:) to (1:3) To prevent problems with some code analysing tools: - "3D oneliner loops" (with ";) only for "do" and "enddo" at the same time - removed line continuation in OMP statements made the makefile more flexible, removed heap-arrays switch
2011-09-13 21:24:06 +05:30
added new, flexible debugging scheme. now all modules have their own debug specification. compiles and runs, I hope nothing is broken did a lot of polishing
2012-03-09 01:55:28 +05:30
end function crystallite_postResults
major restructuring of code. homogenization as well as constitutive are now free to choose. the runtime got somewhat longer (25% on simple tests) compared to a hardcoded isostrain homogenization. this might be a point of further optimization at a later stage... please use homogenization_isostrain.f90 as starting point / example for future developments of homog-schemes. the homogenization scheme now can additionally output certain results. hence, the userdata structure at each integration point now looks like this: - sizeHomogPostResults - block of that size containing homogPostResults then for each grain: - sizeGrainPostResults - block of that size containing crystallitePostResults, which consist of: + phaseID + volFrac + Eulers (3) + any constitutive post results requested
2009-05-07 21:57:36 +05:30
END MODULE
restructured stress integration. Double loop for stress integration (Lp and stress) with cutback step in IntegrateStress is replaced by single loop for Lp without cutback. loop counter and limits are accordingly renamed and implemented
2009-05-28 22:08:40 +05:30
!##############################################################