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/numerics.f90

459 lines
25 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$
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
!##############################################################
MODULE numerics
!##############################################################
use prec, only: pInt, pReal
moved all routines from postprocessingMath to math.90, renamed the module to DAMASK, changed scripts and interfaces accordingly. polished math.f90 (mainly added _pInt/_pReal and intent(in/out)) curl_fft is still a dummy function
2011-12-01 17:31:13 +05:30
use IO, only: IO_warning
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
implicit none
character(len=64), parameter :: numerics_configFile = 'numerics.config' ! name of configuration file
first try of implementing a rotation of the loadcase coordinate system. Seems to work so far for one loadcase and homogeneous materials.
2011-10-24 23:56:34 +05:30
integer(pInt) :: iJacoStiffness, & ! frequency of stiffness update
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
iJacoLpresiduum, & ! frequency of Jacobian update of residuum in Lp
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
nHomog, & ! homogenization loop limit (only for debugging info, loop limit is determined by "subStepMinHomog")
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
nMPstate, & ! materialpoint state loop limit
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
nCryst, & ! crystallite loop limit (only for debugging info, loop limit is determined by "subStepMinCryst")
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
nState, & ! state loop limit
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
nStress, & ! stress loop limit
* 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
pert_method, & ! method used in perturbation technique for tangent
sorry, forgot to commit the numerics.f90, too
2011-02-23 18:00:52 +05:30
numerics_integrationMode ! integration mode 1 = central solution ; integration mode 2 = perturbation
integer(pInt), dimension(2) :: numerics_integrator ! method used for state integration (central & perturbed state)
first try of implementing a rotation of the loadcase coordinate system. Seems to work so far for one loadcase and homogeneous materials.
2011-10-24 23:56:34 +05:30
real(pReal) :: relevantStrain, & ! strain increment considered significant (used by crystallite to determine whether strain inc is considered significant)
new numerics parameter "defgradTolerance" replaces "relevantStrain" in cpfem, since "relevantStrain" is also used in crystallite but in a different context. "defgradTolerance" gets the same standard value as "relevantStrain" so calculations should be consistent with older ones
2010-05-20 20:25:11 +05:30
defgradTolerance, & ! deviation of deformation gradient that is still allowed (used by CPFEM to determine outdated ffn1)
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
pert_Fg, & ! strain perturbation for FEM Jacobi
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
subStepMinCryst, & ! minimum (relative) size of sub-step allowed during cutback in crystallite
subStepMinHomog, & ! minimum (relative) size of sub-step allowed during cutback in homogenization
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
subStepSizeCryst, & ! size of first substep when cutback in crystallite
subStepSizeHomog, & ! size of first substep when cutback in homogenization
stepIncreaseCryst, & ! increase of next substep size when previous substep converged in crystallite
stepIncreaseHomog, & ! increase of next substep size when previous substep converged in homogenization
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
rTol_crystalliteState, & ! relative tolerance in crystallite state loop
rTol_crystalliteTemperature, & ! relative tolerance in crystallite temperature loop
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
rTol_crystalliteStress, & ! relative tolerance in crystallite stress loop
aTol_crystalliteStress, & ! absolute tolerance in crystallite stress loop
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
Additional feature to the RGC scheme: The volumetric consistency constraint. This is implemented by penalizing any volumetric discrepancy which occurs due to severe relaxation. The penalty for volume inconsistency is described using a power-law model. The setting for this function can be done in the numerics.config via three new parameters, i.e., maxvoldiscrepancy_RGC, voldiscrepancymod_RGC and discrepancypower_RGC. For monintoring, an extra output variable in prescribed in the material.config in the RGC section, namely "(output) volumediscrepancy". IO.f90 and numerics.f90 has been modified accordingly to accommodate these changes
2009-12-16 21:50:53 +05:30
!* RGC parameters: added <<<updated 17.12.2009>>>
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
absTol_RGC, & ! absolute tolerance of RGC residuum
relTol_RGC, & ! relative tolerance of RGC residuum
absMax_RGC, & ! absolute maximum of RGC residuum
relMax_RGC, & ! relative maximum of RGC residuum
pPert_RGC, & ! perturbation for computing RGC penalty tangent
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
xSmoo_RGC, & ! RGC penalty smoothing parameter (hyperbolic tangent)
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
viscPower_RGC, & ! power (sensitivity rate) of numerical viscosity in RGC scheme
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
viscModus_RGC, & ! stress modulus of RGC numerical viscosity
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
refRelaxRate_RGC, & ! reference relaxation rate in RGC viscosity
Additional feature to the RGC scheme: The volumetric consistency constraint. This is implemented by penalizing any volumetric discrepancy which occurs due to severe relaxation. The penalty for volume inconsistency is described using a power-law model. The setting for this function can be done in the numerics.config via three new parameters, i.e., maxvoldiscrepancy_RGC, voldiscrepancymod_RGC and discrepancypower_RGC. For monintoring, an extra output variable in prescribed in the material.config in the RGC section, namely "(output) volumediscrepancy". IO.f90 and numerics.f90 has been modified accordingly to accommodate these changes
2009-12-16 21:50:53 +05:30
maxdRelax_RGC, & ! threshold of maximum relaxation vector increment (if exceed this then cutback)
maxVolDiscr_RGC, & ! threshold of maximum volume discrepancy allowed
volDiscrMod_RGC, & ! stiffness of RGC volume discrepancy (zero = without volume discrepancy constraint)
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
volDiscrPow_RGC, & ! powerlaw penalty for volume discrepancy
!* spectral parameters:
removed hard-coded tolerances from mpie_spectral and put them to numerics/IO removed storage of full cauchy stres field from mpie_spectral.f90, only average is stored now added cauchy stress and von mises equivalent calculation to spectral post.
2011-01-31 22:37:42 +05:30
err_div_tol, & ! error of divergence in fourier space
added two parameters to control behavior of FFTW, timelimit is not working at the moment remove fftw3.f as it is not needed anymore !incremental update, wait for commit of damask_spectral.f90 before checking out
2011-10-18 14:46:18 +05:30
err_stress_tolrel, & ! factor to multiply with highest stress to get err_stress_tol
first try of implementing a rotation of the loadcase coordinate system. Seems to work so far for one loadcase and homogeneous materials.
2011-10-24 23:56:34 +05:30
fftw_timelimit, & ! sets the timelimit of plan creation for FFTW, see manual on www.fftw.org
some small improvements regarding the rotation of the loadcase frame
2011-10-25 19:08:24 +05:30
rotation_tol ! tolerance of rotation specified in loadcase
moved all routines from postprocessingMath to math.90, renamed the module to DAMASK, changed scripts and interfaces accordingly. polished math.f90 (mainly added _pInt/_pReal and intent(in/out)) curl_fft is still a dummy function
2011-12-01 17:31:13 +05:30
character(len=64) :: fftw_planner_string ! reads the planing-rigor flag, see manual on www.fftw.org
changed fftw from legacy fortran to new (2003) fortran (calling c routines directly) renamed "steps" consequently to "incs" moved kdtree2 to math.f90, put original source to private folder
2012-01-13 21:48:16 +05:30
integer(pInt) :: fftw_planner_flag ! conversion of fftw_planner_string to integer, basically what is usually done in the include file of fftw
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
logical :: memory_efficient,& ! for fast execution (pre calculation of gamma_hat)
indroduced 3 more flags for fine control of spectral algorithm
2012-01-25 14:26:46 +05:30
divergence_correction,& ! correct divergence calculation in fourier space
update_gamma,& ! update gamma operator with current stiffness
simplified_algorithm ! use short algorithm without fluctuation field
real(pReal) :: cut_off_value ! percentage of frequencies to cut away
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
integer(pInt) :: itmax , & ! maximum number of iterations
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
mpie_spectral and mpie_interface: changed workingdir from pathToLoadFile to pathToGeomFile mpie_spectral and numerics: added switch to prevent pre calculation of gamma_hat. slower, but saves memory 3Dvisualize: started to add support for gmsh (not fully working yet) reconstruct: new version of f2py/Fortran subroutines for output of results from spectral method
2011-02-07 20:05:42 +05:30
removed hard-coded tolerances from mpie_spectral and put them to numerics/IO removed storage of full cauchy stres field from mpie_spectral.f90, only average is stored now added cauchy stress and von mises equivalent calculation to spectral post.
2011-01-31 22:37:42 +05:30
!* Random seeding parameters
fixedSeed ! fixed seeding for pseudo-random number generator
!* OpenMP variable
corrected typos and such
2011-09-13 21:27:58 +05:30
integer(pInt) DAMASK_NumThreadsInt ! value stored in environment variable DAMASK_NUM_THREADS
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +05:30
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
CONTAINS
!*******************************************
! initialization subroutine
!*******************************************
subroutine numerics_init()
!*** variables and functions from other modules ***!
use prec, only: pInt, &
pReal
use IO, only: IO_error, &
IO_open_file, &
IO_isBlank, &
IO_stringPos, &
IO_stringValue, &
IO_lc, &
IO_floatValue, &
IO_intValue
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +05:30
!$ use OMP_LIB ! the openMP function library
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
implicit none
!*** input variables ***!
!*** output variables ***!
!*** local variables ***!
integer(pInt), parameter :: fileunit = 300
integer(pInt), parameter :: maxNchunks = 2
integer(pInt), dimension(1+2*maxNchunks) :: positions
character(len=64) tag
character(len=1024) line
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +05:30
! OpenMP variable
changed MPIE_NUM_THREADS to DAMASK_NUM_THREADS
2011-05-28 15:12:25 +05:30
!$ character(len=4) DAMASK_NumThreadsString !environment variable DAMASK_NUM_THREADS
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +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 CRITICAL (write2out)
write(6,*)
write(6,*) '<<<+- numerics init -+>>>'
write(6,*) '$Id$'
write(6,*)
!$OMP END CRITICAL (write2out)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
! initialize all parameters with standard values
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
relevantStrain = 1.0e-7_pReal
new numerics parameter "defgradTolerance" replaces "relevantStrain" in cpfem, since "relevantStrain" is also used in crystallite but in a different context. "defgradTolerance" gets the same standard value as "relevantStrain" so calculations should be consistent with older ones
2010-05-20 20:25:11 +05:30
defgradTolerance = 1.0e-7_pReal
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
iJacoStiffness = 1_pInt
iJacoLpresiduum = 1_pInt
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
pert_Fg = 1.0e-7_pReal
pert_method = 1
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
nHomog = 20_pInt
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
subStepMinHomog = 1.0e-3_pReal
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
subStepSizeHomog = 0.25
stepIncreaseHomog = 1.5
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
nMPstate = 10_pInt
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
nCryst = 20_pInt
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
subStepMinCryst = 1.0e-3_pReal
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
subStepsizeCryst = 0.25
stepIncreaseCryst = 1.5
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
nState = 10_pInt
nStress = 40_pInt
rTol_crystalliteState = 1.0e-6_pReal
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
rTol_crystalliteTemperature = 1.0e-6_pReal
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
rTol_crystalliteStress = 1.0e-6_pReal
absolute tolerance was just fine -- residuum is in Lp not in stress. Hence, unit is strain and not Pa...
2009-10-19 18:23:56 +05:30
aTol_crystalliteStress = 1.0e-8_pReal ! residuum is in Lp (hence strain on the order of 1e-8 here)
sorry, forgot to commit the numerics.f90, too
2011-02-23 18:00:52 +05:30
numerics_integrator(1) = 1 ! fix-point iteration
numerics_integrator(2) = 1 ! fix-point iteration
* 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
Additional feature to the RGC scheme: The volumetric consistency constraint. This is implemented by penalizing any volumetric discrepancy which occurs due to severe relaxation. The penalty for volume inconsistency is described using a power-law model. The setting for this function can be done in the numerics.config via three new parameters, i.e., maxvoldiscrepancy_RGC, voldiscrepancymod_RGC and discrepancypower_RGC. For monintoring, an extra output variable in prescribed in the material.config in the RGC section, namely "(output) volumediscrepancy". IO.f90 and numerics.f90 has been modified accordingly to accommodate these changes
2009-12-16 21:50:53 +05:30
!* RGC parameters: added <<<updated 17.12.2009>>> with moderate setting
just small changes in the 'default' value of RGC numerical parameters.
2009-10-30 15:24:52 +05:30
absTol_RGC = 1.0e+4
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
relTol_RGC = 1.0e-3
just small changes in the 'default' value of RGC numerical parameters.
2009-10-30 15:24:52 +05:30
absMax_RGC = 1.0e+10
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
relMax_RGC = 1.0e+2
just small changes in the 'default' value of RGC numerical parameters.
2009-10-30 15:24:52 +05:30
pPert_RGC = 1.0e-7
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
xSmoo_RGC = 1.0e-5
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
viscPower_RGC = 1.0e+0 ! Newton viscosity (linear model)
introduction of a possibility to have homogeneous element (all ips in one element are identical, sort of reduced integration) and bugs-fixing in crystallite.f90, homogenization_RGC.f90, numerics.f90.
2009-11-24 20:30:25 +05:30
viscModus_RGC = 0.0e+0 ! No viscosity is applied
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
refRelaxRate_RGC = 1.0e-3
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
maxdRelax_RGC = 1.0e+0
Additional feature to the RGC scheme: The volumetric consistency constraint. This is implemented by penalizing any volumetric discrepancy which occurs due to severe relaxation. The penalty for volume inconsistency is described using a power-law model. The setting for this function can be done in the numerics.config via three new parameters, i.e., maxvoldiscrepancy_RGC, voldiscrepancymod_RGC and discrepancypower_RGC. For monintoring, an extra output variable in prescribed in the material.config in the RGC section, namely "(output) volumediscrepancy". IO.f90 and numerics.f90 has been modified accordingly to accommodate these changes
2009-12-16 21:50:53 +05:30
maxVolDiscr_RGC = 1.0e-5 ! tolerance for volume discrepancy allowed
volDiscrMod_RGC = 1.0e+12
volDiscrPow_RGC = 5.0
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
!* spectral parameters:
added two parameters to control behavior of FFTW, timelimit is not working at the moment remove fftw3.f as it is not needed anymore !incremental update, wait for commit of damask_spectral.f90 before checking out
2011-10-18 14:46:18 +05:30
err_div_tol = 1.0e-4 ! 1.0e-4 proposed by Suquet
err_stress_tolrel = 0.01 ! relative tolerance for fullfillment of stress BC (1% of maximum stress)
itmax = 20_pInt ! Maximum iteration number
memory_efficient = .true. ! Precalculate Gamma-operator (81 double per point)
fftw_timelimit = -1.0_pReal ! no timelimit of plan creation for FFTW
moved all routines from postprocessingMath to math.90, renamed the module to DAMASK, changed scripts and interfaces accordingly. polished math.f90 (mainly added _pInt/_pReal and intent(in/out)) curl_fft is still a dummy function
2011-12-01 17:31:13 +05:30
fftw_planner_string ='FFTW_PATIENT'
some small improvements regarding the rotation of the loadcase frame
2011-10-25 19:08:24 +05:30
rotation_tol = 1.0e-12
indroduced 3 more flags for fine control of spectral algorithm
2012-01-25 14:26:46 +05:30
divergence_correction = .true. ! correct divergence by empirical factor
simplified_algorithm = .true. ! use algorithm without fluctuation field
update_gamma = .false. ! do not update gamma operator with current stiffness
cut_off_value = 0.0_pReal ! use all frequencies
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
!* Random seeding parameters
mpie_cpfem_marc.f90 >>> changing the compilation sequence of modules: numerics.f90 and IO.f90 move up, while math.f90 down. IO.f90 >>> adding "inRad" instead of using inRad from math.f90 module, since math.f90 module is now below IO.f90. numerics.f90 >>> now can read the parameter "fixed_seed" from numerics.config. this parameter is used to set a pseudo-random number generator/fixed seeding. default value is 0 (zero), which will give fully random number. math.f90 >> adding a possibility to fix the seeding (i.e., pseudo random number) numerics.config >>> add a new parameter: "fixed_seed"
2009-08-27 21:00:40 +05:30
fixedSeed = 0_pInt
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +05:30
changed MPIE_NUM_THREADS to DAMASK_NUM_THREADS
2011-05-28 15:12:25 +05:30
!* determin number of threads from environment variable DAMASK_NUM_THREADS
added option to build DAMASK_spectral without openMP (make OPENMP=OFF) fixed bug in bc_temperature assignment that was hitting memory. Temperature is taken from the first loadcase and evolves from there in an adiabatic fashion for the moment. I.e. T-specifications from later loadcases are ignored...
2011-08-03 23:27:28 +05:30
DAMASK_NumThreadsInt = 0_pInt
changed MPIE_NUM_THREADS to DAMASK_NUM_THREADS
2011-05-28 15:12:25 +05:30
!$ call GetEnv('DAMASK_NUM_THREADS',DAMASK_NumThreadsString) ! get environment variable DAMASK_NUM_THREADS...
!$ read(DAMASK_NumThreadsString,'(i4)') DAMASK_NumThreadsInt ! ...convert it to integer...
!$ if (DAMASK_NumThreadsInt < 1) DAMASK_NumThreadsInt = 1 ! ...ensure that its at least one...
!$ call omp_set_num_threads(DAMASK_NumThreadsInt) ! ...and use it as number of threads for parallel execution
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +05:30
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
! try to open the config file
if(IO_open_file(fileunit,numerics_configFile)) 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
!$OMP CRITICAL (write2out)
write(6,*) ' ... using values from config file'
write(6,*)
!$OMP END CRITICAL (write2out)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
line = ''
! read variables from config file and overwrite parameters
do
read(fileunit,'(a1024)',END=100) line
if (IO_isBlank(line)) cycle ! skip empty lines
positions = IO_stringPos(line,maxNchunks)
tag = IO_lc(IO_stringValue(line,positions,1)) ! extract key
select case(tag)
case ('relevantstrain')
relevantStrain = IO_floatValue(line,positions,2)
new numerics parameter "defgradTolerance" replaces "relevantStrain" in cpfem, since "relevantStrain" is also used in crystallite but in a different context. "defgradTolerance" gets the same standard value as "relevantStrain" so calculations should be consistent with older ones
2010-05-20 20:25:11 +05:30
case ('defgradtolerance')
defgradTolerance = IO_floatValue(line,positions,2)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
case ('ijacostiffness')
iJacoStiffness = IO_intValue(line,positions,2)
case ('ijacolpresiduum')
iJacoLpresiduum = IO_intValue(line,positions,2)
case ('pert_fg')
pert_Fg = IO_floatValue(line,positions,2)
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
case ('pert_method')
pert_method = IO_intValue(line,positions,2)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
case ('nhomog')
nHomog = IO_intValue(line,positions,2)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
case ('nmpstate')
nMPstate = IO_intValue(line,positions,2)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
case ('ncryst')
nCryst = IO_intValue(line,positions,2)
case ('nstate')
nState = IO_intValue(line,positions,2)
case ('nstress')
nStress = IO_intValue(line,positions,2)
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
case ('substepmincryst')
subStepMinCryst = IO_floatValue(line,positions,2)
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
case ('substepsizecryst')
subStepSizeCryst = IO_floatValue(line,positions,2)
case ('stepincreasecryst')
stepIncreaseCryst = IO_floatValue(line,positions,2)
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
case ('substepminhomog')
subStepMinHomog = IO_floatValue(line,positions,2)
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
case ('substepsizehomog')
subStepSizeHomog = IO_floatValue(line,positions,2)
case ('stepincreasehomog')
stepIncreaseHomog = IO_floatValue(line,positions,2)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
case ('rtol_crystallitestate')
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
rTol_crystalliteState = IO_floatValue(line,positions,2)
case ('rtol_crystallitetemperature')
Major Update: all modules are now correctly submitted
2009-07-01 16:25:31 +05:30
rTol_crystalliteTemperature = IO_floatValue(line,positions,2)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
case ('rtol_crystallitestress')
rTol_crystalliteStress = IO_floatValue(line,positions,2)
case ('atol_crystallitestress')
aTol_crystalliteStress = IO_floatValue(line,positions,2)
* 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
case ('integrator')
sorry, forgot to commit the numerics.f90, too
2011-02-23 18:00:52 +05:30
numerics_integrator(1) = IO_intValue(line,positions,2)
* 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
case ('integratorstiffness')
sorry, forgot to commit the numerics.f90, too
2011-02-23 18:00:52 +05:30
numerics_integrator(2) = IO_intValue(line,positions,2)
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
removed hard-coded tolerances from mpie_spectral and put them to numerics/IO removed storage of full cauchy stres field from mpie_spectral.f90, only average is stored now added cauchy stress and von mises equivalent calculation to spectral post.
2011-01-31 22:37:42 +05:30
!* RGC parameters:
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
case ('atol_rgc')
absTol_RGC = IO_floatValue(line,positions,2)
case ('rtol_rgc')
relTol_RGC = IO_floatValue(line,positions,2)
case ('amax_rgc')
absMax_RGC = IO_floatValue(line,positions,2)
case ('rmax_rgc')
relMax_RGC = IO_floatValue(line,positions,2)
case ('perturbpenalty_rgc')
pPert_RGC = IO_floatValue(line,positions,2)
case ('relevantmismatch_rgc')
xSmoo_RGC = IO_floatValue(line,positions,2)
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
case ('viscositypower_rgc')
viscPower_RGC = IO_floatValue(line,positions,2)
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
case ('viscositymodulus_rgc')
introduction of a possibility to have homogeneous element (all ips in one element are identical, sort of reduced integration) and bugs-fixing in crystallite.f90, homogenization_RGC.f90, numerics.f90.
2009-11-24 20:30:25 +05:30
viscModus_RGC = IO_floatValue(line,positions,2)
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
case ('refrelaxationrate_rgc')
refRelaxRate_RGC = IO_floatValue(line,positions,2)
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
case ('maxrelaxation_rgc')
maxdRelax_RGC = IO_floatValue(line,positions,2)
Additional feature to the RGC scheme: The volumetric consistency constraint. This is implemented by penalizing any volumetric discrepancy which occurs due to severe relaxation. The penalty for volume inconsistency is described using a power-law model. The setting for this function can be done in the numerics.config via three new parameters, i.e., maxvoldiscrepancy_RGC, voldiscrepancymod_RGC and discrepancypower_RGC. For monintoring, an extra output variable in prescribed in the material.config in the RGC section, namely "(output) volumediscrepancy". IO.f90 and numerics.f90 has been modified accordingly to accommodate these changes
2009-12-16 21:50:53 +05:30
case ('maxvoldiscrepancy_rgc')
maxVolDiscr_RGC = IO_floatValue(line,positions,2)
case ('voldiscrepancymod_rgc')
volDiscrMod_RGC = IO_floatValue(line,positions,2)
case ('discrepancypower_rgc')
volDiscrPow_RGC = IO_floatValue(line,positions,2)
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
!* spectral parameters
removed hard-coded tolerances from mpie_spectral and put them to numerics/IO removed storage of full cauchy stres field from mpie_spectral.f90, only average is stored now added cauchy stress and von mises equivalent calculation to spectral post.
2011-01-31 22:37:42 +05:30
case ('err_div_tol')
err_div_tol = IO_floatValue(line,positions,2)
case ('err_stress_tolrel')
err_stress_tolrel = IO_floatValue(line,positions,2)
case ('itmax')
itmax = IO_intValue(line,positions,2)
extended IO to cope with different name for solverJob and Model polishing, added error codes added FFTW library files
2011-02-21 20:07:38 +05:30
case ('memory_efficient')
memory_efficient = IO_intValue(line,positions,2) > 0_pInt
added two parameters to control behavior of FFTW, timelimit is not working at the moment remove fftw3.f as it is not needed anymore !incremental update, wait for commit of damask_spectral.f90 before checking out
2011-10-18 14:46:18 +05:30
case ('fftw_timelimit')
fftw_timelimit = IO_floatValue(line,positions,2)
moved all routines from postprocessingMath to math.90, renamed the module to DAMASK, changed scripts and interfaces accordingly. polished math.f90 (mainly added _pInt/_pReal and intent(in/out)) curl_fft is still a dummy function
2011-12-01 17:31:13 +05:30
case ('fftw_planner_string')
fftw_planner_string = IO_stringValue(line,positions,2)
some small improvements regarding the rotation of the loadcase frame
2011-10-25 19:08:24 +05:30
case ('rotation_tol')
rotation_tol = IO_floatValue(line,positions,2)
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
case ('divergence_correction')
divergence_correction = IO_intValue(line,positions,2) > 0_pInt
indroduced 3 more flags for fine control of spectral algorithm
2012-01-25 14:26:46 +05:30
case ('update_gamma')
update_gamma = IO_intValue(line,positions,2) > 0_pInt
case ('simplified_algorithm')
simplified_algorithm = IO_intValue(line,positions,2) > 0_pInt
case ('cut_off_value')
cut_off_value = IO_floatValue(line,positions,2)
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
removed hard-coded tolerances from mpie_spectral and put them to numerics/IO removed storage of full cauchy stres field from mpie_spectral.f90, only average is stored now added cauchy stress and von mises equivalent calculation to spectral post.
2011-01-31 22:37:42 +05:30
!* Random seeding parameters
mpie_cpfem_marc.f90 >>> changing the compilation sequence of modules: numerics.f90 and IO.f90 move up, while math.f90 down. IO.f90 >>> adding "inRad" instead of using inRad from math.f90 module, since math.f90 module is now below IO.f90. numerics.f90 >>> now can read the parameter "fixed_seed" from numerics.config. this parameter is used to set a pseudo-random number generator/fixed seeding. default value is 0 (zero), which will give fully random number. math.f90 >> adding a possibility to fix the seeding (i.e., pseudo random number) numerics.config >>> add a new parameter: "fixed_seed"
2009-08-27 21:00:40 +05:30
case ('fixed_seed')
correctet random seed generation to work with gfortran.
2011-11-04 15:59:35 +05:30
fixedSeed = IO_intValue(line,positions,2)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
endselect
enddo
100 close(fileunit)
! no config file, so we use standard values
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
!$OMP CRITICAL (write2out)
write(6,*) ' ... using standard values'
write(6,*)
!$OMP END CRITICAL (write2out)
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
endif
moved all routines from postprocessingMath to math.90, renamed the module to DAMASK, changed scripts and interfaces accordingly. polished math.f90 (mainly added _pInt/_pReal and intent(in/out)) curl_fft is still a dummy function
2011-12-01 17:31:13 +05:30
select case(IO_lc(fftw_planner_string)) ! setting parameters for the plan creation of FFTW. Basically a translation from fftw3.f
case('estimate','fftw_estimate') ! ordered from slow execution (but fast plan creation) to fast execution
fftw_planner_flag = 64
case('measure','fftw_measure')
fftw_planner_flag = 0
case('patient','fftw_patient')
fftw_planner_flag= 32
case('exhaustive','fftw_exhaustive')
fftw_planner_flag = 8
case default
call IO_warning(warning_ID=47_pInt,ext_msg=trim(IO_lc(fftw_planner_string)))
fftw_planner_flag = 32
end select
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
! writing parameters to output file
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)
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,e8.1)') ' relevantStrain: ',relevantStrain
write(6,'(a24,x,e8.1)') ' defgradTolerance: ',defgradTolerance
write(6,'(a24,x,i8)') ' iJacoStiffness: ',iJacoStiffness
write(6,'(a24,x,i8)') ' iJacoLpresiduum: ',iJacoLpresiduum
write(6,'(a24,x,e8.1)') ' pert_Fg: ',pert_Fg
write(6,'(a24,x,i8)') ' pert_method: ',pert_method
write(6,'(a24,x,i8)') ' nCryst: ',nCryst
write(6,'(a24,x,e8.1)') ' subStepMinCryst: ',subStepMinCryst
write(6,'(a24,x,e8.1)') ' subStepSizeCryst: ',subStepSizeCryst
write(6,'(a24,x,e8.1)') ' stepIncreaseCryst: ',stepIncreaseCryst
write(6,'(a24,x,i8)') ' nState: ',nState
write(6,'(a24,x,i8)') ' nStress: ',nStress
write(6,'(a24,x,e8.1)') ' rTol_crystalliteState: ',rTol_crystalliteState
write(6,'(a24,x,e8.1)') ' rTol_crystalliteTemp: ',rTol_crystalliteTemperature
write(6,'(a24,x,e8.1)') ' rTol_crystalliteStress: ',rTol_crystalliteStress
write(6,'(a24,x,e8.1)') ' aTol_crystalliteStress: ',aTol_crystalliteStress
write(6,'(a24,2(x,i8),/)')' integrator: ',numerics_integrator
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
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,i8)') ' nHomog: ',nHomog
write(6,'(a24,x,e8.1)') ' subStepMinHomog: ',subStepMinHomog
write(6,'(a24,x,e8.1)') ' subStepSizeHomog: ',subStepSizeHomog
write(6,'(a24,x,e8.1)') ' stepIncreaseHomog: ',stepIncreaseHomog
write(6,'(a24,x,i8,/)') ' nMPstate: ',nMPstate
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
!* RGC parameters
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,e8.1)') ' aTol_RGC: ',absTol_RGC
write(6,'(a24,x,e8.1)') ' rTol_RGC: ',relTol_RGC
write(6,'(a24,x,e8.1)') ' aMax_RGC: ',absMax_RGC
write(6,'(a24,x,e8.1)') ' rMax_RGC: ',relMax_RGC
write(6,'(a24,x,e8.1)') ' perturbPenalty_RGC: ',pPert_RGC
write(6,'(a24,x,e8.1)') ' relevantMismatch_RGC: ',xSmoo_RGC
write(6,'(a24,x,e8.1)') ' viscosityrate_RGC: ',viscPower_RGC
write(6,'(a24,x,e8.1)') ' viscositymodulus_RGC: ',viscModus_RGC
write(6,'(a24,x,e8.1)') ' maxrelaxation_RGC: ',maxdRelax_RGC
write(6,'(a24,x,e8.1)') ' maxVolDiscrepancy_RGC: ',maxVolDiscr_RGC
write(6,'(a24,x,e8.1)') ' volDiscrepancyMod_RGC: ',volDiscrMod_RGC
write(6,'(a24,x,e8.1,/)') ' discrepancyPower_RGC: ',volDiscrPow_RGC
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
!* spectral parameters
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,e8.1)') ' err_div_tol: ',err_div_tol
write(6,'(a24,x,e8.1)') ' err_stress_tolrel: ',err_stress_tolrel
write(6,'(a24,x,i8)') ' itmax: ',itmax
write(6,'(a24,x,L8)') ' memory_efficient: ',memory_efficient
indroduced 3 more flags for fine control of spectral algorithm
2012-01-25 14:26:46 +05:30
if(fftw_timelimit<0.0_pReal) then
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,L8)') ' fftw_timelimit: ',.false.
added two parameters to control behavior of FFTW, timelimit is not working at the moment remove fftw3.f as it is not needed anymore !incremental update, wait for commit of damask_spectral.f90 before checking out
2011-10-18 14:46:18 +05:30
else
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,e8.1)') ' fftw_timelimit: ',fftw_timelimit
added two parameters to control behavior of FFTW, timelimit is not working at the moment remove fftw3.f as it is not needed anymore !incremental update, wait for commit of damask_spectral.f90 before checking out
2011-10-18 14:46:18 +05:30
endif
moved all routines from postprocessingMath to math.90, renamed the module to DAMASK, changed scripts and interfaces accordingly. polished math.f90 (mainly added _pInt/_pReal and intent(in/out)) curl_fft is still a dummy function
2011-12-01 17:31:13 +05:30
write(6,'(a24,x,a)') ' fftw_planner_string: ',trim(fftw_planner_string)
write(6,'(a24,x,i8)') ' fftw_planner_flag: ',fftw_planner_flag
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,e8.1)') ' rotation_tol: ',rotation_tol
write(6,'(a24,x,L8,/)') ' divergence_correction: ',divergence_correction
indroduced 3 more flags for fine control of spectral algorithm
2012-01-25 14:26:46 +05:30
write(6,'(a24,x,L8,/)') ' update_gamma: ',update_gamma
write(6,'(a24,x,L8,/)') ' simplified_algorithm: ',simplified_algorithm
write(6,'(a24,x,e8.1)') ' cut_off_value: ',cut_off_value
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
!* Random seeding parameters
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
write(6,'(a24,x,i16,/)') ' fixed_seed: ',fixedSeed
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)
some polishing concerning openMP initialization number of threads is now written to *.out file
2010-12-02 16:34:29 +05:30
!* openMP parameter
restructured algorithm: moved into loop to reallocate fields and replan FFTW in case resolution changes during runtime ==> regridding introduced parameters for selective debugging of spectral code and partly introduced the advanced divergence calculation again which is controlled by debug.config added switch in numerics to control divergence behavior (uncorrected and corrected by phenomenological factor) added precision directive to all values I found
2011-11-15 23:24:18 +05:30
!$ write(6,'(a24,x,i8,/)') ' number of threads: ',DAMASK_NumThreadsInt
numerics.config is now optional; if this file does not exist in the working directory, standard values from numerics.f90 are used; either way the output file tells which values were taken. added some output to the init subroutines of debug.f90, FEsolving.f90, lattice.f90, material.f90 and mesh.f90.
2009-06-18 19:58:02 +05:30
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
! sanity check
if (relevantStrain <= 0.0_pReal) call IO_error(260)
new numerics parameter "defgradTolerance" replaces "relevantStrain" in cpfem, since "relevantStrain" is also used in crystallite but in a different context. "defgradTolerance" gets the same standard value as "relevantStrain" so calculations should be consistent with older ones
2010-05-20 20:25:11 +05:30
if (defgradTolerance <= 0.0_pReal) call IO_error(294)
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (iJacoStiffness < 1_pInt) call IO_error(261)
if (iJacoLpresiduum < 1_pInt) call IO_error(262)
if (pert_Fg <= 0.0_pReal) call IO_error(263)
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
if (pert_method <= 0_pInt .or. pert_method >= 4_pInt) &
call IO_error(299)
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (nHomog < 1_pInt) call IO_error(264)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
if (nMPstate < 1_pInt) call IO_error(279) !! missing in IO !!
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (nCryst < 1_pInt) call IO_error(265)
if (nState < 1_pInt) call IO_error(266)
if (nStress < 1_pInt) call IO_error(267)
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
if (subStepMinCryst <= 0.0_pReal) call IO_error(268)
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
if (subStepSizeCryst <= 0.0_pReal) call IO_error(268)
if (stepIncreaseCryst <= 0.0_pReal) call IO_error(268)
minimum substepping size in homogenization and crystallite is now controlled by two independent parameters subStepMinHomog and subStepMinCryst respectively. deleted flush statements where they are not needed, since they seriously slow down computation.
2009-10-26 22:13:43 +05:30
if (subStepMinHomog <= 0.0_pReal) call IO_error(268)
introduced a flexibility in cut-backing scheme in homogenization.f90 and in crystallite.f90: (1) subStepSizeHomog and subStepSizeCryst := size of substep when cut-back is applied (initially was hard-coded). (2) stepIncreaseHomog and stepIncreaseCryst := step increase when calculation for substep converge (was also hardcoded). introduced a possibility to choose different finite difference scheme, i.e., forward-, backward- and central-difference, for computing grain numerical tangent. note that central-difference scheme will slow down the computation significantly. please use it only if necessary. parameters to set these new features have been included in numerics.f90 and numerics.config, whereas corresponding error messages have been introduced in the IO.f90
2009-11-10 19:06:27 +05:30
if (subStepSizeHomog <= 0.0_pReal) call IO_error(268)
if (stepIncreaseHomog <= 0.0_pReal) call IO_error(268)
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (rTol_crystalliteState <= 0.0_pReal) call IO_error(269)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
if (rTol_crystalliteTemperature <= 0.0_pReal) call IO_error(276) !! oops !!
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (rTol_crystalliteStress <= 0.0_pReal) call IO_error(270)
if (aTol_crystalliteStress <= 0.0_pReal) call IO_error(271)
sorry, forgot to commit the numerics.f90, too
2011-02-23 18:00:52 +05:30
if (any(numerics_integrator <= 0_pInt) .or. any(numerics_integrator >= 6_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
call IO_error(298)
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
!* RGC parameters: added <<<updated 17.11.2009>>>
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (absTol_RGC <= 0.0_pReal) call IO_error(272)
if (relTol_RGC <= 0.0_pReal) call IO_error(273)
if (absMax_RGC <= 0.0_pReal) call IO_error(274)
if (relMax_RGC <= 0.0_pReal) call IO_error(275)
now with first draft of nonlocal constitutive law debugging memory leak closed debugging counters corrected center of gravity stored in mesh state updated is now split into a collecting loop and an execution updateState and updateTemperature fill sequentially separate logicals and evaluate afterwards to converged added 3x3 transposition function, norm for 3x1 matrix and 33x3 matrix multiplication in math non-converged crystallite triggers materialpoint cutback (used to respond elastically) non-converged materialpoint raises terminal illness which in turn renders whole FE increment useless by means of odd stress/stiffness and thus waits for FE cutback
2009-08-11 22:01:57 +05:30
if (pPert_RGC <= 0.0_pReal) call IO_error(276) !! oops !!
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
if (xSmoo_RGC <= 0.0_pReal) call IO_error(277)
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
if (viscPower_RGC < 0.0_pReal) call IO_error(278)
introduction of a possibility to have homogeneous element (all ips in one element are identical, sort of reduced integration) and bugs-fixing in crystallite.f90, homogenization_RGC.f90, numerics.f90.
2009-11-24 20:30:25 +05:30
if (viscModus_RGC < 0.0_pReal) call IO_error(278)
the latest RGC model + corrections for "element homogeneous" feature
2010-03-24 18:50:12 +05:30
if (refRelaxRate_RGC <= 0.0_pReal) call IO_error(278)
Introduction of a numerical viscosity into the RGC scheme to improve the convergent behavior and the numerical stability of the scheme (see: homogenization_RGC.f90). These changes have been incorporated in all related subroutines (homogenization.f90, IO.f90, numerics.config and numerics.f90).
2009-11-17 19:12:38 +05:30
if (maxdRelax_RGC <= 0.0_pReal) call IO_error(288)
Additional feature to the RGC scheme: The volumetric consistency constraint. This is implemented by penalizing any volumetric discrepancy which occurs due to severe relaxation. The penalty for volume inconsistency is described using a power-law model. The setting for this function can be done in the numerics.config via three new parameters, i.e., maxvoldiscrepancy_RGC, voldiscrepancymod_RGC and discrepancypower_RGC. For monintoring, an extra output variable in prescribed in the material.config in the RGC section, namely "(output) volumediscrepancy". IO.f90 and numerics.f90 has been modified accordingly to accommodate these changes
2009-12-16 21:50:53 +05:30
if (maxVolDiscr_RGC <= 0.0_pReal) call IO_error(289)
if (volDiscrMod_RGC < 0.0_pReal) call IO_error(289)
if (volDiscrPow_RGC <= 0.0_pReal) call IO_error(289)
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
!* spectral parameters
extended IO to cope with different name for solverJob and Model polishing, added error codes added FFTW library files
2011-02-21 20:07:38 +05:30
if (err_div_tol <= 0.0_pReal) call IO_error(49)
if (err_stress_tolrel <= 0.0_pReal) call IO_error(49)
if (itmax <= 1.0_pInt) call IO_error(49)
added matrix multiplication 3333x33 to math.f90 added some parameters for spectral method to numerics.f90 (tolerance) changed error message concerning spectral method in IO.f90 corrected calculation of stress BC in mpie_spectral.f90
2010-10-13 21:34:44 +05:30
openmp parallelization working again (at least for j2 and nonlocal constitutive model). In order to keep it like that, please follow these simple rules: DON'T use implicit array subscripts: example: real, dimension(3,3) :: A,B A(:,2) = B(:,1) <--- DON'T USE A(1:3,2) = B(1:3,1) <--- BETTER USE In many cases the use of explicit array subscripts is inevitable for parallelization. Additionally, it is an easy means to prevent memory leaks. Enclose all write statements with the following: !$OMP CRITICAL (write2out) <your write statement> !$OMP END CRITICAL (write2out) Whenever you change something in the code and are not sure if it affects parallelization and leads to nonconforming behavior, please ask me and/or Franz to check this.
2011-03-17 16:16:17 +05:30
if (fixedSeed <= 0_pInt) then
!$OMP CRITICAL (write2out)
write(6,'(a)') 'Random is random!'
!$OMP END CRITICAL (write2out)
endif
added a new module called numerics.f90 which reads in all numerical "parameters" from the file numerics.config (also being added). From now on this file has to be located in the working directory of the FEM-model and has to contain all necessary parameters.
2009-06-15 18:41:21 +05:30
endsubroutine
List of changes/modifications: * IO.f90 :: Adding error messages for RGC homogenization * crystallite.f90 :: Modifying convergent criteria in crystalline_updateState and crystalline_updateTemperature * material.f90 :: Adding IO_lc in homogenization_type(Name) * debug.f90 :: Adding debbugging statement and counter for material point loop * homogenization.f90 :: Adding homogenization_RGC blocks * homogenization_isostrain.f90 :: Modifying argument of homogenization_isostrain_stateInit * mpie_cpfem_marc.f90 :: Adding homogenization_RGC include * numerics.f90 :: Adding numerical parameters for RGC scheme * math.f90 :: Changing function name: math_permut to math_civita
2009-07-31 17:32:20 +05:30
END MODULE numerics