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

behavior of IO_stringPos was unsafe in some situations, also took the chance to rename the variables used in its context to a more meaningful name. 

functions in the core module are not used, including kdTree
This commit is contained in:
Martin Diehl 2015-08-28 07:38:48 +00:00
parent b4768013a0
commit 6848d83d13
47 changed files with 1361 additions and 4107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
code/DAMASK_run.py
View File

@ -1,80 +0,0 @@
#!/usr/bin/env python
# -*- coding: UTF-8 no BOM -*-
import numpy,os,damask,string,sys,subprocess,re
from optparse import OptionParser, Option
# -----------------------------
class extendableOption(Option):
# -----------------------------
# used for definition of new option parser action 'extend', which enables to take multiple option arguments
# taken from online tutorial http://docs.python.org/library/optparse.html
ACTIONS = Option.ACTIONS + ("extend",)
STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
def take_action(self, action, dest, opt, value, values, parser):
if action == "extend":
lvalue = value.split(",")
values.ensure_value(dest, []).extend(lvalue)
else:
Option.take_action(self, action, dest, opt, value, values, parser)
# --------------------------------------------------------------------
# MAIN
# --------------------------------------------------------------------
parser = OptionParser(option_class=extendableOption, usage='%prog options [file[s]]', description = """
Add column(s) with derived values according to user defined arithmetic operation between column(s).
Columns can be specified either by label or index.
Example: distance to IP coordinates -- "math.sqrt( #ip.x#**2 + #ip.y#**2 + #ip.z#**2 )"
""" + string.replace('$Id$','\n','\\n')
)
parser.add_option('-l','--load', '--loadcase', dest='loadcase', type='string', \
help='PathToLoadFile/NameOfLoadFile.load. "PathToLoadFile" will be the working directory.')
parser.add_option('-g','--geom', '--geometry', dest='geometry', type='string', \
help='PathToGeomFile/NameOfGeomFile.load.')
parser.set_defaults(loadcase= '')
parser.set_defaults(geometry= '')
(options,filenames) = parser.parse_args()
start = 1
exitCode=2
print 'load case', options.loadcase
print 'geometry', options.geometry
res=numpy.array([32,32,32])
while exitCode == 2:
print 'restart at ', start
proc=subprocess.Popen(executable='DAMASK_spectral',\
args=['-l', '%s'%options.loadcase, '-g', '%s'%options.geometry, '--regrid', '%i'%start],\
stderr=subprocess.PIPE,stdout=subprocess.PIPE, bufsize=1)
while proc.poll() is None: # while process is running
myLine = proc.stdout.readline()
if len(myLine)>1: print myLine[0:-1] # print output without extra newline
exitCode = proc.returncode
err = proc.stderr.readlines()
print '-------------------------------------------------------'
print 'error messages', err
print '-------------------------------------------------------'
if exitCode==2:
os.system('rm -rf %i'%start)
os.system('mkdir %i'%start)
os.system('cp * %i/.'%start)
for i in xrange(len(err)):
if re.search('restart at\s+\d+',err[i]): start=int(string.split(err[i])[2])
#------------regridding----------------------------------------------
#--------------------------------------------------------------------
damask.core.prec.init()
damask.core.DAMASK_interface.init(options.loadcase,options.geometry)
damask.core.IO.init()
damask.core.numerics.init()
damask.core.debug.init()
damask.core.math.init()
damask.core.FEsolving.init()
damask.core.mesh.init(1,1)
damask.core.mesh.regrid(adaptive=True,resNewInput=res)

51
code/DAMASK_spectral_driver.f90
View File

@ -91,11 +91,8 @@ program DAMASK_spectral_Driver
! variables related to information from load case and geom file ! variables related to information from load case and geom file
real(pReal), dimension(9) :: temp_valueVector = 0.0_pReal !< temporarily from loadcase file when reading in tensors (initialize to 0.0) real(pReal), dimension(9) :: temp_valueVector = 0.0_pReal !< temporarily from loadcase file when reading in tensors (initialize to 0.0)
logical, dimension(9) :: temp_maskVector = .false. !< temporarily from loadcase file when reading in tensors logical, dimension(9) :: temp_maskVector = .false. !< temporarily from loadcase file when reading in tensors
integer(pInt), parameter :: MAXNCHUNKS = (1_pInt + 9_pInt)*3_pInt + & ! deformation, rotation, and stress integer(pInt), parameter :: FILEUNIT = 234_pInt !< file unit, DAMASK IO does not support newunit feature
(1_pInt + 1_pInt)*5_pInt + & ! time, (log)incs, temp, restartfrequency, and outputfrequency integer(pInt), allocatable, dimension(:) :: chunkPos
1_pInt, & ! dropguessing
FILEUNIT = 234_pInt !< file unit, DAMASK IO does not support newunit feature
integer(pInt), dimension(1_pInt + MAXNCHUNKS*2_pInt) :: positions ! this is longer than needed for geometry parsing
integer(pInt) :: & integer(pInt) :: &
N_t = 0_pInt, & !< # of time indicators found in load case file N_t = 0_pInt, & !< # of time indicators found in load case file
@ -178,9 +175,9 @@ program DAMASK_spectral_Driver
line = IO_read(FILEUNIT) line = IO_read(FILEUNIT)
if (trim(line) == IO_EOF) exit if (trim(line) == IO_EOF) exit
if (IO_isBlank(line)) cycle ! skip empty lines if (IO_isBlank(line)) cycle ! skip empty lines
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
do i = 1_pInt, positions(1) ! reading compulsory parameters for loadcase do i = 1_pInt, chunkPos(1) ! reading compulsory parameters for loadcase
select case (IO_lc(IO_stringValue(line,positions,i))) select case (IO_lc(IO_stringValue(line,chunkPos,i)))
case('l','velocitygrad','velgrad','velocitygradient','fdot','dotf','f') case('l','velocitygrad','velgrad','velocitygradient','fdot','dotf','f')
N_def = N_def + 1_pInt N_def = N_def + 1_pInt
case('t','time','delta') case('t','time','delta')
@ -188,7 +185,7 @@ program DAMASK_spectral_Driver
case('n','incs','increments','steps','logincs','logincrements','logsteps') case('n','incs','increments','steps','logincs','logincrements','logsteps')
N_n = N_n + 1_pInt N_n = N_n + 1_pInt
end select end select
enddo ! count all identifiers to allocate memory and do sanity check enddo ! count all identifiers to allocate memory and do sanity check
enddo enddo
if ((N_def /= N_n) .or. (N_n /= N_t)) & ! sanity check if ((N_def /= N_n) .or. (N_n /= N_t)) & ! sanity check
@ -218,24 +215,24 @@ program DAMASK_spectral_Driver
if (trim(line) == IO_EOF) exit if (trim(line) == IO_EOF) exit
if (IO_isBlank(line)) cycle ! skip empty lines if (IO_isBlank(line)) cycle ! skip empty lines
currentLoadCase = currentLoadCase + 1_pInt currentLoadCase = currentLoadCase + 1_pInt
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
do i = 1_pInt, positions(1) do i = 1_pInt, chunkPos(1)
select case (IO_lc(IO_stringValue(line,positions,i))) select case (IO_lc(IO_stringValue(line,chunkPos,i)))
case('fdot','dotf','l','velocitygrad','velgrad','velocitygradient','f') ! assign values for the deformation BC matrix case('fdot','dotf','l','velocitygrad','velgrad','velocitygradient','f') ! assign values for the deformation BC matrix
temp_valueVector = 0.0_pReal temp_valueVector = 0.0_pReal
if (IO_lc(IO_stringValue(line,positions,i)) == 'fdot'.or. & ! in case of Fdot, set type to fdot if (IO_lc(IO_stringValue(line,chunkPos,i)) == 'fdot'.or. & ! in case of Fdot, set type to fdot
IO_lc(IO_stringValue(line,positions,i)) == 'dotf') then IO_lc(IO_stringValue(line,chunkPos,i)) == 'dotf') then
loadCases(currentLoadCase)%deformation%myType = 'fdot' loadCases(currentLoadCase)%deformation%myType = 'fdot'
else if (IO_lc(IO_stringValue(line,positions,i)) == 'f') then else if (IO_lc(IO_stringValue(line,chunkPos,i)) == 'f') then
loadCases(currentLoadCase)%deformation%myType = 'f' loadCases(currentLoadCase)%deformation%myType = 'f'
else else
loadCases(currentLoadCase)%deformation%myType = 'l' loadCases(currentLoadCase)%deformation%myType = 'l'
endif endif
do j = 1_pInt, 9_pInt do j = 1_pInt, 9_pInt
temp_maskVector(j) = IO_stringValue(line,positions,i+j) /= '*' ! true if not a * temp_maskVector(j) = IO_stringValue(line,chunkPos,i+j) /= '*' ! true if not a *
enddo enddo
do j = 1_pInt,9_pInt do j = 1_pInt,9_pInt
if (temp_maskVector(j)) temp_valueVector(j) = IO_floatValue(line,positions,i+j) ! read value where applicable if (temp_maskVector(j)) temp_valueVector(j) = IO_floatValue(line,chunkPos,i+j) ! read value where applicable
enddo enddo
loadCases(currentLoadCase)%deformation%maskLogical = & ! logical mask in 3x3 notation loadCases(currentLoadCase)%deformation%maskLogical = & ! logical mask in 3x3 notation
transpose(reshape(temp_maskVector,[ 3,3])) transpose(reshape(temp_maskVector,[ 3,3]))
@ -245,34 +242,34 @@ program DAMASK_spectral_Driver
case('p','pk1','piolakirchhoff','stress', 's') case('p','pk1','piolakirchhoff','stress', 's')
temp_valueVector = 0.0_pReal temp_valueVector = 0.0_pReal
do j = 1_pInt, 9_pInt do j = 1_pInt, 9_pInt
temp_maskVector(j) = IO_stringValue(line,positions,i+j) /= '*' ! true if not an asterisk temp_maskVector(j) = IO_stringValue(line,chunkPos,i+j) /= '*' ! true if not an asterisk
enddo enddo
do j = 1_pInt,9_pInt do j = 1_pInt,9_pInt
if (temp_maskVector(j)) temp_valueVector(j) = IO_floatValue(line,positions,i+j) ! read value where applicable if (temp_maskVector(j)) temp_valueVector(j) = IO_floatValue(line,chunkPos,i+j) ! read value where applicable
enddo enddo
loadCases(currentLoadCase)%P%maskLogical = transpose(reshape(temp_maskVector,[ 3,3])) loadCases(currentLoadCase)%P%maskLogical = transpose(reshape(temp_maskVector,[ 3,3]))
loadCases(currentLoadCase)%P%maskFloat = merge(ones,zeros,& loadCases(currentLoadCase)%P%maskFloat = merge(ones,zeros,&
loadCases(currentLoadCase)%P%maskLogical) loadCases(currentLoadCase)%P%maskLogical)
loadCases(currentLoadCase)%P%values = math_plain9to33(temp_valueVector) loadCases(currentLoadCase)%P%values = math_plain9to33(temp_valueVector)
case('t','time','delta') ! increment time case('t','time','delta') ! increment time
loadCases(currentLoadCase)%time = IO_floatValue(line,positions,i+1_pInt) loadCases(currentLoadCase)%time = IO_floatValue(line,chunkPos,i+1_pInt)
case('n','incs','increments','steps') ! number of increments case('n','incs','increments','steps') ! number of increments
loadCases(currentLoadCase)%incs = IO_intValue(line,positions,i+1_pInt) loadCases(currentLoadCase)%incs = IO_intValue(line,chunkPos,i+1_pInt)
case('logincs','logincrements','logsteps') ! number of increments (switch to log time scaling) case('logincs','logincrements','logsteps') ! number of increments (switch to log time scaling)
loadCases(currentLoadCase)%incs = IO_intValue(line,positions,i+1_pInt) loadCases(currentLoadCase)%incs = IO_intValue(line,chunkPos,i+1_pInt)
loadCases(currentLoadCase)%logscale = 1_pInt loadCases(currentLoadCase)%logscale = 1_pInt
case('freq','frequency','outputfreq') ! frequency of result writings case('freq','frequency','outputfreq') ! frequency of result writings
loadCases(currentLoadCase)%outputfrequency = IO_intValue(line,positions,i+1_pInt) loadCases(currentLoadCase)%outputfrequency = IO_intValue(line,chunkPos,i+1_pInt)
case('r','restart','restartwrite') ! frequency of writing restart information case('r','restart','restartwrite') ! frequency of writing restart information
loadCases(currentLoadCase)%restartfrequency = & loadCases(currentLoadCase)%restartfrequency = &
max(0_pInt,IO_intValue(line,positions,i+1_pInt)) max(0_pInt,IO_intValue(line,chunkPos,i+1_pInt))
case('guessreset','dropguessing') case('guessreset','dropguessing')
loadCases(currentLoadCase)%followFormerTrajectory = .false. ! do not continue to predict deformation along former trajectory loadCases(currentLoadCase)%followFormerTrajectory = .false. ! do not continue to predict deformation along former trajectory
case('euler') ! rotation of currentLoadCase given in euler angles case('euler') ! rotation of currentLoadCase given in euler angles
temp_valueVector = 0.0_pReal temp_valueVector = 0.0_pReal
l = 1_pInt ! assuming values given in degrees l = 1_pInt ! assuming values given in degrees
k = 1_pInt ! assuming keyword indicating degree/radians present k = 1_pInt ! assuming keyword indicating degree/radians present
select case (IO_lc(IO_stringValue(line,positions,i+1_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,i+1_pInt)))
case('deg','degree') case('deg','degree')
case('rad','radian') ! don't convert from degree to radian case('rad','radian') ! don't convert from degree to radian
l = 0_pInt l = 0_pInt
@ -280,14 +277,14 @@ program DAMASK_spectral_Driver
k = 0_pInt k = 0_pInt
end select end select
do j = 1_pInt, 3_pInt do j = 1_pInt, 3_pInt
temp_valueVector(j) = IO_floatValue(line,positions,i+k+j) temp_valueVector(j) = IO_floatValue(line,chunkPos,i+k+j)
enddo enddo
if (l == 1_pInt) temp_valueVector(1:3) = temp_valueVector(1:3) * inRad ! convert to rad if (l == 1_pInt) temp_valueVector(1:3) = temp_valueVector(1:3) * inRad ! convert to rad
loadCases(currentLoadCase)%rotation = math_EulerToR(temp_valueVector(1:3)) ! convert rad Eulers to rotation matrix loadCases(currentLoadCase)%rotation = math_EulerToR(temp_valueVector(1:3)) ! convert rad Eulers to rotation matrix
case('rotation','rot') ! assign values for the rotation of currentLoadCase matrix case('rotation','rot') ! assign values for the rotation of currentLoadCase matrix
temp_valueVector = 0.0_pReal temp_valueVector = 0.0_pReal
do j = 1_pInt, 9_pInt do j = 1_pInt, 9_pInt
temp_valueVector(j) = IO_floatValue(line,positions,i+j) temp_valueVector(j) = IO_floatValue(line,chunkPos,i+j)
enddo enddo
loadCases(currentLoadCase)%rotation = math_plain9to33(temp_valueVector) loadCases(currentLoadCase)%rotation = math_plain9to33(temp_valueVector)
end select end select

97
code/DAMASK_spectral_interface.f90
View File

@ -66,10 +66,8 @@ subroutine DAMASK_interface_init(loadCaseParameterIn,geometryParameterIn)
integer :: & integer :: &
i, & i, &
worldrank = 0 worldrank = 0
integer, parameter :: & integer, allocatable, dimension(:) :: &
MAXNCHUNKS = 128 !< DAMASK_spectral + (l,g,w,r)*2 + h chunkPos
integer, dimension(1+ 2* MAXNCHUNKS) :: &
positions
integer, dimension(8) :: & integer, dimension(8) :: &
dateAndTime ! type default integer dateAndTime ! type default integer
#ifdef PETSc #ifdef PETSc
@ -102,9 +100,9 @@ subroutine DAMASK_interface_init(loadCaseParameterIn,geometryParameterIn)
commandLine = 'n/a' commandLine = 'n/a'
else if ( .not.( present(loadcaseParameterIn) .and. present(geometryParameterIn))) then ! none parameters given in function call, trying to get them from command line else if ( .not.( present(loadcaseParameterIn) .and. present(geometryParameterIn))) then ! none parameters given in function call, trying to get them from command line
call get_command(commandLine) call get_command(commandLine)
positions = IIO_stringPos(commandLine,MAXNCHUNKS) chunkPos = IIO_stringPos(commandLine)
do i = 1, positions(1) do i = 1, chunkPos(1)
tag = IIO_lc(IIO_stringValue(commandLine,positions,i)) ! extract key tag = IIO_lc(IIO_stringValue(commandLine,chunkPos,i)) ! extract key
select case(tag) select case(tag)
case ('-h','--help') case ('-h','--help')
mainProcess2: if (worldrank == 0) then mainProcess2: if (worldrank == 0) then
@ -164,16 +162,16 @@ subroutine DAMASK_interface_init(loadCaseParameterIn,geometryParameterIn)
call quit(0_pInt) ! normal Termination call quit(0_pInt) ! normal Termination
endif mainProcess2 endif mainProcess2
case ('-l', '--load', '--loadcase') case ('-l', '--load', '--loadcase')
loadcaseArg = IIO_stringValue(commandLine,positions,i+1_pInt) loadcaseArg = IIO_stringValue(commandLine,chunkPos,i+1_pInt)
case ('-g', '--geom', '--geometry') case ('-g', '--geom', '--geometry')
geometryArg = IIO_stringValue(commandLine,positions,i+1_pInt) geometryArg = IIO_stringValue(commandLine,chunkPos,i+1_pInt)
case ('-w', '-d', '--wd', '--directory', '--workingdir', '--workingdirectory') case ('-w', '-d', '--wd', '--directory', '--workingdir', '--workingdirectory')
workingDirArg = IIO_stringValue(commandLine,positions,i+1_pInt) workingDirArg = IIO_stringValue(commandLine,chunkPos,i+1_pInt)
case ('-r', '--rs', '--restart') case ('-r', '--rs', '--restart')
spectralRestartInc = IIO_IntValue(commandLine,positions,i+1_pInt) spectralRestartInc = IIO_IntValue(commandLine,chunkPos,i+1_pInt)
appendToOutFile = .true. appendToOutFile = .true.
case ('--rg', '--regrid') case ('--rg', '--regrid')
spectralRestartInc = IIO_IntValue(commandLine,positions,i+1_pInt) spectralRestartInc = IIO_IntValue(commandLine,chunkPos,i+1_pInt)
appendToOutFile = .false. appendToOutFile = .false.
end select end select
enddo enddo
@ -477,38 +475,40 @@ end function getPathSep
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief taken from IO, check IO_stringValue for documentation !> @brief taken from IO, check IO_stringValue for documentation
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure function IIO_stringValue(line,positions,myPos) pure function IIO_stringValue(string,chunkPos,myChunk)
implicit none implicit none
integer(pInt), intent(in) :: positions(*), & integer(pInt), dimension(:), intent(in) :: chunkPos !< positions of start and end of each tag/chunk in given string
myPos integer(pInt), intent(in) :: myChunk !< position number of desired chunk
character(len=1+positions(myPos*2+1)-positions(myPos*2)) :: IIO_stringValue character(len=1+chunkPos(myChunk*2+1)-chunkPos(myChunk*2)) :: IIO_stringValue
character(len=*), intent(in) :: line character(len=*), intent(in) :: string !< raw input with known start and end of each chunk
if (positions(1) < myPos) then
valuePresent: if (myChunk > chunkPos(1) .or. myChunk < 1_pInt) then
IIO_stringValue = '' IIO_stringValue = ''
else else valuePresent
IIO_stringValue = line(positions(myPos*2):positions(myPos*2+1)) IIO_stringValue = string(chunkPos(myChunk*2):chunkPos(myChunk*2+1))
endif endif valuePresent
end function IIO_stringValue end function IIO_stringValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief taken from IO, check IO_stringValue for documentation !> @brief taken from IO, check IO_intValue for documentation
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
integer(pInt) pure function IIO_intValue(line,positions,myPos) integer(pInt) pure function IIO_intValue(string,chunkPos,myChunk)
implicit none
character(len=*), intent(in) :: string !< raw input with known start and end of each chunk
integer(pInt), intent(in) :: myChunk !< position number of desired sub string
integer(pInt), dimension(:), intent(in) :: chunkPos !< positions of start and end of each tag/chunk in given string
implicit none
character(len=*), intent(in) :: line
integer(pInt), intent(in) :: positions(*), &
myPos
if (positions(1) < myPos) then valuePresent: if (myChunk > chunkPos(1) .or. myChunk < 1_pInt) then
IIO_intValue = 0_pInt IIO_intValue = 0_pInt
else else valuePresent
read(UNIT=line(positions(myPos*2):positions(myPos*2+1)),ERR=100,FMT=*) IIO_intValue read(UNIT=string(chunkPos(myChunk*2):chunkPos(myChunk*2+1)),ERR=100,FMT=*) IIO_intValue
endif endif valuePresent
return return
100 IIO_intValue = huge(1_pInt) 100 IIO_intValue = huge(1_pInt)
@ -518,20 +518,21 @@ end function IIO_intValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief taken from IO, check IO_lc for documentation !> @brief taken from IO, check IO_lc for documentation
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure function IIO_lc(line) pure function IIO_lc(string)
implicit none implicit none
character(26), parameter :: lower = 'abcdefghijklmnopqrstuvwxyz' character(len=*), intent(in) :: string !< string to convert
character(26), parameter :: upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' character(len=len(string)) :: IIO_lc
character(len=*), intent(in) :: line
character(len=len(line)) :: IIO_lc character(26), parameter :: LOWER = 'abcdefghijklmnopqrstuvwxyz'
character(26), parameter :: UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
integer :: i,n ! no pInt (len returns default integer) integer :: i,n ! no pInt (len returns default integer)
IIO_lc = line IIO_lc = string
do i=1,len(line) do i=1,len(string)
n = index(upper,IIO_lc(i:i)) n = index(UPPER,IIO_lc(i:i))
if (n/=0) IIO_lc(i:i) = lower(n:n) if (n/=0) IIO_lc(i:i) = LOWER(n:n)
enddo enddo
end function IIO_lc end function IIO_lc
@ -540,29 +541,23 @@ end function IIO_lc
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief taken from IO, check IO_stringPos for documentation !> @brief taken from IO, check IO_stringPos for documentation
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure function IIO_stringPos(string,N) pure function IIO_stringPos(string)
implicit none implicit none
integer(pInt), intent(in) :: N !< maximum number of parts integer(pInt), dimension(:), allocatable :: IIO_stringPos
integer(pInt), dimension(1_pInt+N*2_pInt) :: IIO_stringPos character(len=*), intent(in) :: string !< string in which chunks are searched for
character(len=*), intent(in) :: string !< string in which parts are searched for
character(len=*), parameter :: SEP=achar(44)//achar(32)//achar(9)//achar(10)//achar(13) ! comma and whitespaces character(len=*), parameter :: SEP=achar(44)//achar(32)//achar(9)//achar(10)//achar(13) ! comma and whitespaces
integer :: left, right ! no pInt (verify and scan return default integer) integer :: left, right ! no pInt (verify and scan return default integer)
allocate(IIO_stringPos(1), source=0_pInt)
IIO_stringPos = -1_pInt
IIO_stringPos(1) = 0_pInt
right = 0 right = 0
do while (verify(string(right+1:),SEP)>0) do while (verify(string(right+1:),SEP)>0)
left = right + verify(string(right+1:),SEP) left = right + verify(string(right+1:),SEP)
right = left + scan(string(left:),SEP) - 2 right = left + scan(string(left:),SEP) - 2
if ( string(left:left) == '#' ) exit if ( string(left:left) == '#' ) exit
if ( IIO_stringPos(1)<N ) then IIO_stringPos = [IIO_stringPos,int(left, pInt), int(right, pInt)]
IIO_stringPos(1_pInt+IIO_stringPos(1)*2_pInt+1_pInt) = int(left, pInt)
IIO_stringPos(1_pInt+IIO_stringPos(1)*2_pInt+2_pInt) = int(right, pInt)
endif
IIO_stringPos(1) = IIO_stringPos(1)+1_pInt IIO_stringPos(1) = IIO_stringPos(1)+1_pInt
enddo enddo

52
code/FEsolving.f90
View File

@ -79,12 +79,10 @@ subroutine FE_init
implicit none implicit none
#if defined(Marc4DAMASK) || defined(Abaqus) #if defined(Marc4DAMASK) || defined(Abaqus)
integer(pInt), parameter :: & integer(pInt), parameter :: &
FILEUNIT = 222_pInt, & FILEUNIT = 222_pInt
MAXNCHUNKS = 6_pInt
integer(pInt) :: j integer(pInt) :: j
character(len=64) :: tag character(len=65536) :: tag, line
character(len=1024) :: line integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions
#endif #endif
mainProcess: if (worldrank == 0) then mainProcess: if (worldrank == 0) then
@ -114,26 +112,26 @@ subroutine FE_init
rewind(FILEUNIT) rewind(FILEUNIT)
do do
read (FILEUNIT,'(a1024)',END=100) line read (FILEUNIT,'(a1024)',END=100) line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('solver') case ('solver')
read (FILEUNIT,'(a1024)',END=100) line ! next line read (FILEUNIT,'(a1024)',END=100) line ! next line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
symmetricSolver = (IO_intValue(line,positions,2_pInt) /= 1_pInt) symmetricSolver = (IO_intValue(line,chunkPos,2_pInt) /= 1_pInt)
case ('restart') case ('restart')
read (FILEUNIT,'(a1024)',END=100) line ! next line read (FILEUNIT,'(a1024)',END=100) line ! next line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
restartWrite = iand(IO_intValue(line,positions,1_pInt),1_pInt) > 0_pInt restartWrite = iand(IO_intValue(line,chunkPos,1_pInt),1_pInt) > 0_pInt
restartRead = iand(IO_intValue(line,positions,1_pInt),2_pInt) > 0_pInt restartRead = iand(IO_intValue(line,chunkPos,1_pInt),2_pInt) > 0_pInt
case ('*restart') case ('*restart')
do j=2_pInt,positions(1) do j=2_pInt,chunkPos(1)
restartWrite = (IO_lc(IO_StringValue(line,positions,j)) == 'write') .or. restartWrite restartWrite = (IO_lc(IO_StringValue(line,chunkPos,j)) == 'write') .or. restartWrite
restartRead = (IO_lc(IO_StringValue(line,positions,j)) == 'read') .or. restartRead restartRead = (IO_lc(IO_StringValue(line,chunkPos,j)) == 'read') .or. restartRead
enddo enddo
if(restartWrite) then if(restartWrite) then
do j=2_pInt,positions(1) do j=2_pInt,chunkPos(1)
restartWrite = (IO_lc(IO_StringValue(line,positions,j)) /= 'frequency=0') .and. restartWrite restartWrite = (IO_lc(IO_StringValue(line,chunkPos,j)) /= 'frequency=0') .and. restartWrite
enddo enddo
endif endif
end select end select
@ -146,23 +144,23 @@ subroutine FE_init
rewind(FILEUNIT) rewind(FILEUNIT)
do do
read (FILEUNIT,'(a1024)',END=200) line read (FILEUNIT,'(a1024)',END=200) line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if ( IO_lc(IO_stringValue(line,positions,1_pInt)) == 'restart' .and. & if ( IO_lc(IO_stringValue(line,chunkPos,1_pInt)) == 'restart' .and. &
IO_lc(IO_stringValue(line,positions,2_pInt)) == 'file' .and. & IO_lc(IO_stringValue(line,chunkPos,2_pInt)) == 'file' .and. &
IO_lc(IO_stringValue(line,positions,3_pInt)) == 'job' .and. & IO_lc(IO_stringValue(line,chunkPos,3_pInt)) == 'job' .and. &
IO_lc(IO_stringValue(line,positions,4_pInt)) == 'id' ) & IO_lc(IO_stringValue(line,chunkPos,4_pInt)) == 'id' ) &
modelName = IO_StringValue(line,positions,6_pInt) modelName = IO_StringValue(line,chunkPos,6_pInt)
enddo enddo
#else #else
call IO_open_inputFile(FILEUNIT,modelName) call IO_open_inputFile(FILEUNIT,modelName)
rewind(FILEUNIT) rewind(FILEUNIT)
do do
read (FILEUNIT,'(a1024)',END=200) line read (FILEUNIT,'(a1024)',END=200) line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if ( IO_lc(IO_stringValue(line,positions,1_pInt))=='*heading') then if ( IO_lc(IO_stringValue(line,chunkPos,1_pInt))=='*heading') then
read (FILEUNIT,'(a1024)',END=200) line read (FILEUNIT,'(a1024)',END=200) line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
modelName = IO_StringValue(line,positions,1_pInt) modelName = IO_StringValue(line,chunkPos,1_pInt)
endif endif
enddo enddo
#endif #endif

358
code/IO.f90
View File

@ -56,7 +56,6 @@ module IO
IO_spotTagInPart, & IO_spotTagInPart, &
IO_globalTagInPart, & IO_globalTagInPart, &
IO_stringPos, & IO_stringPos, &
IO_stringPos2, &
IO_stringValue, & IO_stringValue, &
IO_fixedStringValue ,& IO_fixedStringValue ,&
IO_floatValue, & IO_floatValue, &
@ -538,8 +537,7 @@ logical function IO_abaqus_hasNoPart(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: myPos
character(len=65536) :: line character(len=65536) :: line
IO_abaqus_hasNoPart = .true. IO_abaqus_hasNoPart = .true.
@ -548,8 +546,8 @@ logical function IO_abaqus_hasNoPart(fileUnit)
rewind(fileUnit) rewind(fileUnit)
do do
read(fileUnit,610,END=620) line read(fileUnit,610,END=620) line
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (IO_lc(IO_stringValue(line,myPos,1_pInt)) == '*part' ) then if (IO_lc(IO_stringValue(line,chunkPos,1_pInt)) == '*part' ) then
IO_abaqus_hasNoPart = .false. IO_abaqus_hasNoPart = .false.
exit exit
endif endif
@ -566,9 +564,9 @@ function IO_hybridIA(Nast,ODFfileName)
tol_math_check tol_math_check
implicit none implicit none
integer(pInt), intent(in) :: Nast !< number of samples? integer(pInt), intent(in) :: Nast !< number of samples?
real(pReal), dimension(3,Nast) :: IO_hybridIA real(pReal), dimension(3,Nast) :: IO_hybridIA
character(len=*), intent(in) :: ODFfileName !< name of ODF file including total path character(len=*), intent(in) :: ODFfileName !< name of ODF file including total path
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! math module is not available ! math module is not available
@ -576,10 +574,10 @@ function IO_hybridIA(Nast,ODFfileName)
real(pReal), parameter :: INRAD = PI/180.0_pReal real(pReal), parameter :: INRAD = PI/180.0_pReal
integer(pInt) :: i,j,bin,NnonZero,Nset,Nreps,reps,phi1,Phi,phi2 integer(pInt) :: i,j,bin,NnonZero,Nset,Nreps,reps,phi1,Phi,phi2
integer(pInt), dimension(1_pInt + 7_pInt*2_pInt) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(3) :: steps !< number of steps in phi1, Phi, and phi2 direction integer(pInt), dimension(3) :: steps !< number of steps in phi1, Phi, and phi2 direction
integer(pInt), dimension(4) :: columns !< columns in linearODF file where eulerangles and density are located integer(pInt), dimension(4) :: columns !< columns in linearODF file where eulerangles and density are located
integer(pInt), dimension(:), allocatable :: binSet integer(pInt), dimension(:), allocatable :: binSet
real(pReal) :: center,sum_dV_V,prob,dg_0,C,lowerC,upperC,rnd real(pReal) :: center,sum_dV_V,prob,dg_0,C,lowerC,upperC,rnd
real(pReal), dimension(2,3) :: limits !< starting and end values for eulerangles real(pReal), dimension(2,3) :: limits !< starting and end values for eulerangles
real(pReal), dimension(3) :: deltas, & !< angular step size in phi1, Phi, and phi2 direction real(pReal), dimension(3) :: deltas, & !< angular step size in phi1, Phi, and phi2 direction
@ -597,10 +595,10 @@ function IO_hybridIA(Nast,ODFfileName)
call IO_open_file(FILEUNIT,ODFfileName) call IO_open_file(FILEUNIT,ODFfileName)
headerLength = 0_pInt headerLength = 0_pInt
line=IO_read(FILEUNIT) line=IO_read(FILEUNIT)
positions = IO_stringPos(line,7_pInt) chunkPos = IO_stringPos(line)
keyword = IO_lc(IO_StringValue(line,positions,2_pInt,.true.)) keyword = IO_lc(IO_StringValue(line,chunkPos,2_pInt,.true.))
if (keyword(1:4) == 'head') then if (keyword(1:4) == 'head') then
headerLength = IO_intValue(line,positions,1_pInt) + 1_pInt headerLength = IO_intValue(line,chunkPos,1_pInt) + 1_pInt
else else
call IO_error(error_ID=156_pInt, ext_msg='no header found') call IO_error(error_ID=156_pInt, ext_msg='no header found')
endif endif
@ -611,9 +609,9 @@ function IO_hybridIA(Nast,ODFfileName)
line=IO_read(FILEUNIT) line=IO_read(FILEUNIT)
enddo enddo
columns = 0_pInt columns = 0_pInt
positions = IO_stringPos(line,7_pInt) chunkPos = IO_stringPos(line)
do i = 1_pInt, positions(1) do i = 1_pInt, chunkPos(1)
select case ( IO_lc(IO_StringValue(line,positions,i,.true.)) ) select case ( IO_lc(IO_StringValue(line,chunkPos,i,.true.)) )
case ('phi1') case ('phi1')
columns(1) = i columns(1) = i
case ('phi') case ('phi')
@ -635,10 +633,10 @@ function IO_hybridIA(Nast,ODFfileName)
line=IO_read(FILEUNIT) line=IO_read(FILEUNIT)
do while (trim(line) /= IO_EOF) do while (trim(line) /= IO_EOF)
positions = IO_stringPos(line,7_pInt) chunkPos = IO_stringPos(line)
eulers=[IO_floatValue(line,positions,columns(1)),& eulers=[IO_floatValue(line,chunkPos,columns(1)),&
IO_floatValue(line,positions,columns(2)),& IO_floatValue(line,chunkPos,columns(2)),&
IO_floatValue(line,positions,columns(3))] IO_floatValue(line,chunkPos,columns(3))]
steps = steps + merge(1,0,eulers>limits(2,1:3)) steps = steps + merge(1,0,eulers>limits(2,1:3))
limits(1,1:3) = min(limits(1,1:3),eulers) limits(1,1:3) = min(limits(1,1:3),eulers)
limits(2,1:3) = max(limits(2,1:3),eulers) limits(2,1:3) = max(limits(2,1:3),eulers)
@ -679,14 +677,14 @@ function IO_hybridIA(Nast,ODFfileName)
do phi1=1_pInt,steps(1); do Phi=1_pInt,steps(2); do phi2=1_pInt,steps(3) do phi1=1_pInt,steps(1); do Phi=1_pInt,steps(2); do phi2=1_pInt,steps(3)
line=IO_read(FILEUNIT) line=IO_read(FILEUNIT)
positions = IO_stringPos(line,7_pInt) chunkPos = IO_stringPos(line)
eulers=[IO_floatValue(line,positions,columns(1)),& ! read in again for consistency check only eulers=[IO_floatValue(line,chunkPos,columns(1)),& ! read in again for consistency check only
IO_floatValue(line,positions,columns(2)),& IO_floatValue(line,chunkPos,columns(2)),&
IO_floatValue(line,positions,columns(3))]*INRAD IO_floatValue(line,chunkPos,columns(3))]*INRAD
if (any(abs((real([phi1,phi,phi2],pReal)-1.0_pReal + center)*deltas-eulers)>tol_math_check)) & ! check if data is in expected order (phi2 fast) if (any(abs((real([phi1,phi,phi2],pReal)-1.0_pReal + center)*deltas-eulers)>tol_math_check)) & ! check if data is in expected order (phi2 fast)
call IO_error(error_ID = 156_pInt, ext_msg='linear ODF data not in expected order') call IO_error(error_ID = 156_pInt, ext_msg='linear ODF data not in expected order')
prob = IO_floatValue(line,positions,columns(4)) prob = IO_floatValue(line,chunkPos,columns(4))
if (prob > 0.0_pReal) then if (prob > 0.0_pReal) then
NnonZero = NnonZero+1_pInt NnonZero = NnonZero+1_pInt
sum_dV_V = sum_dV_V+prob sum_dV_V = sum_dV_V+prob
@ -865,10 +863,9 @@ function IO_countTagInPart(fileUnit,part,tag,Nsections)
character(len=*),intent(in) :: part, & !< part in which tag is searched for character(len=*),intent(in) :: part, & !< part in which tag is searched for
tag !< tag to search for tag !< tag to search for
integer(pInt), parameter :: MAXNCHUNKS = 1_pInt
integer(pInt), dimension(Nsections) :: counter integer(pInt), dimension(Nsections) :: counter
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: section integer(pInt) :: section
character(len=65536) :: line character(len=65536) :: line
@ -890,8 +887,8 @@ function IO_countTagInPart(fileUnit,part,tag,Nsections)
endif endif
if (IO_getTag(line,'[',']') /= '') section = section + 1_pInt ! found [section] identifier if (IO_getTag(line,'[',']') /= '') section = section + 1_pInt ! found [section] identifier
if (section > 0) then if (section > 0) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (tag == trim(IO_lc(IO_stringValue(line,positions,1_pInt)))) & ! match if (tag == trim(IO_lc(IO_stringValue(line,chunkPos,1_pInt)))) & ! match
counter(section) = counter(section) + 1_pInt counter(section) = counter(section) + 1_pInt
endif endif
enddo enddo
@ -913,9 +910,8 @@ function IO_spotTagInPart(fileUnit,part,tag,Nsections)
character(len=*),intent(in) :: part, & !< part in which tag is searched for character(len=*),intent(in) :: part, & !< part in which tag is searched for
tag !< tag to search for tag !< tag to search for
integer(pInt), parameter :: MAXNCHUNKS = 1_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: section integer(pInt) :: section
character(len=65536) :: line character(len=65536) :: line
@ -937,8 +933,8 @@ function IO_spotTagInPart(fileUnit,part,tag,Nsections)
endif endif
if (IO_getTag(line,'[',']') /= '') section = section + 1_pInt ! found [section] identifier if (IO_getTag(line,'[',']') /= '') section = section + 1_pInt ! found [section] identifier
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (tag == trim(IO_lc(IO_stringValue(line,positions,1_pInt)))) & ! matsch ! match if (tag == trim(IO_lc(IO_stringValue(line,chunkPos,1_pInt)))) & ! match
IO_spotTagInPart(section) = .true. IO_spotTagInPart(section) = .true.
endif endif
enddo enddo
@ -956,9 +952,8 @@ logical function IO_globalTagInPart(fileUnit,part,tag)
character(len=*),intent(in) :: part, & !< part in which tag is searched for character(len=*),intent(in) :: part, & !< part in which tag is searched for
tag !< tag to search for tag !< tag to search for
integer(pInt), parameter :: MAXNCHUNKS = 1_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: section integer(pInt) :: section
character(len=65536) :: line character(len=65536) :: line
@ -980,8 +975,8 @@ logical function IO_globalTagInPart(fileUnit,part,tag)
endif endif
if (IO_getTag(line,'[',']') /= '') section = section + 1_pInt ! found [section] identifier if (IO_getTag(line,'[',']') /= '') section = section + 1_pInt ! found [section] identifier
if (section == 0_pInt) then if (section == 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (tag == trim(IO_lc(IO_stringValue(line,positions,1_pInt)))) & ! match if (tag == trim(IO_lc(IO_stringValue(line,chunkPos,1_pInt)))) & ! match
IO_globalTagInPart = .true. IO_globalTagInPart = .true.
endif endif
enddo enddo
@ -990,33 +985,28 @@ end function IO_globalTagInPart
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief locates at most N space-separated parts in string and returns array containing number of !> @brief locates all space-separated chunks in given string and returns array containing number
!! parts in string and the left/right positions of at most N to be used by IO_xxxVal !! them and the left/right position to be used by IO_xxxVal
!! Array size is dynamically adjusted to number of chunks found in string
!! IMPORTANT: first element contains number of chunks! !! IMPORTANT: first element contains number of chunks!
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure function IO_stringPos(string,N) pure function IO_stringPos(string)
implicit none implicit none
integer(pInt), intent(in) :: N !< maximum number of parts integer(pInt), dimension(:), allocatable :: IO_stringPos
integer(pInt), dimension(1_pInt+N*2_pInt) :: IO_stringPos character(len=*), intent(in) :: string !< string in which chunk positions are searched for
character(len=*), intent(in) :: string !< string in which parts are searched for
character(len=*), parameter :: SEP=achar(44)//achar(32)//achar(9)//achar(10)//achar(13) ! comma and whitespaces character(len=*), parameter :: SEP=achar(44)//achar(32)//achar(9)//achar(10)//achar(13) ! comma and whitespaces
integer :: left, right ! no pInt (verify and scan return default integer) integer :: left, right ! no pInt (verify and scan return default integer)
allocate(IO_stringPos(1), source=0_pInt)
IO_stringPos = -1_pInt
IO_stringPos(1) = 0_pInt
right = 0 right = 0
do while (verify(string(right+1:),SEP)>0) do while (verify(string(right+1:),SEP)>0)
left = right + verify(string(right+1:),SEP) left = right + verify(string(right+1:),SEP)
right = left + scan(string(left:),SEP) - 2 right = left + scan(string(left:),SEP) - 2
if ( string(left:left) == '#' ) exit if ( string(left:left) == '#' ) exit
if ( IO_stringPos(1)<N ) then IO_stringPos = [IO_stringPos,int(left, pInt), int(right, pInt)]
IO_stringPos(1_pInt+IO_stringPos(1)*2_pInt+1_pInt) = int(left, pInt)
IO_stringPos(1_pInt+IO_stringPos(1)*2_pInt+2_pInt) = int(right, pInt)
endif
IO_stringPos(1) = IO_stringPos(1)+1_pInt IO_stringPos(1) = IO_stringPos(1)+1_pInt
enddo enddo
@ -1024,45 +1014,17 @@ end function IO_stringPos
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief locates at all space-separated parts in string and returns array containing number of !> @brief reads string value at myChunk from string
!! parts in string and the left/right positions to be used by IO_xxxVal
!! Array size is dynamically adjusted to number of chunks found in string
!! IMPORTANT: first element contains number of chunks!
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure function IO_stringPos2(string) function IO_stringValue(string,chunkPos,myChunk,silent)
implicit none
integer(pInt), dimension(:), allocatable :: IO_stringPos2
character(len=*), intent(in) :: string !< string in which parts are searched for
character(len=*), parameter :: SEP=achar(44)//achar(32)//achar(9)//achar(10)//achar(13) ! comma and whitespaces
integer :: left, right ! no pInt (verify and scan return default integer)
allocate(IO_stringPos2(1), source=0_pInt)
right = 0
do while (verify(string(right+1:),SEP)>0)
left = right + verify(string(right+1:),SEP)
right = left + scan(string(left:),SEP) - 2
if ( string(left:left) == '#' ) exit
IO_stringPos2 = [IO_stringPos2,int(left, pInt), int(right, pInt)]
IO_stringPos2(1) = IO_stringPos2(1)+1_pInt
enddo
end function IO_stringPos2
!--------------------------------------------------------------------------------------------------
!> @brief reads string value at myPos from string
!--------------------------------------------------------------------------------------------------
function IO_stringValue(string,positions,myPos,silent)
implicit none implicit none
integer(pInt), dimension(:), intent(in) :: positions !< positions of tags in string integer(pInt), dimension(:), intent(in) :: chunkPos !< positions of start and end of each tag/chunk in given string
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
character(len=1+positions(myPos*2+1)-positions(myPos*2)) :: IO_stringValue character(len=*), intent(in) :: string !< raw input with known start and end of each chunk
character(len=*), intent(in) :: string !< raw input with known positions character(len=:), allocatable :: IO_stringValue
logical, optional,intent(in) :: silent !< switch to trigger verbosity
logical, optional,intent(in) :: silent !< switch to trigger verbosity
character(len=16), parameter :: MYNAME = 'IO_stringValue: ' character(len=16), parameter :: MYNAME = 'IO_stringValue: '
logical :: warn logical :: warn
@ -1074,84 +1036,84 @@ function IO_stringValue(string,positions,myPos,silent)
endif endif
IO_stringValue = '' IO_stringValue = ''
if (myPos > positions(1) .or. myPos < 1_pInt) then ! trying to access non-present value valuePresent: if (myChunk > chunkPos(1) .or. myChunk < 1_pInt) then
if (warn) call IO_warning(201,el=myPos,ext_msg=MYNAME//trim(string)) if (warn) call IO_warning(201,el=myChunk,ext_msg=MYNAME//trim(string))
else else valuePresent
IO_stringValue = string(positions(myPos*2):positions(myPos*2+1)) IO_stringValue = string(chunkPos(myChunk*2):chunkPos(myChunk*2+1))
endif endif valuePresent
end function IO_stringValue end function IO_stringValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief reads string value at myPos from fixed format string !> @brief reads string value at myChunk from fixed format string
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
pure function IO_fixedStringValue (string,ends,myPos) pure function IO_fixedStringValue (string,ends,myChunk)
implicit none implicit none
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
integer(pInt), dimension(:), intent(in) :: ends !< positions of ends in string integer(pInt), dimension(:), intent(in) :: ends !< positions of end of each tag/chunk in given string
character(len=ends(myPos+1)-ends(myPos)) :: IO_fixedStringValue character(len=ends(myChunk+1)-ends(myChunk)) :: IO_fixedStringValue
character(len=*), intent(in) :: string !< raw input with known ends character(len=*), intent(in) :: string !< raw input with known ends of each chunk
IO_fixedStringValue = string(ends(myPos)+1:ends(myPos+1)) IO_fixedStringValue = string(ends(myChunk)+1:ends(myChunk+1))
end function IO_fixedStringValue end function IO_fixedStringValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief reads float value at myPos from string !> @brief reads float value at myChunk from string
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
real(pReal) function IO_floatValue (string,positions,myPos) real(pReal) function IO_floatValue (string,chunkPos,myChunk)
implicit none implicit none
integer(pInt), dimension(:), intent(in) :: positions !< positions of tags in string integer(pInt), dimension(:), intent(in) :: chunkPos !< positions of start and end of each tag/chunk in given string
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
character(len=*), intent(in) :: string !< raw input with known positions character(len=*), intent(in) :: string !< raw input with known start and end of each chunk
character(len=15), parameter :: MYNAME = 'IO_floatValue: ' character(len=15), parameter :: MYNAME = 'IO_floatValue: '
character(len=17), parameter :: VALIDCHARACTERS = '0123456789eEdD.+-' character(len=17), parameter :: VALIDCHARACTERS = '0123456789eEdD.+-'
IO_floatValue = 0.0_pReal IO_floatValue = 0.0_pReal
if (myPos > positions(1) .or. myPos < 1_pInt) then ! trying to access non-present value valuePresent: if (myChunk > chunkPos(1) .or. myChunk < 1_pInt) then
call IO_warning(201,el=myPos,ext_msg=MYNAME//trim(string)) call IO_warning(201,el=myChunk,ext_msg=MYNAME//trim(string))
else else valuePresent
IO_floatValue = & IO_floatValue = &
IO_verifyFloatValue(trim(adjustl(string(positions(myPos*2):positions(myPos*2+1)))),& IO_verifyFloatValue(trim(adjustl(string(chunkPos(myChunk*2):chunkPos(myChunk*2+1)))),&
VALIDCHARACTERS,MYNAME) VALIDCHARACTERS,MYNAME)
endif endif valuePresent
end function IO_floatValue end function IO_floatValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief reads float value at myPos from fixed format string !> @brief reads float value at myChunk from fixed format string
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
real(pReal) function IO_fixedFloatValue (string,ends,myPos) real(pReal) function IO_fixedFloatValue (string,ends,myChunk)
implicit none implicit none
character(len=*), intent(in) :: string !< raw input with known ends character(len=*), intent(in) :: string !< raw input with known ends of each chunk
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
integer(pInt), dimension(:), intent(in) :: ends !< positions of ends in string integer(pInt), dimension(:), intent(in) :: ends !< positions of end of each tag/chunk in given string
character(len=20), parameter :: MYNAME = 'IO_fixedFloatValue: ' character(len=20), parameter :: MYNAME = 'IO_fixedFloatValue: '
character(len=17), parameter :: VALIDCHARACTERS = '0123456789eEdD.+-' character(len=17), parameter :: VALIDCHARACTERS = '0123456789eEdD.+-'
IO_fixedFloatValue = & IO_fixedFloatValue = &
IO_verifyFloatValue(trim(adjustl(string(ends(myPos)+1_pInt:ends(myPos+1_pInt)))),& IO_verifyFloatValue(trim(adjustl(string(ends(myChunk)+1_pInt:ends(myChunk+1_pInt)))),&
VALIDCHARACTERS,MYNAME) VALIDCHARACTERS,MYNAME)
end function IO_fixedFloatValue end function IO_fixedFloatValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief reads float x.y+z value at myPos from format string !> @brief reads float x.y+z value at myChunk from format string
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
real(pReal) function IO_fixedNoEFloatValue (string,ends,myPos) real(pReal) function IO_fixedNoEFloatValue (string,ends,myChunk)
implicit none implicit none
character(len=*), intent(in) :: string !< raw input with known ends character(len=*), intent(in) :: string !< raw input with known ends of each chunk
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
integer(pInt), dimension(:), intent(in) :: ends !< positions of ends in string integer(pInt), dimension(:), intent(in) :: ends !< positions of end of each tag/chunk in given string
character(len=22), parameter :: MYNAME = 'IO_fixedNoEFloatValue ' character(len=22), parameter :: MYNAME = 'IO_fixedNoEFloatValue '
character(len=13), parameter :: VALIDBASE = '0123456789.+-' character(len=13), parameter :: VALIDBASE = '0123456789.+-'
character(len=12), parameter :: VALIDEXP = '0123456789+-' character(len=12), parameter :: VALIDEXP = '0123456789+-'
@ -1160,59 +1122,59 @@ real(pReal) function IO_fixedNoEFloatValue (string,ends,myPos)
integer(pInt) :: expon integer(pInt) :: expon
integer :: pos_exp integer :: pos_exp
pos_exp = scan(string(ends(myPos)+1:ends(myPos+1)),'+-',back=.true.) pos_exp = scan(string(ends(myChunk)+1:ends(myChunk+1)),'+-',back=.true.)
if (pos_exp > 1) then hasExponent: if (pos_exp > 1) then
base = IO_verifyFloatValue(trim(adjustl(string(ends(myPos)+1_pInt:ends(myPos)+pos_exp-1_pInt))),& base = IO_verifyFloatValue(trim(adjustl(string(ends(myChunk)+1_pInt:ends(myChunk)+pos_exp-1_pInt))),&
VALIDBASE,MYNAME//'(base): ') VALIDBASE,MYNAME//'(base): ')
expon = IO_verifyIntValue(trim(adjustl(string(ends(myPos)+pos_exp:ends(myPos+1_pInt)))),& expon = IO_verifyIntValue(trim(adjustl(string(ends(myChunk)+pos_exp:ends(myChunk+1_pInt)))),&
VALIDEXP,MYNAME//'(exp): ') VALIDEXP,MYNAME//'(exp): ')
else else hasExponent
base = IO_verifyFloatValue(trim(adjustl(string(ends(myPos)+1_pInt:ends(myPos+1_pInt)))),& base = IO_verifyFloatValue(trim(adjustl(string(ends(myChunk)+1_pInt:ends(myChunk+1_pInt)))),&
VALIDBASE,MYNAME//'(base): ') VALIDBASE,MYNAME//'(base): ')
expon = 0_pInt expon = 0_pInt
endif endif hasExponent
IO_fixedNoEFloatValue = base*10.0_pReal**real(expon,pReal) IO_fixedNoEFloatValue = base*10.0_pReal**real(expon,pReal)
end function IO_fixedNoEFloatValue end function IO_fixedNoEFloatValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief reads integer value at myPos from string !> @brief reads integer value at myChunk from string
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
integer(pInt) function IO_intValue(string,ends,myPos) integer(pInt) function IO_intValue(string,chunkPos,myChunk)
implicit none implicit none
character(len=*), intent(in) :: string !< raw input with known ends character(len=*), intent(in) :: string !< raw input with known start and end of each chunk
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
integer(pInt), dimension(:), intent(in) :: ends !< positions of ends in string integer(pInt), dimension(:), intent(in) :: chunkPos !< positions of start and end of each tag/chunk in given string
character(len=13), parameter :: MYNAME = 'IO_intValue: ' character(len=13), parameter :: MYNAME = 'IO_intValue: '
character(len=12), parameter :: VALIDCHARACTERS = '0123456789+-' character(len=12), parameter :: VALIDCHARACTERS = '0123456789+-'
IO_intValue = 0_pInt IO_intValue = 0_pInt
if (myPos > ends(1) .or. myPos < 1_pInt) then ! trying to access non-present value valuePresent: if (myChunk > chunkPos(1) .or. myChunk < 1_pInt) then
call IO_warning(201,el=myPos,ext_msg=MYNAME//trim(string)) call IO_warning(201,el=myChunk,ext_msg=MYNAME//trim(string))
else else valuePresent
IO_intValue = IO_verifyIntValue(trim(adjustl(string(ends(myPos*2):ends(myPos*2+1)))),& IO_intValue = IO_verifyIntValue(trim(adjustl(string(chunkPos(myChunk*2):chunkPos(myChunk*2+1)))),&
VALIDCHARACTERS,MYNAME) VALIDCHARACTERS,MYNAME)
endif endif valuePresent
end function IO_intValue end function IO_intValue
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief reads integer value at myPos from fixed format string !> @brief reads integer value at myChunk from fixed format string
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
integer(pInt) function IO_fixedIntValue(string,ends,myPos) integer(pInt) function IO_fixedIntValue(string,ends,myChunk)
implicit none implicit none
character(len=*), intent(in) :: string !< raw input with known ends character(len=*), intent(in) :: string !< raw input with known ends of each chunk
integer(pInt), intent(in) :: myPos !< position of desired sub string integer(pInt), intent(in) :: myChunk !< position number of desired chunk
integer(pInt), dimension(:), intent(in) :: ends !< positions of ends in string integer(pInt), dimension(:), intent(in) :: ends !< positions of end of each tag/chunk in given string
character(len=20), parameter :: MYNAME = 'IO_fixedIntValue: ' character(len=20), parameter :: MYNAME = 'IO_fixedIntValue: '
character(len=12), parameter :: VALIDCHARACTERS = '0123456789+-' character(len=12), parameter :: VALIDCHARACTERS = '0123456789+-'
IO_fixedIntValue = IO_verifyIntValue(trim(adjustl(string(ends(myPos)+1_pInt:ends(myPos+1_pInt)))),& IO_fixedIntValue = IO_verifyIntValue(trim(adjustl(string(ends(myChunk)+1_pInt:ends(myChunk+1_pInt)))),&
VALIDCHARACTERS,MYNAME) VALIDCHARACTERS,MYNAME)
end function IO_fixedIntValue end function IO_fixedIntValue
@ -1250,10 +1212,7 @@ subroutine IO_skipChunks(fileUnit,N)
integer(pInt), intent(in) :: fileUnit, & !< file handle integer(pInt), intent(in) :: fileUnit, & !< file handle
N !< minimum number of chunks to skip N !< minimum number of chunks to skip
integer(pInt), parameter :: MAXNCHUNKS = 64_pInt
integer(pInt) :: remainingChunks integer(pInt) :: remainingChunks
integer(pInt), dimension(1+2*MAXNCHUNKS) :: myPos
character(len=65536) :: line character(len=65536) :: line
line = '' line = ''
@ -1261,8 +1220,7 @@ subroutine IO_skipChunks(fileUnit,N)
do while (trim(line) /= IO_EOF .and. remainingChunks > 0) do while (trim(line) /= IO_EOF .and. remainingChunks > 0)
line = IO_read(fileUnit) line = IO_read(fileUnit)
myPos = IO_stringPos(line,MAXNCHUNKS) remainingChunks = remainingChunks - (size(IO_stringPos(line))-1_pInt)/2_pInt
remainingChunks = remainingChunks - myPos(1)
enddo enddo
end subroutine IO_skipChunks end subroutine IO_skipChunks
@ -1278,13 +1236,13 @@ character(len=300) pure function IO_extractValue(pair,key)
character(len=*), parameter :: SEP = achar(61) ! '=' character(len=*), parameter :: SEP = achar(61) ! '='
integer :: myPos ! no pInt (scan returns default integer) integer :: myChunk !< position number of desired chunk
IO_extractValue = '' IO_extractValue = ''
myPos = scan(pair,SEP) myChunk = scan(pair,SEP)
if (myPos > 0 .and. pair(:myPos-1) == key(:myPos-1)) & ! key matches expected key if (myChunk > 0 .and. pair(:myChunk-1) == key(:myChunk-1)) &
IO_extractValue = pair(myPos+1:) ! extract value IO_extractValue = pair(myChunk+1:) ! extract value if key matches
end function IO_extractValue end function IO_extractValue
@ -1297,9 +1255,8 @@ integer(pInt) function IO_countDataLines(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit !< file handle integer(pInt), intent(in) :: fileUnit !< file handle
integer(pInt), parameter :: MAXNCHUNKS = 1_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: myPos integer(pInt), allocatable, dimension(:) :: chunkPos
character(len=65536) :: line, & character(len=65536) :: line, &
tmp tmp
@ -1308,8 +1265,8 @@ integer(pInt) function IO_countDataLines(fileUnit)
do while (trim(line) /= IO_EOF) do while (trim(line) /= IO_EOF)
line = IO_read(fileUnit) line = IO_read(fileUnit)
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tmp = IO_lc(IO_stringValue(line,myPos,1_pInt)) tmp = IO_lc(IO_stringValue(line,chunkPos,1_pInt))
if (tmp(1:1) == '*' .and. tmp(2:2) /= '*') then ! found keyword if (tmp(1:1) == '*' .and. tmp(2:2) /= '*') then ! found keyword
line = IO_read(fileUnit, .true.) ! reset IO_read line = IO_read(fileUnit, .true.) ! reset IO_read
exit exit
@ -1333,11 +1290,10 @@ integer(pInt) function IO_countContinuousIntValues(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 8192_pInt
#ifdef Abaqus #ifdef Abaqus
integer(pInt) :: l,c integer(pInt) :: l,c
#endif #endif
integer(pInt), dimension(1+2*MAXNCHUNKS) :: myPos integer(pInt), allocatable, dimension(:) :: chunkPos
character(len=65536) :: line character(len=65536) :: line
IO_countContinuousIntValues = 0_pInt IO_countContinuousIntValues = 0_pInt
@ -1346,22 +1302,22 @@ integer(pInt) function IO_countContinuousIntValues(fileUnit)
#ifndef Abaqus #ifndef Abaqus
do while (trim(line) /= IO_EOF) do while (trim(line) /= IO_EOF)
line = IO_read(fileUnit) line = IO_read(fileUnit)
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (myPos(1) < 1_pInt) then ! empty line if (chunkPos(1) < 1_pInt) then ! empty line
line = IO_read(fileUnit, .true.) ! reset IO_read line = IO_read(fileUnit, .true.) ! reset IO_read
exit exit
elseif (IO_lc(IO_stringValue(line,myPos,2_pInt)) == 'to' ) then ! found range indicator elseif (IO_lc(IO_stringValue(line,chunkPos,2_pInt)) == 'to' ) then ! found range indicator
IO_countContinuousIntValues = 1_pInt + IO_intValue(line,myPos,3_pInt) & IO_countContinuousIntValues = 1_pInt + IO_intValue(line,chunkPos,3_pInt) &
- IO_intValue(line,myPos,1_pInt) - IO_intValue(line,chunkPos,1_pInt)
line = IO_read(fileUnit, .true.) ! reset IO_read line = IO_read(fileUnit, .true.) ! reset IO_read
exit ! only one single range indicator allowed exit ! only one single range indicator allowed
else if (IO_lc(IO_stringValue(line,myPos,2_pInt)) == 'of' ) then ! found multiple entries indicator else if (IO_lc(IO_stringValue(line,chunkPos,2_pInt)) == 'of' ) then ! found multiple entries indicator
IO_countContinuousIntValues = IO_intValue(line,myPos,1_pInt) IO_countContinuousIntValues = IO_intValue(line,chunkPos,1_pInt)
line = IO_read(fileUnit, .true.) ! reset IO_read line = IO_read(fileUnit, .true.) ! reset IO_read
exit ! only one single multiplier allowed exit ! only one single multiplier allowed
else else
IO_countContinuousIntValues = IO_countContinuousIntValues+myPos(1)-1_pInt ! add line's count when assuming 'c' IO_countContinuousIntValues = IO_countContinuousIntValues+chunkPos(1)-1_pInt ! add line's count when assuming 'c'
if ( IO_lc(IO_stringValue(line,myPos,myPos(1))) /= 'c' ) then ! line finished, read last value if ( IO_lc(IO_stringValue(line,chunkPos,chunkPos(1))) /= 'c' ) then ! line finished, read last value
IO_countContinuousIntValues = IO_countContinuousIntValues+1_pInt IO_countContinuousIntValues = IO_countContinuousIntValues+1_pInt
line = IO_read(fileUnit, .true.) ! reset IO_read line = IO_read(fileUnit, .true.) ! reset IO_read
exit ! data ended exit ! data ended
@ -1378,10 +1334,10 @@ integer(pInt) function IO_countContinuousIntValues(fileUnit)
do while (trim(line) /= IO_EOF .and. l <= c) ! ToDo: is this correct do while (trim(line) /= IO_EOF .and. l <= c) ! ToDo: is this correct
l = l + 1_pInt l = l + 1_pInt
line = IO_read(fileUnit) line = IO_read(fileUnit)
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
IO_countContinuousIntValues = IO_countContinuousIntValues + 1_pInt + & ! assuming range generation IO_countContinuousIntValues = IO_countContinuousIntValues + 1_pInt + & ! assuming range generation
(IO_intValue(line,myPos,2_pInt)-IO_intValue(line,myPos,1_pInt))/& (IO_intValue(line,chunkPos,2_pInt)-IO_intValue(line,chunkPos,1_pInt))/&
max(1_pInt,IO_intValue(line,myPos,3_pInt)) max(1_pInt,IO_intValue(line,chunkPos,3_pInt))
enddo enddo
#endif #endif
@ -1405,13 +1361,12 @@ function IO_continuousIntValues(fileUnit,maxN,lookupName,lookupMap,lookupMaxN)
lookupMaxN lookupMaxN
integer(pInt), dimension(:,:), intent(in) :: lookupMap integer(pInt), dimension(:,:), intent(in) :: lookupMap
character(len=64), dimension(:), intent(in) :: lookupName character(len=64), dimension(:), intent(in) :: lookupName
integer(pInt), parameter :: MAXNCHUNKS = 8192_pInt
integer(pInt) :: i integer(pInt) :: i
#ifdef Abaqus #ifdef Abaqus
integer(pInt) :: j,l,c,first,last integer(pInt) :: j,l,c,first,last
#endif #endif
integer(pInt), dimension(1+2*MAXNCHUNKS) :: myPos integer(pInt), allocatable, dimension(:) :: chunkPos
character(len=65536) line character(len=65536) line
logical rangeGeneration logical rangeGeneration
@ -1421,35 +1376,35 @@ function IO_continuousIntValues(fileUnit,maxN,lookupName,lookupMap,lookupMaxN)
#ifndef Abaqus #ifndef Abaqus
do do
read(fileUnit,'(A65536)',end=100) line read(fileUnit,'(A65536)',end=100) line
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (myPos(1) < 1_pInt) then ! empty line if (chunkPos(1) < 1_pInt) then ! empty line
exit exit
elseif (verify(IO_stringValue(line,myPos,1_pInt),'0123456789') > 0) then ! a non-int, i.e. set name elseif (verify(IO_stringValue(line,chunkPos,1_pInt),'0123456789') > 0) then ! a non-int, i.e. set name
do i = 1_pInt, lookupMaxN ! loop over known set names do i = 1_pInt, lookupMaxN ! loop over known set names
if (IO_stringValue(line,myPos,1_pInt) == lookupName(i)) then ! found matching name if (IO_stringValue(line,chunkPos,1_pInt) == lookupName(i)) then ! found matching name
IO_continuousIntValues = lookupMap(:,i) ! return resp. entity list IO_continuousIntValues = lookupMap(:,i) ! return resp. entity list
exit exit
endif endif
enddo enddo
exit exit
else if (myPos(1) > 2_pInt .and. IO_lc(IO_stringValue(line,myPos,2_pInt)) == 'to' ) then ! found range indicator else if (chunkPos(1) > 2_pInt .and. IO_lc(IO_stringValue(line,chunkPos,2_pInt)) == 'to' ) then ! found range indicator
do i = IO_intValue(line,myPos,1_pInt),IO_intValue(line,myPos,3_pInt) do i = IO_intValue(line,chunkPos,1_pInt),IO_intValue(line,chunkPos,3_pInt)
IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt
IO_continuousIntValues(1+IO_continuousIntValues(1)) = i IO_continuousIntValues(1+IO_continuousIntValues(1)) = i
enddo enddo
exit exit
else if (myPos(1) > 2_pInt .and. IO_lc(IO_stringValue(line,myPos,2_pInt)) == 'of' ) then ! found multiple entries indicator else if (chunkPos(1) > 2_pInt .and. IO_lc(IO_stringValue(line,chunkPos,2_pInt)) == 'of' ) then ! found multiple entries indicator
IO_continuousIntValues(1) = IO_intValue(line,myPos,1_pInt) IO_continuousIntValues(1) = IO_intValue(line,chunkPos,1_pInt)
IO_continuousIntValues(2:IO_continuousIntValues(1)+1) = IO_intValue(line,myPos,3_pInt) IO_continuousIntValues(2:IO_continuousIntValues(1)+1) = IO_intValue(line,chunkPos,3_pInt)
exit exit
else else
do i = 1_pInt,myPos(1)-1_pInt ! interpret up to second to last value do i = 1_pInt,chunkPos(1)-1_pInt ! interpret up to second to last value
IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt
IO_continuousIntValues(1+IO_continuousIntValues(1)) = IO_intValue(line,myPos,i) IO_continuousIntValues(1+IO_continuousIntValues(1)) = IO_intValue(line,chunkPos,i)
enddo enddo
if ( IO_lc(IO_stringValue(line,myPos,myPos(1))) /= 'c' ) then ! line finished, read last value if ( IO_lc(IO_stringValue(line,chunkPos,chunkPos(1))) /= 'c' ) then ! line finished, read last value
IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt
IO_continuousIntValues(1+IO_continuousIntValues(1)) = IO_intValue(line,myPos,myPos(1)) IO_continuousIntValues(1+IO_continuousIntValues(1)) = IO_intValue(line,chunkPos,chunkPos(1))
exit exit
endif endif
endif endif
@ -1464,18 +1419,18 @@ function IO_continuousIntValues(fileUnit,maxN,lookupName,lookupMap,lookupMaxN)
! check if the element values in the elset are auto generated ! check if the element values in the elset are auto generated
backspace(fileUnit) backspace(fileUnit)
read(fileUnit,'(A65536)',end=100) line read(fileUnit,'(A65536)',end=100) line
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
do i = 1_pInt,myPos(1) do i = 1_pInt,chunkPos(1)
if (IO_lc(IO_stringValue(line,myPos,i)) == 'generate') rangeGeneration = .true. if (IO_lc(IO_stringValue(line,chunkPos,i)) == 'generate') rangeGeneration = .true.
enddo enddo
do l = 1_pInt,c do l = 1_pInt,c
read(fileUnit,'(A65536)',end=100) line read(fileUnit,'(A65536)',end=100) line
myPos = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (verify(IO_stringValue(line,myPos,1_pInt),'0123456789') > 0) then ! a non-int, i.e. set names follow on this line if (verify(IO_stringValue(line,chunkPos,1_pInt),'0123456789') > 0) then ! a non-int, i.e. set names follow on this line
do i = 1_pInt,myPos(1) ! loop over set names in line do i = 1_pInt,myChunk(1) ! loop over set names in line
do j = 1_pInt,lookupMaxN ! look through known set names do j = 1_pInt,lookupMaxN ! look through known set names
if (IO_stringValue(line,myPos,i) == lookupName(j)) then ! found matching name if (IO_stringValue(line,chunkPos,i) == lookupName(j)) then ! found matching name
first = 2_pInt + IO_continuousIntValues(1) ! where to start appending data first = 2_pInt + IO_continuousIntValues(1) ! where to start appending data
last = first + lookupMap(1,j) - 1_pInt ! up to where to append data last = first + lookupMap(1,j) - 1_pInt ! up to where to append data
IO_continuousIntValues(first:last) = lookupMap(2:1+lookupMap(1,j),j) ! add resp. entity list IO_continuousIntValues(first:last) = lookupMap(2:1+lookupMap(1,j),j) ! add resp. entity list
@ -1484,14 +1439,16 @@ function IO_continuousIntValues(fileUnit,maxN,lookupName,lookupMap,lookupMaxN)
enddo enddo
enddo enddo
else if (rangeGeneration) then ! range generation else if (rangeGeneration) then ! range generation
do i = IO_intValue(line,myPos,1_pInt),IO_intValue(line,myPos,2_pInt),max(1_pInt,IO_intValue(line,myPos,3_pInt)) do i = IO_intValue(line,chunkPos,1_pInt),&
IO_intValue(line,chunkPos,2_pInt),&
max(1_pInt,IO_intValue(line,chunkPos,3_pInt))
IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt
IO_continuousIntValues(1+IO_continuousIntValues(1)) = i IO_continuousIntValues(1+IO_continuousIntValues(1)) = i
enddo enddo
else ! read individual elem nums else ! read individual elem nums
do i = 1_pInt,myPos(1) do i = 1_pInt,myChunk(1)
IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt IO_continuousIntValues(1) = IO_continuousIntValues(1) + 1_pInt
IO_continuousIntValues(1+IO_continuousIntValues(1)) = IO_intValue(line,myPos,i) IO_continuousIntValues(1+IO_continuousIntValues(1)) = IO_intValue(line,chunkPos,i)
enddo enddo
endif endif
enddo enddo
@ -1646,15 +1603,11 @@ subroutine IO_error(error_ID,el,ip,g,ext_msg)
case (406_pInt) case (406_pInt)
msg = 'Prime-error: N must be between 0 and PRIME_MAX' msg = 'Prime-error: N must be between 0 and PRIME_MAX'
case (407_pInt) case (407_pInt)
msg = 'Dimension in nearest neighbor search wrong'
case (408_pInt)
msg = 'Polar decomposition error' msg = 'Polar decomposition error'
case (409_pInt) case (409_pInt)
msg = 'math_check: R*v == q*v failed' msg = 'math_check: R*v == q*v failed'
case (450_pInt) case (450_pInt)
msg = 'unknown symmetry type specified' msg = 'unknown symmetry type specified'
case (460_pInt)
msg = 'kdtree2 error'
!------------------------------------------------------------------------------------------------- !-------------------------------------------------------------------------------------------------
! homogenization errors ! homogenization errors
@ -1948,18 +1901,17 @@ recursive function abaqus_assembleInputFile(unit1,unit2) result(createSuccess)
integer(pInt), intent(in) :: unit1, & integer(pInt), intent(in) :: unit1, &
unit2 unit2
integer(pInt), parameter :: MAXNCHUNKS = 6_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
character(len=65536) :: line,fname character(len=65536) :: line,fname
logical :: createSuccess,fexist logical :: createSuccess,fexist
do do
read(unit2,'(A65536)',END=220) line read(unit2,'(A65536)',END=220) line
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
if (IO_lc(IO_StringValue(line,positions,1_pInt))=='*include') then if (IO_lc(IO_StringValue(line,chunkPos,1_pInt))=='*include') then
fname = trim(getSolverWorkingDirectoryName())//trim(line(9+scan(line(9:),'='):)) fname = trim(getSolverWorkingDirectoryName())//trim(line(9+scan(line(9:),'='):))
inquire(file=fname, exist=fexist) inquire(file=fname, exist=fexist)
if (.not.(fexist)) then if (.not.(fexist)) then

13
code/crystallite.f90
View File

@ -184,10 +184,9 @@ subroutine crystallite_init
implicit none implicit none
integer(pInt), parameter :: & integer(pInt), parameter :: &
FILEUNIT = 200_pInt, & FILEUNIT = 200_pInt
MAXNCHUNKS = 2_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: & integer(pInt) :: &
g, & !< grain number g, & !< grain number
i, & !< integration point number i, & !< integration point number
@ -299,12 +298,12 @@ subroutine crystallite_init
cycle ! skip to next line cycle ! skip to next line
endif endif
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
output = output + 1_pInt output = output + 1_pInt
crystallite_output(output,section) = IO_lc(IO_stringValue(line,positions,2_pInt)) crystallite_output(output,section) = IO_lc(IO_stringValue(line,chunkPos,2_pInt))
select case(crystallite_output(output,section)) select case(crystallite_output(output,section))
case ('phase') case ('phase')
crystallite_outputID(output,section) = phase_ID crystallite_outputID(output,section) = phase_ID
@ -351,7 +350,7 @@ subroutine crystallite_init
case ('neighboringelement') case ('neighboringelement')
crystallite_outputID(output,section) = neighboringelement_ID crystallite_outputID(output,section) = neighboringelement_ID
case default case default
call IO_error(105_pInt,ext_msg=IO_stringValue(line,positions,2_pInt)//' (Crystallite)') call IO_error(105_pInt,ext_msg=IO_stringValue(line,chunkPos,2_pInt)//' (Crystallite)')
end select end select
end select end select
endif endif

11
code/damage_local.f90
View File

@ -76,8 +76,7 @@ subroutine damage_local_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,homog,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,homog,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -123,16 +122,16 @@ subroutine damage_local_init(fileUnit)
if (homog > 0_pInt ) then; if (damage_type(homog) == DAMAGE_local_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (homog > 0_pInt ) then; if (damage_type(homog) == DAMAGE_local_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = damage_typeInstance(homog) ! which instance of my damage is present homog instance = damage_typeInstance(homog) ! which instance of my damage is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('damage') case ('damage')
damage_local_Noutput(instance) = damage_local_Noutput(instance) + 1_pInt damage_local_Noutput(instance) = damage_local_Noutput(instance) + 1_pInt
damage_local_outputID(damage_local_Noutput(instance),instance) = damage_ID damage_local_outputID(damage_local_Noutput(instance),instance) = damage_ID
damage_local_output(damage_local_Noutput(instance),instance) = & damage_local_output(damage_local_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

15
code/damage_nonlocal.f90
View File

@ -81,8 +81,7 @@ subroutine damage_nonlocal_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -125,19 +124,19 @@ subroutine damage_nonlocal_init(fileUnit)
cycle ! skip to next line cycle ! skip to next line
endif endif
if (section > 0_pInt ) then; if (damage_type(section) == DAMAGE_nonlocal_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (damage_type(section) == DAMAGE_nonlocal_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = damage_typeInstance(section) ! which instance of my damage is present homog instance = damage_typeInstance(section) ! which instance of my damage is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('damage') case ('damage')
damage_nonlocal_Noutput(instance) = damage_nonlocal_Noutput(instance) + 1_pInt damage_nonlocal_Noutput(instance) = damage_nonlocal_Noutput(instance) + 1_pInt
damage_nonlocal_outputID(damage_nonlocal_Noutput(instance),instance) = damage_ID damage_nonlocal_outputID(damage_nonlocal_Noutput(instance),instance) = damage_ID
damage_nonlocal_output(damage_nonlocal_Noutput(instance),instance) = & damage_nonlocal_output(damage_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

38
code/damask.core.pyf
View File

@ -45,37 +45,6 @@ python module core ! in
subroutine math_init subroutine math_init
end subroutine math_init end subroutine math_init
function math_nearestNeighbor(querySet,domainSet) ! in :math:math.f90
! input variables
real*8, dimension(:,:), intent(in) :: querySet
real*8, dimension(:,:), intent(in) :: domainSet
! function definition
integer, dimension(size(querySet,2)), depend(querySet) :: math_nearestNeighbor
end function math_nearestNeighbor
function math_periodicNearestNeighbor(geomdim,Favg,querySet,domainSet) ! in :math:math.f90
! input variables
real*8, dimension(3), intent(in) :: geomdim
real*8, dimension(3,3), intent(in) :: Favg
real*8, dimension(:,:), intent(in) :: querySet
real*8, dimension(:,:), intent(in) :: domainSet
integer, dimension(size(querySet,2)), depend(querySet) :: math_periodicNearestNeighbor
! depending on input
real*8, dimension(size(domainSet,1),(3_pInt**size(domainSet,1))*size(domainSet,2)), depend(domainSet) :: domainSetLarge
end function math_periodicNearestNeighbor
function math_periodicNearestNeighborDistances(geomdim,Favg,querySet,domainSet,Ndist) ! in :math:math.f90
! input variables
real*8, dimension(3), intent(in) :: geomdim
real*8, dimension(3,3), intent(in) :: Favg
integer, intent(in) :: Ndist
real*8, dimension(:,:), intent(in) :: querySet
real*8, dimension(:,:), intent(in) :: domainSet
real*8, dimension(Ndist,size(querySet,2)), depend(Ndist,querySet) :: math_periodicNearestNeighborDistances
! depending on input
real*8, dimension(size(domainSet,1),(3_pInt**size(domainSet,1))*size(domainSet,2)), depend(domainSet) :: domainSetLarge
end function math_periodicNearestNeighborDistances
function math_tensorAvg(field) ! in :math:math.f90 function math_tensorAvg(field) ! in :math:math.f90
! input variables ! input variables
real*8 dimension(:,:,:,:,:), intent(in), :: field real*8 dimension(:,:,:,:,:), intent(in), :: field
@ -95,13 +64,6 @@ python module core ! in
integer, parameter :: ip = 1 integer, parameter :: ip = 1
integer, parameter :: element = 1 integer, parameter :: element = 1
end subroutine mesh_init end subroutine mesh_init
function mesh_regrid(adaptive,resNewInput,minRes) ! in :mesh:mesh.f90
logical, intent(in) :: adaptive
integer, dimension(3) :: mesh_regrid
integer, dimension(3), intent(in), optional :: resNewInput = -1
integer, dimension(3), intent(in), optional :: minRes = -1
end function mesh_regrid
function mesh_nodesAroundCentres(gDim,Favg,centres) ! in :mesh:mesh.f90 function mesh_nodesAroundCentres(gDim,Favg,centres) ! in :mesh:mesh.f90
real*8, dimension(:,:,:,:), intent(in) :: centres real*8, dimension(:,:,:,:), intent(in) :: centres

20
code/debug.f90
View File

@ -124,12 +124,10 @@ subroutine debug_init
implicit none implicit none
integer(pInt), parameter :: FILEUNIT = 300_pInt integer(pInt), parameter :: FILEUNIT = 300_pInt
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt
integer(pInt) :: i, what integer(pInt) :: i, what
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
character(len=65536) :: tag character(len=65536) :: tag, line
character(len=65536) :: line
mainProcess: if (worldrank == 0) then mainProcess: if (worldrank == 0) then
write(6,'(/,a)') ' <<<+- debug init -+>>>' write(6,'(/,a)') ' <<<+- debug init -+>>>'
@ -171,15 +169,15 @@ subroutine debug_init
do while (trim(line) /= IO_EOF) ! read thru sections of phase part do while (trim(line) /= IO_EOF) ! read thru sections of phase part
line = IO_read(FILEUNIT) line = IO_read(FILEUNIT)
if (IO_isBlank(line)) cycle ! skip empty lines if (IO_isBlank(line)) cycle ! skip empty lines
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('element','e','el') case ('element','e','el')
debug_e = IO_intValue(line,positions,2_pInt) debug_e = IO_intValue(line,chunkPos,2_pInt)
case ('integrationpoint','i','ip') case ('integrationpoint','i','ip')
debug_i = IO_intValue(line,positions,2_pInt) debug_i = IO_intValue(line,chunkPos,2_pInt)
case ('grain','g','gr') case ('grain','g','gr')
debug_g = IO_intValue(line,positions,2_pInt) debug_g = IO_intValue(line,chunkPos,2_pInt)
end select end select
what = 0_pInt what = 0_pInt
@ -216,8 +214,8 @@ subroutine debug_init
what = debug_MAXNTYPE + 2_pInt what = debug_MAXNTYPE + 2_pInt
end select end select
if (what /= 0) then if (what /= 0) then
do i = 2_pInt, positions(1) do i = 2_pInt, chunkPos(1)
select case(IO_lc(IO_stringValue(line,positions,i))) select case(IO_lc(IO_stringValue(line,chunkPos,i)))
case('basic') case('basic')
debug_level(what) = ior(debug_level(what), debug_LEVELBASIC) debug_level(what) = ior(debug_level(what), debug_LEVELBASIC)
case('extensive') case('extensive')

49
code/homogenization_RGC.f90
View File

@ -103,8 +103,7 @@ subroutine homogenization_RGC_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit !< file pointer to material configuration integer(pInt), intent(in) :: fileUnit !< file pointer to material configuration
integer(pInt), parameter :: MAXNCHUNKS = 4_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions
integer :: & integer :: &
homog, & homog, &
NofMyHomog, & NofMyHomog, &
@ -162,76 +161,76 @@ subroutine homogenization_RGC_init(fileUnit)
if (section > 0_pInt ) then ! do not short-circuit here (.and. with next if-statement). It's not safe in Fortran if (section > 0_pInt ) then ! do not short-circuit here (.and. with next if-statement). It's not safe in Fortran
if (homogenization_type(section) == HOMOGENIZATION_RGC_ID) then ! one of my sections if (homogenization_type(section) == HOMOGENIZATION_RGC_ID) then ! one of my sections
i = homogenization_typeInstance(section) ! which instance of my type is present homogenization i = homogenization_typeInstance(section) ! which instance of my type is present homogenization
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case('constitutivework') case('constitutivework')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = constitutivework_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = constitutivework_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('penaltyenergy') case('penaltyenergy')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = penaltyenergy_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = penaltyenergy_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('volumediscrepancy') case('volumediscrepancy')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = volumediscrepancy_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = volumediscrepancy_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('averagerelaxrate') case('averagerelaxrate')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = averagerelaxrate_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = averagerelaxrate_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('maximumrelaxrate') case('maximumrelaxrate')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = maximumrelaxrate_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = maximumrelaxrate_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('magnitudemismatch') case('magnitudemismatch')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = magnitudemismatch_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = magnitudemismatch_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('ipcoords') case('ipcoords')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = ipcoords_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = ipcoords_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('avgdefgrad','avgf') case('avgdefgrad','avgf')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = avgdefgrad_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = avgdefgrad_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('avgp','avgfirstpiola','avg1stpiola') case('avgp','avgfirstpiola','avg1stpiola')
homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt homogenization_RGC_Noutput(i) = homogenization_RGC_Noutput(i) + 1_pInt
homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = avgfirstpiola_ID homogenization_RGC_outputID(homogenization_RGC_Noutput(i),i) = avgfirstpiola_ID
homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = & homogenization_RGC_output(homogenization_RGC_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('clustersize') case ('clustersize')
homogenization_RGC_Ngrains(1,i) = IO_intValue(line,positions,2_pInt) homogenization_RGC_Ngrains(1,i) = IO_intValue(line,chunkPos,2_pInt)
homogenization_RGC_Ngrains(2,i) = IO_intValue(line,positions,3_pInt) homogenization_RGC_Ngrains(2,i) = IO_intValue(line,chunkPos,3_pInt)
homogenization_RGC_Ngrains(3,i) = IO_intValue(line,positions,4_pInt) homogenization_RGC_Ngrains(3,i) = IO_intValue(line,chunkPos,4_pInt)
if (homogenization_Ngrains(section) /= product(homogenization_RGC_Ngrains(1:3,i))) & if (homogenization_Ngrains(section) /= product(homogenization_RGC_Ngrains(1:3,i))) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//HOMOGENIZATION_RGC_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//HOMOGENIZATION_RGC_label//')')
case ('scalingparameter') case ('scalingparameter')
homogenization_RGC_xiAlpha(i) = IO_floatValue(line,positions,2_pInt) homogenization_RGC_xiAlpha(i) = IO_floatValue(line,chunkPos,2_pInt)
case ('overproportionality') case ('overproportionality')
homogenization_RGC_ciAlpha(i) = IO_floatValue(line,positions,2_pInt) homogenization_RGC_ciAlpha(i) = IO_floatValue(line,chunkPos,2_pInt)
case ('grainsize') case ('grainsize')
homogenization_RGC_dAlpha(1,i) = IO_floatValue(line,positions,2_pInt) homogenization_RGC_dAlpha(1,i) = IO_floatValue(line,chunkPos,2_pInt)
homogenization_RGC_dAlpha(2,i) = IO_floatValue(line,positions,3_pInt) homogenization_RGC_dAlpha(2,i) = IO_floatValue(line,chunkPos,3_pInt)
homogenization_RGC_dAlpha(3,i) = IO_floatValue(line,positions,4_pInt) homogenization_RGC_dAlpha(3,i) = IO_floatValue(line,chunkPos,4_pInt)
case ('clusterorientation') case ('clusterorientation')
homogenization_RGC_angles(1,i) = IO_floatValue(line,positions,2_pInt) homogenization_RGC_angles(1,i) = IO_floatValue(line,chunkPos,2_pInt)
homogenization_RGC_angles(2,i) = IO_floatValue(line,positions,3_pInt) homogenization_RGC_angles(2,i) = IO_floatValue(line,chunkPos,3_pInt)
homogenization_RGC_angles(3,i) = IO_floatValue(line,positions,4_pInt) homogenization_RGC_angles(3,i) = IO_floatValue(line,chunkPos,4_pInt)
end select end select
endif endif

21
code/homogenization_isostrain.f90
View File

@ -65,8 +65,7 @@ subroutine homogenization_isostrain_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 2_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions
integer(pInt) :: & integer(pInt) :: &
section = 0_pInt, i, mySize, o section = 0_pInt, i, mySize, o
integer :: & integer :: &
@ -121,37 +120,37 @@ subroutine homogenization_isostrain_init(fileUnit)
if (section > 0_pInt ) then ! do not short-circuit here (.and. with next if-statement). It's not safe in Fortran if (section > 0_pInt ) then ! do not short-circuit here (.and. with next if-statement). It's not safe in Fortran
if (homogenization_type(section) == HOMOGENIZATION_ISOSTRAIN_ID) then ! one of my sections if (homogenization_type(section) == HOMOGENIZATION_ISOSTRAIN_ID) then ! one of my sections
i = homogenization_typeInstance(section) ! which instance of my type is present homogenization i = homogenization_typeInstance(section) ! which instance of my type is present homogenization
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case('nconstituents','ngrains') case('nconstituents','ngrains')
homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt
homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = nconstituents_ID homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = nconstituents_ID
homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = & homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('ipcoords') case('ipcoords')
homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt
homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = ipcoords_ID homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = ipcoords_ID
homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = & homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('avgdefgrad','avgf') case('avgdefgrad','avgf')
homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt
homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = avgdefgrad_ID homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = avgdefgrad_ID
homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = & homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case('avgp','avgfirstpiola','avg1stpiola') case('avgp','avgfirstpiola','avg1stpiola')
homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt homogenization_isostrain_Noutput(i) = homogenization_isostrain_Noutput(i) + 1_pInt
homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = avgfirstpiola_ID homogenization_isostrain_outputID(homogenization_isostrain_Noutput(i),i) = avgfirstpiola_ID
homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = & homogenization_isostrain_output(homogenization_isostrain_Noutput(i),i) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('nconstituents','ngrains') case ('nconstituents','ngrains')
homogenization_isostrain_Ngrains(i) = IO_intValue(line,positions,2_pInt) homogenization_isostrain_Ngrains(i) = IO_intValue(line,chunkPos,2_pInt)
case ('mapping') case ('mapping')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('parallel','sum') case ('parallel','sum')
homogenization_isostrain_mapping(i) = parallel_ID homogenization_isostrain_mapping(i) = parallel_ID
case ('average','mean','avg') case ('average','mean','avg')

11
code/hydrogenflux_cahnhilliard.f90
View File

@ -88,8 +88,7 @@ subroutine hydrogenflux_cahnhilliard_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -135,16 +134,16 @@ subroutine hydrogenflux_cahnhilliard_init(fileUnit)
if (section > 0_pInt ) then; if (hydrogenflux_type(section) == HYDROGENFLUX_cahnhilliard_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (hydrogenflux_type(section) == HYDROGENFLUX_cahnhilliard_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = hydrogenflux_typeInstance(section) ! which instance of my hydrogenflux is present homog instance = hydrogenflux_typeInstance(section) ! which instance of my hydrogenflux is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('hydrogenconc') case ('hydrogenconc')
hydrogenflux_cahnhilliard_Noutput(instance) = hydrogenflux_cahnhilliard_Noutput(instance) + 1_pInt hydrogenflux_cahnhilliard_Noutput(instance) = hydrogenflux_cahnhilliard_Noutput(instance) + 1_pInt
hydrogenflux_cahnhilliard_outputID(hydrogenflux_cahnhilliard_Noutput(instance),instance) = hydrogenConc_ID hydrogenflux_cahnhilliard_outputID(hydrogenflux_cahnhilliard_Noutput(instance),instance) = hydrogenConc_ID
hydrogenflux_cahnhilliard_output(hydrogenflux_cahnhilliard_Noutput(instance),instance) = & hydrogenflux_cahnhilliard_output(hydrogenflux_cahnhilliard_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

19
code/kinematics_cleavage_opening.f90
View File

@ -88,8 +88,7 @@ subroutine kinematics_cleavage_opening_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,kinematics integer(pInt) :: maxNinstance,phase,instance,kinematics
integer(pInt) :: Nchunks_CleavageFamilies = 0_pInt, j integer(pInt) :: Nchunks_CleavageFamilies = 0_pInt, j
character(len=65536) :: & character(len=65536) :: &
@ -150,29 +149,29 @@ subroutine kinematics_cleavage_opening_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_cleavage_opening_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_cleavage_opening_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = kinematics_cleavage_opening_instance(phase) ! which instance of my damage is present phase instance = kinematics_cleavage_opening_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('anisobrittle_sdot0') case ('anisobrittle_sdot0')
kinematics_cleavage_opening_sdot_0(instance) = IO_floatValue(line,positions,2_pInt) kinematics_cleavage_opening_sdot_0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisobrittle_ratesensitivity') case ('anisobrittle_ratesensitivity')
kinematics_cleavage_opening_N(instance) = IO_floatValue(line,positions,2_pInt) kinematics_cleavage_opening_N(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('ncleavage') ! case ('ncleavage') !
Nchunks_CleavageFamilies = positions(1) - 1_pInt Nchunks_CleavageFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_CleavageFamilies do j = 1_pInt, Nchunks_CleavageFamilies
kinematics_cleavage_opening_Ncleavage(j,instance) = IO_intValue(line,positions,1_pInt+j) kinematics_cleavage_opening_Ncleavage(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisobrittle_criticaldisplacement') case ('anisobrittle_criticaldisplacement')
do j = 1_pInt, Nchunks_CleavageFamilies do j = 1_pInt, Nchunks_CleavageFamilies
kinematics_cleavage_opening_critDisp(j,instance) = IO_floatValue(line,positions,1_pInt+j) kinematics_cleavage_opening_critDisp(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisobrittle_criticalload') case ('anisobrittle_criticalload')
do j = 1_pInt, Nchunks_CleavageFamilies do j = 1_pInt, Nchunks_CleavageFamilies
kinematics_cleavage_opening_critLoad(j,instance) = IO_floatValue(line,positions,1_pInt+j) kinematics_cleavage_opening_critLoad(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
end select end select

9
code/kinematics_hydrogen_strain.f90
View File

@ -75,8 +75,7 @@ subroutine kinematics_hydrogen_strain_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,kinematics integer(pInt) :: maxNinstance,phase,instance,kinematics
character(len=65536) :: & character(len=65536) :: &
tag = '', & tag = '', &
@ -131,11 +130,11 @@ subroutine kinematics_hydrogen_strain_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_hydrogen_strain_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_hydrogen_strain_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = kinematics_hydrogen_strain_instance(phase) ! which instance of my damage is present phase instance = kinematics_hydrogen_strain_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('hydrogen_strain_coeff') case ('hydrogen_strain_coeff')
kinematics_hydrogen_strain_coeff(instance) = IO_floatValue(line,positions,2_pInt) kinematics_hydrogen_strain_coeff(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

19
code/kinematics_slipplane_opening.f90
View File

@ -88,8 +88,7 @@ subroutine kinematics_slipplane_opening_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,kinematics integer(pInt) :: maxNinstance,phase,instance,kinematics
integer(pInt) :: Nchunks_SlipFamilies = 0_pInt, j integer(pInt) :: Nchunks_SlipFamilies = 0_pInt, j
character(len=65536) :: & character(len=65536) :: &
@ -150,29 +149,29 @@ subroutine kinematics_slipplane_opening_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_slipplane_opening_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_slipplane_opening_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = kinematics_slipplane_opening_instance(phase) ! which instance of my damage is present phase instance = kinematics_slipplane_opening_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('nslip') ! case ('nslip') !
Nchunks_SlipFamilies = positions(1) - 1_pInt Nchunks_SlipFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
kinematics_slipplane_opening_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) kinematics_slipplane_opening_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisoductile_sdot0') case ('anisoductile_sdot0')
kinematics_slipplane_opening_sdot_0(instance) = IO_floatValue(line,positions,2_pInt) kinematics_slipplane_opening_sdot_0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisoductile_criticalplasticstrain') case ('anisoductile_criticalplasticstrain')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
kinematics_slipplane_opening_critPlasticStrain(j,instance) = IO_floatValue(line,positions,1_pInt+j) kinematics_slipplane_opening_critPlasticStrain(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisoductile_ratesensitivity') case ('anisoductile_ratesensitivity')
kinematics_slipplane_opening_N(instance) = IO_floatValue(line,positions,2_pInt) kinematics_slipplane_opening_N(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisoductile_criticalload') case ('anisoductile_criticalload')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
kinematics_slipplane_opening_critLoad(j,instance) = IO_floatValue(line,positions,1_pInt+j) kinematics_slipplane_opening_critLoad(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
end select end select

9
code/kinematics_thermal_expansion.f90
View File

@ -75,8 +75,7 @@ subroutine kinematics_thermal_expansion_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,kinematics integer(pInt) :: maxNinstance,phase,instance,kinematics
character(len=65536) :: & character(len=65536) :: &
tag = '', & tag = '', &
@ -131,11 +130,11 @@ subroutine kinematics_thermal_expansion_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_thermal_expansion_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_thermal_expansion_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = kinematics_thermal_expansion_instance(phase) ! which instance of my damage is present phase instance = kinematics_thermal_expansion_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key... tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key...
select case(tag) select case(tag)
! case ('(output)') ! case ('(output)')
! output = IO_lc(IO_stringValue(line,positions,2_pInt)) ! ...and corresponding output ! output = IO_lc(IO_stringValue(line,chunkPos,2_pInt)) ! ...and corresponding output
! select case(output) ! select case(output)
! case ('thermalexpansionrate') ! case ('thermalexpansionrate')
! kinematics_thermal_expansion_Noutput(instance) = kinematics_thermal_expansion_Noutput(instance) + 1_pInt ! kinematics_thermal_expansion_Noutput(instance) = kinematics_thermal_expansion_Noutput(instance) + 1_pInt

9
code/kinematics_vacancy_strain.f90
View File

@ -75,8 +75,7 @@ subroutine kinematics_vacancy_strain_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,kinematics integer(pInt) :: maxNinstance,phase,instance,kinematics
character(len=65536) :: & character(len=65536) :: &
tag = '', & tag = '', &
@ -131,11 +130,11 @@ subroutine kinematics_vacancy_strain_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_vacancy_strain_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_kinematics(:,phase) == KINEMATICS_vacancy_strain_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = kinematics_vacancy_strain_instance(phase) ! which instance of my damage is present phase instance = kinematics_vacancy_strain_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('vacancy_strain_coeff') case ('vacancy_strain_coeff')
kinematics_vacancy_strain_coeff(instance) = IO_floatValue(line,positions,2_pInt) kinematics_vacancy_strain_coeff(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

133
code/lattice.f90
View File

@ -1186,10 +1186,8 @@ subroutine lattice_init
IO_open_file,& IO_open_file,&
IO_open_jobFile_stat, & IO_open_jobFile_stat, &
IO_countSections, & IO_countSections, &
IO_countTagInPart, &
IO_error, & IO_error, &
IO_timeStamp, & IO_timeStamp, &
IO_stringPos, &
IO_EOF, & IO_EOF, &
IO_read, & IO_read, &
IO_lc, & IO_lc, &
@ -1215,8 +1213,7 @@ subroutine lattice_init
character(len=65536) :: & character(len=65536) :: &
tag = '', & tag = '', &
line = '' line = ''
integer(pInt), parameter :: MAXNCHUNKS = 2_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: section = 0_pInt,i integer(pInt) :: section = 0_pInt,i
real(pReal), dimension(:), allocatable :: & real(pReal), dimension(:), allocatable :: &
CoverA, & !!!!!!< c/a ratio for low symmetry type lattice CoverA, & !!!!!!< c/a ratio for low symmetry type lattice
@ -1410,11 +1407,11 @@ subroutine lattice_init
section = section + 1_pInt section = section + 1_pInt
endif endif
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('lattice_structure') case ('lattice_structure')
select case(trim(IO_lc(IO_stringValue(line,positions,2_pInt)))) select case(trim(IO_lc(IO_stringValue(line,chunkPos,2_pInt))))
case('iso','isotropic') case('iso','isotropic')
lattice_structure(section) = LATTICE_iso_ID lattice_structure(section) = LATTICE_iso_ID
case('fcc') case('fcc')
@ -1428,133 +1425,133 @@ subroutine lattice_init
case('ort','orthorhombic') case('ort','orthorhombic')
lattice_structure(section) = LATTICE_ort_ID lattice_structure(section) = LATTICE_ort_ID
case default case default
call IO_error(130_pInt,ext_msg=trim(IO_lc(IO_stringValue(line,positions,2_pInt)))) call IO_error(130_pInt,ext_msg=trim(IO_lc(IO_stringValue(line,chunkPos,2_pInt))))
end select end select
case('trans_lattice_structure') case('trans_lattice_structure')
select case(trim(IO_lc(IO_stringValue(line,positions,2_pInt)))) select case(trim(IO_lc(IO_stringValue(line,chunkPos,2_pInt))))
case('bcc') case('bcc')
trans_lattice_structure(section) = LATTICE_bcc_ID trans_lattice_structure(section) = LATTICE_bcc_ID
case('hex','hexagonal','hcp') case('hex','hexagonal','hcp')
trans_lattice_structure(section) = LATTICE_hex_ID trans_lattice_structure(section) = LATTICE_hex_ID
end select end select
case ('c11') case ('c11')
lattice_C66(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c12') case ('c12')
lattice_C66(1,2,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(1,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c13') case ('c13')
lattice_C66(1,3,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(1,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c22') case ('c22')
lattice_C66(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c23') case ('c23')
lattice_C66(2,3,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(2,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c33') case ('c33')
lattice_C66(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c44') case ('c44')
lattice_C66(4,4,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(4,4,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c55') case ('c55')
lattice_C66(5,5,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(5,5,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c66') case ('c66')
lattice_C66(6,6,section) = IO_floatValue(line,positions,2_pInt) lattice_C66(6,6,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c11_trans') case ('c11_trans')
lattice_trans_C66(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c12_trans') case ('c12_trans')
lattice_trans_C66(1,2,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(1,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c13_trans') case ('c13_trans')
lattice_trans_C66(1,3,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(1,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c22_trans') case ('c22_trans')
lattice_trans_C66(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c23_trans') case ('c23_trans')
lattice_trans_C66(2,3,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(2,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c33_trans') case ('c33_trans')
lattice_trans_C66(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c44_trans') case ('c44_trans')
lattice_trans_C66(4,4,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(4,4,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c55_trans') case ('c55_trans')
lattice_trans_C66(5,5,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(5,5,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c66_trans') case ('c66_trans')
lattice_trans_C66(6,6,section) = IO_floatValue(line,positions,2_pInt) lattice_trans_C66(6,6,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('covera_ratio','c/a_ratio','c/a') case ('covera_ratio','c/a_ratio','c/a')
CoverA(section) = IO_floatValue(line,positions,2_pInt) CoverA(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('c/a_trans','c/a_martensite','c/a_mart') case ('c/a_trans','c/a_martensite','c/a_mart')
CoverA_trans(section) = IO_floatValue(line,positions,2_pInt) CoverA_trans(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('a_fcc') case ('a_fcc')
a_fcc(section) = IO_floatValue(line,positions,2_pInt) a_fcc(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('a_bcc') case ('a_bcc')
a_bcc(section) = IO_floatValue(line,positions,2_pInt) a_bcc(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('thermal_conductivity11') case ('thermal_conductivity11')
lattice_thermalConductivity33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_thermalConductivity33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('thermal_conductivity22') case ('thermal_conductivity22')
lattice_thermalConductivity33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_thermalConductivity33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('thermal_conductivity33') case ('thermal_conductivity33')
lattice_thermalConductivity33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_thermalConductivity33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('thermal_expansion11') case ('thermal_expansion11')
lattice_thermalExpansion33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_thermalExpansion33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('thermal_expansion22') case ('thermal_expansion22')
lattice_thermalExpansion33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_thermalExpansion33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('thermal_expansion33') case ('thermal_expansion33')
lattice_thermalExpansion33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_thermalExpansion33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('specific_heat') case ('specific_heat')
lattice_specificHeat(section) = IO_floatValue(line,positions,2_pInt) lattice_specificHeat(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyformationenergy') case ('vacancyformationenergy')
lattice_vacancyFormationEnergy(section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyFormationEnergy(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancysurfaceenergy') case ('vacancysurfaceenergy')
lattice_vacancySurfaceEnergy(section) = IO_floatValue(line,positions,2_pInt) lattice_vacancySurfaceEnergy(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyvolume') case ('vacancyvolume')
lattice_vacancyVol(section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyVol(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenformationenergy') case ('hydrogenformationenergy')
lattice_hydrogenFormationEnergy(section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenFormationEnergy(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogensurfaceenergy') case ('hydrogensurfaceenergy')
lattice_hydrogenSurfaceEnergy(section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenSurfaceEnergy(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenvolume') case ('hydrogenvolume')
lattice_hydrogenVol(section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenVol(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('mass_density') case ('mass_density')
lattice_massDensity(section) = IO_floatValue(line,positions,2_pInt) lattice_massDensity(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('reference_temperature') case ('reference_temperature')
lattice_referenceTemperature(section) = IO_floatValue(line,positions,2_pInt) lattice_referenceTemperature(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('damage_diffusion11') case ('damage_diffusion11')
lattice_DamageDiffusion33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_DamageDiffusion33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('damage_diffusion22') case ('damage_diffusion22')
lattice_DamageDiffusion33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_DamageDiffusion33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('damage_diffusion33') case ('damage_diffusion33')
lattice_DamageDiffusion33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_DamageDiffusion33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('damage_mobility') case ('damage_mobility')
lattice_DamageMobility(section) = IO_floatValue(line,positions,2_pInt) lattice_DamageMobility(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyflux_diffusion11') case ('vacancyflux_diffusion11')
lattice_vacancyfluxDiffusion33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyfluxDiffusion33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyflux_diffusion22') case ('vacancyflux_diffusion22')
lattice_vacancyfluxDiffusion33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyfluxDiffusion33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyflux_diffusion33') case ('vacancyflux_diffusion33')
lattice_vacancyfluxDiffusion33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyfluxDiffusion33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyflux_mobility11') case ('vacancyflux_mobility11')
lattice_vacancyfluxMobility33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyfluxMobility33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyflux_mobility22') case ('vacancyflux_mobility22')
lattice_vacancyfluxMobility33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyfluxMobility33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyflux_mobility33') case ('vacancyflux_mobility33')
lattice_vacancyfluxMobility33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_vacancyfluxMobility33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('porosity_diffusion11') case ('porosity_diffusion11')
lattice_PorosityDiffusion33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_PorosityDiffusion33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('porosity_diffusion22') case ('porosity_diffusion22')
lattice_PorosityDiffusion33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_PorosityDiffusion33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('porosity_diffusion33') case ('porosity_diffusion33')
lattice_PorosityDiffusion33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_PorosityDiffusion33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('porosity_mobility') case ('porosity_mobility')
lattice_PorosityMobility(section) = IO_floatValue(line,positions,2_pInt) lattice_PorosityMobility(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenflux_diffusion11') case ('hydrogenflux_diffusion11')
lattice_hydrogenfluxDiffusion33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenfluxDiffusion33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenflux_diffusion22') case ('hydrogenflux_diffusion22')
lattice_hydrogenfluxDiffusion33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenfluxDiffusion33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenflux_diffusion33') case ('hydrogenflux_diffusion33')
lattice_hydrogenfluxDiffusion33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenfluxDiffusion33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenflux_mobility11') case ('hydrogenflux_mobility11')
lattice_hydrogenfluxMobility33(1,1,section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenfluxMobility33(1,1,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenflux_mobility22') case ('hydrogenflux_mobility22')
lattice_hydrogenfluxMobility33(2,2,section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenfluxMobility33(2,2,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenflux_mobility33') case ('hydrogenflux_mobility33')
lattice_hydrogenfluxMobility33(3,3,section) = IO_floatValue(line,positions,2_pInt) lattice_hydrogenfluxMobility33(3,3,section) = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancy_eqcv') case ('vacancy_eqcv')
lattice_equilibriumVacancyConcentration(section) = IO_floatValue(line,positions,2_pInt) lattice_equilibriumVacancyConcentration(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogen_eqch') case ('hydrogen_eqch')
lattice_equilibriumHydrogenConcentration(section) = IO_floatValue(line,positions,2_pInt) lattice_equilibriumHydrogenConcentration(section) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif endif
enddo enddo

3
code/libs.f90
View File

@ -8,9 +8,6 @@ module libs
!nothing in here !nothing in here
end module libs end module libs
#if defined(Spectral) || defined(FEM)
#include "../lib/kdtree2.f90"
#endif
#include "../lib/IR_Precision.f90" #include "../lib/IR_Precision.f90"
#include "../lib/Lib_Base64.f90" #include "../lib/Lib_Base64.f90"
#include "../lib/Lib_VTK_IO.f90" #include "../lib/Lib_VTK_IO.f90"

126
code/material.f90
View File

@ -561,9 +561,8 @@ subroutine material_parseHomogenization(fileUnit,myPart)
character(len=*), intent(in) :: myPart character(len=*), intent(in) :: myPart
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 2_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: Nsections, section, s, p integer(pInt) :: Nsections, section, s, p
character(len=65536) :: & character(len=65536) :: &
tag, line tag, line
@ -620,11 +619,11 @@ subroutine material_parseHomogenization(fileUnit,myPart)
homogenization_name(section) = IO_getTag(line,'[',']') homogenization_name(section) = IO_getTag(line,'[',']')
endif endif
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('type') case ('type')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case(HOMOGENIZATION_NONE_label) case(HOMOGENIZATION_NONE_label)
homogenization_type(section) = HOMOGENIZATION_NONE_ID homogenization_type(section) = HOMOGENIZATION_NONE_ID
homogenization_Ngrains(section) = 1_pInt homogenization_Ngrains(section) = 1_pInt
@ -633,12 +632,12 @@ subroutine material_parseHomogenization(fileUnit,myPart)
case(HOMOGENIZATION_RGC_label) case(HOMOGENIZATION_RGC_label)
homogenization_type(section) = HOMOGENIZATION_RGC_ID homogenization_type(section) = HOMOGENIZATION_RGC_ID
case default case default
call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
homogenization_typeInstance(section) = & homogenization_typeInstance(section) = &
count(homogenization_type==homogenization_type(section)) ! count instances count(homogenization_type==homogenization_type(section)) ! count instances
case ('thermal') case ('thermal')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case(THERMAL_isothermal_label) case(THERMAL_isothermal_label)
thermal_type(section) = THERMAL_isothermal_ID thermal_type(section) = THERMAL_isothermal_ID
case(THERMAL_adiabatic_label) case(THERMAL_adiabatic_label)
@ -646,11 +645,11 @@ subroutine material_parseHomogenization(fileUnit,myPart)
case(THERMAL_conduction_label) case(THERMAL_conduction_label)
thermal_type(section) = THERMAL_conduction_ID thermal_type(section) = THERMAL_conduction_ID
case default case default
call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('damage') case ('damage')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case(DAMAGE_NONE_label) case(DAMAGE_NONE_label)
damage_type(section) = DAMAGE_none_ID damage_type(section) = DAMAGE_none_ID
case(DAMAGE_LOCAL_label) case(DAMAGE_LOCAL_label)
@ -658,11 +657,11 @@ subroutine material_parseHomogenization(fileUnit,myPart)
case(DAMAGE_NONLOCAL_label) case(DAMAGE_NONLOCAL_label)
damage_type(section) = DAMAGE_nonlocal_ID damage_type(section) = DAMAGE_nonlocal_ID
case default case default
call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('vacancyflux') case ('vacancyflux')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case(VACANCYFLUX_isoconc_label) case(VACANCYFLUX_isoconc_label)
vacancyflux_type(section) = VACANCYFLUX_isoconc_ID vacancyflux_type(section) = VACANCYFLUX_isoconc_ID
case(VACANCYFLUX_isochempot_label) case(VACANCYFLUX_isochempot_label)
@ -670,46 +669,46 @@ subroutine material_parseHomogenization(fileUnit,myPart)
case(VACANCYFLUX_cahnhilliard_label) case(VACANCYFLUX_cahnhilliard_label)
vacancyflux_type(section) = VACANCYFLUX_cahnhilliard_ID vacancyflux_type(section) = VACANCYFLUX_cahnhilliard_ID
case default case default
call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('porosity') case ('porosity')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case(POROSITY_NONE_label) case(POROSITY_NONE_label)
porosity_type(section) = POROSITY_none_ID porosity_type(section) = POROSITY_none_ID
case(POROSITY_phasefield_label) case(POROSITY_phasefield_label)
porosity_type(section) = POROSITY_phasefield_ID porosity_type(section) = POROSITY_phasefield_ID
case default case default
call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('hydrogenflux') case ('hydrogenflux')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case(HYDROGENFLUX_isoconc_label) case(HYDROGENFLUX_isoconc_label)
hydrogenflux_type(section) = HYDROGENFLUX_isoconc_ID hydrogenflux_type(section) = HYDROGENFLUX_isoconc_ID
case(HYDROGENFLUX_cahnhilliard_label) case(HYDROGENFLUX_cahnhilliard_label)
hydrogenflux_type(section) = HYDROGENFLUX_cahnhilliard_ID hydrogenflux_type(section) = HYDROGENFLUX_cahnhilliard_ID
case default case default
call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(500_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('nconstituents','ngrains') case ('nconstituents','ngrains')
homogenization_Ngrains(section) = IO_intValue(line,positions,2_pInt) homogenization_Ngrains(section) = IO_intValue(line,chunkPos,2_pInt)
case ('initialtemperature','initialt') case ('initialtemperature','initialt')
thermal_initialT(section) = IO_floatValue(line,positions,2_pInt) thermal_initialT(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('initialdamage') case ('initialdamage')
damage_initialPhi(section) = IO_floatValue(line,positions,2_pInt) damage_initialPhi(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('initialvacancyconc','initialcv') case ('initialvacancyconc','initialcv')
vacancyflux_initialCv(section) = IO_floatValue(line,positions,2_pInt) vacancyflux_initialCv(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('initialporosity') case ('initialporosity')
porosity_initialPhi(section) = IO_floatValue(line,positions,2_pInt) porosity_initialPhi(section) = IO_floatValue(line,chunkPos,2_pInt)
case ('initialhydrogenconc','initialch') case ('initialhydrogenconc','initialch')
hydrogenflux_initialCh(section) = IO_floatValue(line,positions,2_pInt) hydrogenflux_initialCh(section) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif endif
@ -742,9 +741,8 @@ subroutine material_parseMicrostructure(fileUnit,myPart)
character(len=*), intent(in) :: myPart character(len=*), intent(in) :: myPart
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: Nsections, section, constituent, e, i integer(pInt) :: Nsections, section, constituent, e, i
character(len=65536) :: & character(len=65536) :: &
tag, line tag, line
@ -799,22 +797,22 @@ subroutine material_parseMicrostructure(fileUnit,myPart)
microstructure_name(section) = IO_getTag(line,'[',']') microstructure_name(section) = IO_getTag(line,'[',']')
endif endif
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('crystallite') case ('crystallite')
microstructure_crystallite(section) = IO_intValue(line,positions,2_pInt) microstructure_crystallite(section) = IO_intValue(line,chunkPos,2_pInt)
case ('(constituent)') case ('(constituent)')
constituent = constituent + 1_pInt constituent = constituent + 1_pInt
do i=2_pInt,6_pInt,2_pInt do i=2_pInt,6_pInt,2_pInt
tag = IO_lc(IO_stringValue(line,positions,i)) tag = IO_lc(IO_stringValue(line,chunkPos,i))
select case (tag) select case (tag)
case('phase') case('phase')
microstructure_phase(constituent,section) = IO_intValue(line,positions,i+1_pInt) microstructure_phase(constituent,section) = IO_intValue(line,chunkPos,i+1_pInt)
case('texture') case('texture')
microstructure_texture(constituent,section) = IO_intValue(line,positions,i+1_pInt) microstructure_texture(constituent,section) = IO_intValue(line,chunkPos,i+1_pInt)
case('fraction') case('fraction')
microstructure_fraction(constituent,section) = IO_floatValue(line,positions,i+1_pInt) microstructure_fraction(constituent,section) = IO_floatValue(line,chunkPos,i+1_pInt)
end select end select
enddo enddo
end select end select
@ -906,9 +904,8 @@ subroutine material_parsePhase(fileUnit,myPart)
character(len=*), intent(in) :: myPart character(len=*), intent(in) :: myPart
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 2_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: Nsections, section, sourceCtr, kinematicsCtr, stiffDegradationCtr, p integer(pInt) :: Nsections, section, sourceCtr, kinematicsCtr, stiffDegradationCtr, p
character(len=65536) :: & character(len=65536) :: &
tag,line tag,line
@ -966,18 +963,18 @@ subroutine material_parsePhase(fileUnit,myPart)
phase_name(section) = IO_getTag(line,'[',']') phase_name(section) = IO_getTag(line,'[',']')
endif endif
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('elasticity') case ('elasticity')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case (ELASTICITY_HOOKE_label) case (ELASTICITY_HOOKE_label)
phase_elasticity(section) = ELASTICITY_HOOKE_ID phase_elasticity(section) = ELASTICITY_HOOKE_ID
case default case default
call IO_error(200_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(200_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('plasticity') case ('plasticity')
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case (PLASTICITY_NONE_label) case (PLASTICITY_NONE_label)
phase_plasticity(section) = PLASTICITY_NONE_ID phase_plasticity(section) = PLASTICITY_NONE_ID
case (PLASTICITY_J2_label) case (PLASTICITY_J2_label)
@ -995,11 +992,11 @@ subroutine material_parsePhase(fileUnit,myPart)
case (PLASTICITY_NONLOCAL_label) case (PLASTICITY_NONLOCAL_label)
phase_plasticity(section) = PLASTICITY_NONLOCAL_ID phase_plasticity(section) = PLASTICITY_NONLOCAL_ID
case default case default
call IO_error(201_pInt,ext_msg=trim(IO_stringValue(line,positions,2_pInt))) call IO_error(201_pInt,ext_msg=trim(IO_stringValue(line,chunkPos,2_pInt)))
end select end select
case ('(source)') case ('(source)')
sourceCtr = sourceCtr + 1_pInt sourceCtr = sourceCtr + 1_pInt
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case (SOURCE_thermal_dissipation_label) case (SOURCE_thermal_dissipation_label)
phase_source(sourceCtr,section) = SOURCE_thermal_dissipation_ID phase_source(sourceCtr,section) = SOURCE_thermal_dissipation_ID
case (SOURCE_thermal_externalheat_label) case (SOURCE_thermal_externalheat_label)
@ -1021,7 +1018,7 @@ subroutine material_parsePhase(fileUnit,myPart)
end select end select
case ('(kinematics)') case ('(kinematics)')
kinematicsCtr = kinematicsCtr + 1_pInt kinematicsCtr = kinematicsCtr + 1_pInt
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case (KINEMATICS_cleavage_opening_label) case (KINEMATICS_cleavage_opening_label)
phase_kinematics(kinematicsCtr,section) = KINEMATICS_cleavage_opening_ID phase_kinematics(kinematicsCtr,section) = KINEMATICS_cleavage_opening_ID
case (KINEMATICS_slipplane_opening_label) case (KINEMATICS_slipplane_opening_label)
@ -1035,7 +1032,7 @@ subroutine material_parsePhase(fileUnit,myPart)
end select end select
case ('(stiffness_degradation)') case ('(stiffness_degradation)')
stiffDegradationCtr = stiffDegradationCtr + 1_pInt stiffDegradationCtr = stiffDegradationCtr + 1_pInt
select case (IO_lc(IO_stringValue(line,positions,2_pInt))) select case (IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case (STIFFNESS_DEGRADATION_damage_label) case (STIFFNESS_DEGRADATION_damage_label)
phase_stiffnessDegradation(stiffDegradationCtr,section) = STIFFNESS_DEGRADATION_damage_ID phase_stiffnessDegradation(stiffDegradationCtr,section) = STIFFNESS_DEGRADATION_damage_ID
case (STIFFNESS_DEGRADATION_porosity_label) case (STIFFNESS_DEGRADATION_porosity_label)
@ -1081,9 +1078,8 @@ subroutine material_parseTexture(fileUnit,myPart)
character(len=*), intent(in) :: myPart character(len=*), intent(in) :: myPart
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 13_pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: Nsections, section, gauss, fiber, j integer(pInt) :: Nsections, section, gauss, fiber, j
character(len=65536) :: tag character(len=65536) :: tag
character(len=65536) :: line character(len=65536) :: line
@ -1136,13 +1132,13 @@ subroutine material_parseTexture(fileUnit,myPart)
texture_name(section) = IO_getTag(line,'[',']') texture_name(section) = IO_getTag(line,'[',']')
endif endif
if (section > 0_pInt) then if (section > 0_pInt) then
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
textureType: select case(tag) textureType: select case(tag)
case ('axes', 'rotation') textureType case ('axes', 'rotation') textureType
do j = 1_pInt, 3_pInt ! look for "x", "y", and "z" entries do j = 1_pInt, 3_pInt ! look for "x", "y", and "z" entries
tag = IO_lc(IO_stringValue(line,positions,j+1_pInt)) tag = IO_lc(IO_stringValue(line,chunkPos,j+1_pInt))
select case (tag) select case (tag)
case('x', '+x') case('x', '+x')
texture_transformation(j,1:3,section) = [ 1.0_pReal, 0.0_pReal, 0.0_pReal] ! original axis is now +x-axis texture_transformation(j,1:3,section) = [ 1.0_pReal, 0.0_pReal, 0.0_pReal] ! original axis is now +x-axis
@ -1162,10 +1158,10 @@ subroutine material_parseTexture(fileUnit,myPart)
enddo enddo
case ('hybridia') textureType case ('hybridia') textureType
texture_ODFfile(section) = IO_stringValue(line,positions,2_pInt) texture_ODFfile(section) = IO_stringValue(line,chunkPos,2_pInt)
case ('symmetry') textureType case ('symmetry') textureType
tag = IO_lc(IO_stringValue(line,positions,2_pInt)) tag = IO_lc(IO_stringValue(line,chunkPos,2_pInt))
select case (tag) select case (tag)
case('orthotropic') case('orthotropic')
texture_symmetry(section) = 4_pInt texture_symmetry(section) = 4_pInt
@ -1179,50 +1175,50 @@ subroutine material_parseTexture(fileUnit,myPart)
gauss = gauss + 1_pInt gauss = gauss + 1_pInt
texture_Gauss(1:3,gauss,section) = math_sampleRandomOri() texture_Gauss(1:3,gauss,section) = math_sampleRandomOri()
do j = 2_pInt,4_pInt,2_pInt do j = 2_pInt,4_pInt,2_pInt
tag = IO_lc(IO_stringValue(line,positions,j)) tag = IO_lc(IO_stringValue(line,chunkPos,j))
select case (tag) select case (tag)
case('scatter') case('scatter')
texture_Gauss(4,gauss,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Gauss(4,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('fraction') case('fraction')
texture_Gauss(5,gauss,section) = IO_floatValue(line,positions,j+1_pInt) texture_Gauss(5,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)
end select end select
enddo enddo
case ('(gauss)') textureType case ('(gauss)') textureType
gauss = gauss + 1_pInt gauss = gauss + 1_pInt
do j = 2_pInt,10_pInt,2_pInt do j = 2_pInt,10_pInt,2_pInt
tag = IO_lc(IO_stringValue(line,positions,j)) tag = IO_lc(IO_stringValue(line,chunkPos,j))
select case (tag) select case (tag)
case('phi1') case('phi1')
texture_Gauss(1,gauss,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Gauss(1,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('phi') case('phi')
texture_Gauss(2,gauss,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Gauss(2,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('phi2') case('phi2')
texture_Gauss(3,gauss,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Gauss(3,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('scatter') case('scatter')
texture_Gauss(4,gauss,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Gauss(4,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('fraction') case('fraction')
texture_Gauss(5,gauss,section) = IO_floatValue(line,positions,j+1_pInt) texture_Gauss(5,gauss,section) = IO_floatValue(line,chunkPos,j+1_pInt)
end select end select
enddo enddo
case ('(fiber)') textureType case ('(fiber)') textureType
fiber = fiber + 1_pInt fiber = fiber + 1_pInt
do j = 2_pInt,12_pInt,2_pInt do j = 2_pInt,12_pInt,2_pInt
tag = IO_lc(IO_stringValue(line,positions,j)) tag = IO_lc(IO_stringValue(line,chunkPos,j))
select case (tag) select case (tag)
case('alpha1') case('alpha1')
texture_Fiber(1,fiber,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Fiber(1,fiber,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('alpha2') case('alpha2')
texture_Fiber(2,fiber,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Fiber(2,fiber,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('beta1') case('beta1')
texture_Fiber(3,fiber,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Fiber(3,fiber,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('beta2') case('beta2')
texture_Fiber(4,fiber,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Fiber(4,fiber,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('scatter') case('scatter')
texture_Fiber(5,fiber,section) = IO_floatValue(line,positions,j+1_pInt)*inRad texture_Fiber(5,fiber,section) = IO_floatValue(line,chunkPos,j+1_pInt)*inRad
case('fraction') case('fraction')
texture_Fiber(6,fiber,section) = IO_floatValue(line,positions,j+1_pInt) texture_Fiber(6,fiber,section) = IO_floatValue(line,chunkPos,j+1_pInt)
end select end select
enddo enddo

147
code/math.f90
View File

@ -178,10 +178,7 @@ module math
fftw_execute_dft_r2c, & fftw_execute_dft_r2c, &
fftw_execute_dft_c2r, & fftw_execute_dft_c2r, &
fftw_destroy_plan, & fftw_destroy_plan, &
math_tensorAvg, & math_tensorAvg
math_periodicNearestNeighbor, &
math_nearestNeighbor, &
math_periodicNearestNeighborDistances
#endif #endif
private :: & private :: &
math_partition, & math_partition, &
@ -2721,148 +2718,6 @@ pure function math_rotate_forward3333(tensor,rot_tensor)
end function math_rotate_forward3333 end function math_rotate_forward3333
#ifdef Spectral
!--------------------------------------------------------------------------------------------------
!> @brief Obtain the nearest neighbor from periodic domainSet at points in querySet
!--------------------------------------------------------------------------------------------------
function math_periodicNearestNeighbor(geomdim, Favg, querySet, domainSet)
use kdtree2_module
use IO, only: &
IO_error
implicit none
real(pReal), dimension(3,3), intent(in) :: Favg
real(pReal), dimension(3), intent(in) :: geomdim
real(pReal), dimension(:,:), intent(in) :: querySet
real(pReal), dimension(:,:), intent(in) :: domainSet
integer(pInt), dimension(size(querySet,2)) :: math_periodicNearestNeighbor
real(pReal), dimension(size(domainSet,1),(3_pInt**size(domainSet,1))*size(domainSet,2)) :: &
domainSetLarge
integer(pInt) :: i,j, l,m,n, spatialDim
type(kdtree2), pointer :: tree
type(kdtree2_result), dimension(1) :: Results
if (size(querySet,1) /= size(domainSet,1)) call IO_error(407_pInt,ext_msg='query set')
spatialDim = size(querySet,1)
i = 0_pInt
if(spatialDim == 2_pInt) then
do j = 1_pInt, size(domainSet,2)
do l = -1_pInt, 1_pInt; do m = -1_pInt, 1_pInt
i = i + 1_pInt
domainSetLarge(1:2,i) = domainSet(1:2,j) +matmul(Favg(1:2,1:2),real([l,m],pReal)*geomdim(1:2))
enddo; enddo
enddo
else
do j = 1_pInt, size(domainSet,2)
do l = -1_pInt, 1_pInt; do m = -1_pInt, 1_pInt; do n = -1_pInt, 1_pInt
i = i + 1_pInt
domainSetLarge(1:3,i) = domainSet(1:3,j) + math_mul33x3(Favg,real([l,m,n],pReal)*geomdim)
enddo; enddo; enddo
enddo
endif
tree => kdtree2_create(domainSetLarge,sort=.true.,rearrange=.true.)
do j = 1_pInt, size(querySet,2)
call kdtree2_n_nearest(tp=tree, qv=querySet(1:spatialDim,j),nn=1_pInt, results = Results)
math_periodicNearestNeighbor(j) = Results(1)%idx
enddo
math_periodicNearestNeighbor = math_periodicNearestNeighbor -1_pInt ! let them run from 0 to domainPoints -1
end function math_periodicNearestNeighbor
!--------------------------------------------------------------------------------------------------
!> @brief Obtain the nearest neighbor from domainSet at points in querySet
!--------------------------------------------------------------------------------------------------
function math_nearestNeighbor(querySet, domainSet)
use kdtree2_module
use IO, only: &
IO_error
implicit none
real(pReal), dimension(:,:), intent(in) :: querySet
real(pReal), dimension(:,:), intent(in) :: domainSet
integer(pInt), dimension(size(querySet,2)) :: math_nearestNeighbor
integer(pInt) :: j, spatialDim
type(kdtree2), pointer :: tree
type(kdtree2_result), dimension(1) :: Results
if (size(querySet,1) /= size(domainSet,1)) call IO_error(407_pInt,ext_msg='query set')
spatialDim = size(querySet,1)
tree => kdtree2_create(domainSet,sort=.true.,rearrange=.true.)
do j = 1_pInt, size(querySet,2)
call kdtree2_n_nearest(tp=tree, qv=querySet(1:spatialDim,j),nn=1_pInt, results = Results)
math_nearestNeighbor(j) = Results(1)%idx
enddo
math_nearestNeighbor = math_nearestNeighbor -1_pInt ! let them run from 0 to domainPoints -1
end function math_nearestNeighbor
!--------------------------------------------------------------------------------------------------
!> @brief Obtain the distances to the next N nearest neighbors from domainSet at points in querySet
!--------------------------------------------------------------------------------------------------
function math_periodicNearestNeighborDistances(geomdim, Favg, querySet, domainSet, Ndist) result(distances)
use kdtree2_module
use IO, only: &
IO_error
implicit none
real(pReal), dimension(3), intent(in) :: geomdim
real(pReal), dimension(3,3), intent(in) :: Favg
integer(pInt), intent(in) :: Ndist
real(pReal), dimension(:,:), intent(in) :: querySet
real(pReal), dimension(:,:), intent(in) :: domainSet
! output variable
real(pReal), dimension(Ndist,size(querySet,2)) :: distances
real(pReal), dimension(size(domainSet,1),(3_pInt**size(domainSet,1))*size(domainSet,2)) &
:: domainSetLarge
integer(pInt) :: i,j, l,m,n, spatialDim
type(kdtree2), pointer :: tree
type(kdtree2_result), dimension(:), allocatable :: Results
allocate(Results(Ndist))
if (size(querySet,1) /= size(domainSet,1)) call IO_error(407_pInt,ext_msg='query set')
spatialDim = size(querySet,1)
i = 0_pInt
if(spatialDim == 2_pInt) then
do j = 1_pInt, size(domainSet,2)
do l = -1_pInt, 1_pInt; do m = -1_pInt, 1_pInt
i = i + 1_pInt
domainSetLarge(1:2,i) = domainSet(1:2,j) +matmul(Favg(1:2,1:2),real([l,m],pReal)*geomdim(1:2))
enddo; enddo
enddo
else
do j = 1_pInt, size(domainSet,2)
do l = -1_pInt, 1_pInt; do m = -1_pInt, 1_pInt; do n = -1_pInt, 1_pInt
i = i + 1_pInt
domainSetLarge(1:3,i) = domainSet(1:3,j) + math_mul33x3(Favg,real([l,m,n],pReal)*geomdim)
enddo; enddo; enddo
enddo
endif
tree => kdtree2_create(domainSetLarge,sort=.true.,rearrange=.true.)
do j = 1_pInt, size(querySet,2)
call kdtree2_n_nearest(tp=tree, qv=querySet(1:spatialDim,j),nn=Ndist, results = Results)
distances(1:Ndist,j) = sqrt(Results(1:Ndist)%dis)
enddo
deallocate(Results)
end function math_periodicNearestNeighborDistances
#endif
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
!> @brief calculate average of tensor field !> @brief calculate average of tensor field
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------

893
code/mesh.f90
View File

File diff suppressed because it is too large Load Diff

186
code/numerics.f90
View File

@ -221,11 +221,10 @@ subroutine numerics_init
implicit none implicit none
!$ include "omp_lib.h" ! use the not F90 standard conforming include file to prevent crashes with some versions of MSC.Marc !$ include "omp_lib.h" ! use the not F90 standard conforming include file to prevent crashes with some versions of MSC.Marc
#endif #endif
integer(pInt), parameter :: FILEUNIT = 300_pInt ,& integer(pInt), parameter :: FILEUNIT = 300_pInt
MAXNCHUNKS = 2_pInt
!$ integer :: gotDAMASK_NUM_THREADS = 1 !$ integer :: gotDAMASK_NUM_THREADS = 1
integer :: i, ierr ! no pInt integer :: i, ierr ! no pInt
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
character(len=65536) :: & character(len=65536) :: &
tag ,& tag ,&
line line
@ -273,183 +272,184 @@ subroutine numerics_init
if(line(i:i) == '=') line(i:i) = ' ' ! also allow keyword = value version if(line(i:i) == '=') line(i:i) = ' ' ! also allow keyword = value version
enddo enddo
if (IO_isBlank(line)) cycle ! skip empty lines if (IO_isBlank(line)) cycle ! skip empty lines
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('relevantstrain') case ('relevantstrain')
relevantStrain = IO_floatValue(line,positions,2_pInt) relevantStrain = IO_floatValue(line,chunkPos,2_pInt)
case ('defgradtolerance') case ('defgradtolerance')
defgradTolerance = IO_floatValue(line,positions,2_pInt) defgradTolerance = IO_floatValue(line,chunkPos,2_pInt)
case ('ijacostiffness') case ('ijacostiffness')
iJacoStiffness = IO_intValue(line,positions,2_pInt) iJacoStiffness = IO_intValue(line,chunkPos,2_pInt)
case ('ijacolpresiduum') case ('ijacolpresiduum')
iJacoLpresiduum = IO_intValue(line,positions,2_pInt) iJacoLpresiduum = IO_intValue(line,chunkPos,2_pInt)
case ('pert_fg') case ('pert_fg')
pert_Fg = IO_floatValue(line,positions,2_pInt) pert_Fg = IO_floatValue(line,chunkPos,2_pInt)
case ('pert_method') case ('pert_method')
pert_method = IO_intValue(line,positions,2_pInt) pert_method = IO_intValue(line,chunkPos,2_pInt)
case ('nhomog') case ('nhomog')
nHomog = IO_intValue(line,positions,2_pInt) nHomog = IO_intValue(line,chunkPos,2_pInt)
case ('nmpstate') case ('nmpstate')
nMPstate = IO_intValue(line,positions,2_pInt) nMPstate = IO_intValue(line,chunkPos,2_pInt)
case ('ncryst') case ('ncryst')
nCryst = IO_intValue(line,positions,2_pInt) nCryst = IO_intValue(line,chunkPos,2_pInt)
case ('nstate') case ('nstate')
nState = IO_intValue(line,positions,2_pInt) nState = IO_intValue(line,chunkPos,2_pInt)
case ('nstress') case ('nstress')
nStress = IO_intValue(line,positions,2_pInt) nStress = IO_intValue(line,chunkPos,2_pInt)
case ('substepmincryst') case ('substepmincryst')
subStepMinCryst = IO_floatValue(line,positions,2_pInt) subStepMinCryst = IO_floatValue(line,chunkPos,2_pInt)
case ('substepsizecryst') case ('substepsizecryst')
subStepSizeCryst = IO_floatValue(line,positions,2_pInt) subStepSizeCryst = IO_floatValue(line,chunkPos,2_pInt)
case ('stepincreasecryst') case ('stepincreasecryst')
stepIncreaseCryst = IO_floatValue(line,positions,2_pInt) stepIncreaseCryst = IO_floatValue(line,chunkPos,2_pInt)
case ('substepminhomog') case ('substepminhomog')
subStepMinHomog = IO_floatValue(line,positions,2_pInt) subStepMinHomog = IO_floatValue(line,chunkPos,2_pInt)
case ('substepsizehomog') case ('substepsizehomog')
subStepSizeHomog = IO_floatValue(line,positions,2_pInt) subStepSizeHomog = IO_floatValue(line,chunkPos,2_pInt)
case ('stepincreasehomog') case ('stepincreasehomog')
stepIncreaseHomog = IO_floatValue(line,positions,2_pInt) stepIncreaseHomog = IO_floatValue(line,chunkPos,2_pInt)
case ('rtol_crystallitestate') case ('rtol_crystallitestate')
rTol_crystalliteState = IO_floatValue(line,positions,2_pInt) rTol_crystalliteState = IO_floatValue(line,chunkPos,2_pInt)
case ('rtol_crystallitestress') case ('rtol_crystallitestress')
rTol_crystalliteStress = IO_floatValue(line,positions,2_pInt) rTol_crystalliteStress = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_crystallitestress') case ('atol_crystallitestress')
aTol_crystalliteStress = IO_floatValue(line,positions,2_pInt) aTol_crystalliteStress = IO_floatValue(line,chunkPos,2_pInt)
case ('integrator') case ('integrator')
numerics_integrator(1) = IO_intValue(line,positions,2_pInt) numerics_integrator(1) = IO_intValue(line,chunkPos,2_pInt)
case ('integratorstiffness') case ('integratorstiffness')
numerics_integrator(2) = IO_intValue(line,positions,2_pInt) numerics_integrator(2) = IO_intValue(line,chunkPos,2_pInt)
case ('analyticjaco') case ('analyticjaco')
analyticJaco = IO_intValue(line,positions,2_pInt) > 0_pInt analyticJaco = IO_intValue(line,chunkPos,2_pInt) > 0_pInt
case ('usepingpong') case ('usepingpong')
usepingpong = IO_intValue(line,positions,2_pInt) > 0_pInt usepingpong = IO_intValue(line,chunkPos,2_pInt) > 0_pInt
case ('timesyncing') case ('timesyncing')
numerics_timeSyncing = IO_intValue(line,positions,2_pInt) > 0_pInt numerics_timeSyncing = IO_intValue(line,chunkPos,2_pInt) > 0_pInt
case ('unitlength') case ('unitlength')
numerics_unitlength = IO_floatValue(line,positions,2_pInt) numerics_unitlength = IO_floatValue(line,chunkPos,2_pInt)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! RGC parameters ! RGC parameters
case ('atol_rgc') case ('atol_rgc')
absTol_RGC = IO_floatValue(line,positions,2_pInt) absTol_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('rtol_rgc') case ('rtol_rgc')
relTol_RGC = IO_floatValue(line,positions,2_pInt) relTol_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('amax_rgc') case ('amax_rgc')
absMax_RGC = IO_floatValue(line,positions,2_pInt) absMax_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('rmax_rgc') case ('rmax_rgc')
relMax_RGC = IO_floatValue(line,positions,2_pInt) relMax_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('perturbpenalty_rgc') case ('perturbpenalty_rgc')
pPert_RGC = IO_floatValue(line,positions,2_pInt) pPert_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('relevantmismatch_rgc') case ('relevantmismatch_rgc')
xSmoo_RGC = IO_floatValue(line,positions,2_pInt) xSmoo_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('viscositypower_rgc') case ('viscositypower_rgc')
viscPower_RGC = IO_floatValue(line,positions,2_pInt) viscPower_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('viscositymodulus_rgc') case ('viscositymodulus_rgc')
viscModus_RGC = IO_floatValue(line,positions,2_pInt) viscModus_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('refrelaxationrate_rgc') case ('refrelaxationrate_rgc')
refRelaxRate_RGC = IO_floatValue(line,positions,2_pInt) refRelaxRate_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('maxrelaxation_rgc') case ('maxrelaxation_rgc')
maxdRelax_RGC = IO_floatValue(line,positions,2_pInt) maxdRelax_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('maxvoldiscrepancy_rgc') case ('maxvoldiscrepancy_rgc')
maxVolDiscr_RGC = IO_floatValue(line,positions,2_pInt) maxVolDiscr_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('voldiscrepancymod_rgc') case ('voldiscrepancymod_rgc')
volDiscrMod_RGC = IO_floatValue(line,positions,2_pInt) volDiscrMod_RGC = IO_floatValue(line,chunkPos,2_pInt)
case ('discrepancypower_rgc') case ('discrepancypower_rgc')
volDiscrPow_RGC = IO_floatValue(line,positions,2_pInt) volDiscrPow_RGC = IO_floatValue(line,chunkPos,2_pInt)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! random seeding parameter ! random seeding parameter
case ('fixed_seed') case ('fixed_seed')
fixedSeed = IO_intValue(line,positions,2_pInt) fixedSeed = IO_intValue(line,chunkPos,2_pInt)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! gradient parameter ! gradient parameter
case ('charlength') case ('charlength')
charLength = IO_floatValue(line,positions,2_pInt) charLength = IO_floatValue(line,chunkPos,2_pInt)
case ('residualstiffness') case ('residualstiffness')
residualStiffness = IO_floatValue(line,positions,2_pInt) residualStiffness = IO_floatValue(line,chunkPos,2_pInt)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! field parameters ! field parameters
case ('err_struct_tolabs') case ('err_struct_tolabs')
err_struct_tolAbs = IO_floatValue(line,positions,2_pInt) err_struct_tolAbs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_struct_tolrel') case ('err_struct_tolrel')
err_struct_tolRel = IO_floatValue(line,positions,2_pInt) err_struct_tolRel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_thermal_tolabs') case ('err_thermal_tolabs')
err_thermal_tolabs = IO_floatValue(line,positions,2_pInt) err_thermal_tolabs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_thermal_tolrel') case ('err_thermal_tolrel')
err_thermal_tolrel = IO_floatValue(line,positions,2_pInt) err_thermal_tolrel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_damage_tolabs') case ('err_damage_tolabs')
err_damage_tolabs = IO_floatValue(line,positions,2_pInt) err_damage_tolabs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_damage_tolrel') case ('err_damage_tolrel')
err_damage_tolrel = IO_floatValue(line,positions,2_pInt) err_damage_tolrel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_vacancyflux_tolabs') case ('err_vacancyflux_tolabs')
err_vacancyflux_tolabs = IO_floatValue(line,positions,2_pInt) err_vacancyflux_tolabs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_vacancyflux_tolrel') case ('err_vacancyflux_tolrel')
err_vacancyflux_tolrel = IO_floatValue(line,positions,2_pInt) err_vacancyflux_tolrel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_porosity_tolabs') case ('err_porosity_tolabs')
err_porosity_tolabs = IO_floatValue(line,positions,2_pInt) err_porosity_tolabs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_porosity_tolrel') case ('err_porosity_tolrel')
err_porosity_tolrel = IO_floatValue(line,positions,2_pInt) err_porosity_tolrel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_hydrogenflux_tolabs') case ('err_hydrogenflux_tolabs')
err_hydrogenflux_tolabs = IO_floatValue(line,positions,2_pInt) err_hydrogenflux_tolabs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_hydrogenflux_tolrel') case ('err_hydrogenflux_tolrel')
err_hydrogenflux_tolrel = IO_floatValue(line,positions,2_pInt) err_hydrogenflux_tolrel = IO_floatValue(line,chunkPos,2_pInt)
case ('vacancyboundpenalty') case ('vacancyboundpenalty')
vacancyBoundPenalty = IO_floatValue(line,positions,2_pInt) vacancyBoundPenalty = IO_floatValue(line,chunkPos,2_pInt)
case ('hydrogenboundpenalty') case ('hydrogenboundpenalty')
hydrogenBoundPenalty = IO_floatValue(line,positions,2_pInt) hydrogenBoundPenalty = IO_floatValue(line,chunkPos,2_pInt)
case ('itmax') case ('itmax')
itmax = IO_intValue(line,positions,2_pInt) itmax = IO_intValue(line,chunkPos,2_pInt)
case ('itmin') case ('itmin')
itmin = IO_intValue(line,positions,2_pInt) itmin = IO_intValue(line,chunkPos,2_pInt)
case ('maxcutback') case ('maxcutback')
maxCutBack = IO_intValue(line,positions,2_pInt) maxCutBack = IO_intValue(line,chunkPos,2_pInt)
case ('maxstaggerediter') case ('maxstaggerediter')
stagItMax = IO_intValue(line,positions,2_pInt) stagItMax = IO_intValue(line,chunkPos,2_pInt)
case ('vacancypolyorder') case ('vacancypolyorder')
vacancyPolyOrder = IO_intValue(line,positions,2_pInt) vacancyPolyOrder = IO_intValue(line,chunkPos,2_pInt)
case ('hydrogenpolyorder') case ('hydrogenpolyorder')
hydrogenPolyOrder = IO_intValue(line,positions,2_pInt) hydrogenPolyOrder = IO_intValue(line,chunkPos,2_pInt)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! spectral parameters ! spectral parameters
#ifdef Spectral #ifdef Spectral
case ('err_div_tolabs') case ('err_div_tolabs')
err_div_tolAbs = IO_floatValue(line,positions,2_pInt) err_div_tolAbs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_div_tolrel') case ('err_div_tolrel')
err_div_tolRel = IO_floatValue(line,positions,2_pInt) err_div_tolRel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_stress_tolrel') case ('err_stress_tolrel')
err_stress_tolrel = IO_floatValue(line,positions,2_pInt) err_stress_tolrel = IO_floatValue(line,chunkPos,2_pInt)
case ('err_stress_tolabs') case ('err_stress_tolabs')
err_stress_tolabs = IO_floatValue(line,positions,2_pInt) err_stress_tolabs = IO_floatValue(line,chunkPos,2_pInt)
case ('continuecalculation') case ('continuecalculation')
continueCalculation = IO_intValue(line,positions,2_pInt) continueCalculation = IO_intValue(line,chunkPos,2_pInt)
case ('memory_efficient') case ('memory_efficient')
memory_efficient = IO_intValue(line,positions,2_pInt) > 0_pInt memory_efficient = IO_intValue(line,chunkPos,2_pInt) > 0_pInt
case ('fftw_timelimit') case ('fftw_timelimit')
fftw_timelimit = IO_floatValue(line,positions,2_pInt) fftw_timelimit = IO_floatValue(line,chunkPos,2_pInt)
case ('fftw_plan_mode') case ('fftw_plan_mode')
fftw_plan_mode = IO_lc(IO_stringValue(line,positions,2_pInt)) fftw_plan_mode = IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('spectralfilter','myfilter') case ('spectralfilter','myfilter')
spectral_filter = IO_lc(IO_stringValue(line,positions,2_pInt)) spectral_filter = IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('divergence_correction') case ('divergence_correction')
divergence_correction = IO_intValue(line,positions,2_pInt) divergence_correction = IO_intValue(line,chunkPos,2_pInt)
case ('update_gamma') case ('update_gamma')
update_gamma = IO_intValue(line,positions,2_pInt) > 0_pInt update_gamma = IO_intValue(line,chunkPos,2_pInt) > 0_pInt
case ('petsc_options') case ('petsc_options')
petsc_options = trim(line(positions(4):)) petsc_options = trim(line(chunkPos(4):))
case ('spectralsolver','myspectralsolver') case ('spectralsolver','myspectralsolver')
spectral_solver = IO_lc(IO_stringValue(line,positions,2_pInt)) spectral_solver = IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('err_curl_tolabs') case ('err_curl_tolabs')
err_curl_tolAbs = IO_floatValue(line,positions,2_pInt) err_curl_tolAbs = IO_floatValue(line,chunkPos,2_pInt)
case ('err_curl_tolrel') case ('err_curl_tolrel')
err_curl_tolRel = IO_floatValue(line,positions,2_pInt) err_curl_tolRel = IO_floatValue(line,chunkPos,2_pInt)
case ('polaralpha') case ('polaralpha')
polarAlpha = IO_floatValue(line,positions,2_pInt) polarAlpha = IO_floatValue(line,chunkPos,2_pInt)
case ('polarbeta') case ('polarbeta')
polarBeta = IO_floatValue(line,positions,2_pInt) polarBeta = IO_floatValue(line,chunkPos,2_pInt)
#else #else
case ('err_div_tolabs','err_div_tolrel','err_stress_tolrel','err_stress_tolabs',& ! found spectral parameter for FEM build case ('err_div_tolabs','err_div_tolrel','err_stress_tolrel','err_stress_tolabs',& ! found spectral parameter for FEM build
'memory_efficient','fftw_timelimit','fftw_plan_mode', & 'memory_efficient','fftw_timelimit','fftw_plan_mode', &
@ -463,23 +463,23 @@ subroutine numerics_init
! FEM parameters ! FEM parameters
#ifdef FEM #ifdef FEM
case ('integrationorder') case ('integrationorder')
integrationorder = IO_intValue(line,positions,2_pInt) integrationorder = IO_intValue(line,chunkPos,2_pInt)
case ('structorder') case ('structorder')
structorder = IO_intValue(line,positions,2_pInt) structorder = IO_intValue(line,chunkPos,2_pInt)
case ('thermalorder') case ('thermalorder')
thermalorder = IO_intValue(line,positions,2_pInt) thermalorder = IO_intValue(line,chunkPos,2_pInt)
case ('damageorder') case ('damageorder')
damageorder = IO_intValue(line,positions,2_pInt) damageorder = IO_intValue(line,chunkPos,2_pInt)
case ('vacancyfluxorder') case ('vacancyfluxorder')
vacancyfluxOrder = IO_intValue(line,positions,2_pInt) vacancyfluxOrder = IO_intValue(line,chunkPos,2_pInt)
case ('porosityorder') case ('porosityorder')
porosityOrder = IO_intValue(line,positions,2_pInt) porosityOrder = IO_intValue(line,chunkPos,2_pInt)
case ('hydrogenfluxorder') case ('hydrogenfluxorder')
hydrogenfluxOrder = IO_intValue(line,positions,2_pInt) hydrogenfluxOrder = IO_intValue(line,chunkPos,2_pInt)
case ('petsc_options') case ('petsc_options')
petsc_options = trim(line(positions(4):)) petsc_options = trim(line(chunkPos(4):))
case ('bbarstabilisation') case ('bbarstabilisation')
BBarStabilisation = IO_intValue(line,positions,2_pInt) > 0_pInt BBarStabilisation = IO_intValue(line,chunkPos,2_pInt) > 0_pInt
#else #else
case ('integrationorder','structorder','thermalorder', 'damageorder','vacancyfluxorder', & case ('integrationorder','structorder','thermalorder', 'damageorder','vacancyfluxorder', &
'porosityorder','hydrogenfluxorder','bbarstabilisation') 'porosityorder','hydrogenfluxorder','bbarstabilisation')

113
code/plastic_disloKMC.f90
View File

@ -193,8 +193,7 @@ subroutine plastic_disloKMC_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = LATTICE_maxNinteraction + 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,maxTotalNslip,maxTotalNtwin,& integer(pInt) :: maxNinstance,mySize=0_pInt,phase,maxTotalNslip,maxTotalNtwin,&
f,instance,j,k,l,m,n,o,p,q,r,s,ns,nt, & f,instance,j,k,l,m,n,o,p,q,r,s,ns,nt, &
Nchunks_SlipSlip = 0_pInt, Nchunks_SlipTwin = 0_pInt, & Nchunks_SlipSlip = 0_pInt, Nchunks_SlipTwin = 0_pInt, &
@ -304,102 +303,102 @@ subroutine plastic_disloKMC_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_DISLOKMC_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_DISLOKMC_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('edge_density') case ('edge_density')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = edge_density_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = edge_density_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('dipole_density') case ('dipole_density')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = dipole_density_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = dipole_density_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_slip','shearrate_slip') case ('shear_rate_slip','shearrate_slip')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = shear_rate_slip_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = shear_rate_slip_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulated_shear_slip') case ('accumulated_shear_slip')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = accumulated_shear_slip_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = accumulated_shear_slip_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('mfp_slip') case ('mfp_slip')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = mfp_slip_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = mfp_slip_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_slip') case ('resolved_stress_slip')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = resolved_stress_slip_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = resolved_stress_slip_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('threshold_stress_slip') case ('threshold_stress_slip')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = threshold_stress_slip_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = threshold_stress_slip_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('edge_dipole_distance') case ('edge_dipole_distance')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = edge_dipole_distance_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = edge_dipole_distance_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('stress_exponent') case ('stress_exponent')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = stress_exponent_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = stress_exponent_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('twin_fraction') case ('twin_fraction')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = twin_fraction_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = twin_fraction_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_twin','shearrate_twin') case ('shear_rate_twin','shearrate_twin')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = shear_rate_twin_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = shear_rate_twin_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulated_shear_twin') case ('accumulated_shear_twin')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = accumulated_shear_twin_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = accumulated_shear_twin_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('mfp_twin') case ('mfp_twin')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = mfp_twin_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = mfp_twin_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_twin') case ('resolved_stress_twin')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = resolved_stress_twin_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = resolved_stress_twin_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('threshold_stress_twin') case ('threshold_stress_twin')
plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt plastic_disloKMC_Noutput(instance) = plastic_disloKMC_Noutput(instance) + 1_pInt
plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = threshold_stress_twin_ID plastic_disloKMC_outputID(plastic_disloKMC_Noutput(instance),instance) = threshold_stress_twin_ID
plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = & plastic_disloKMC_output(plastic_disloKMC_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of slip system families ! parameters depending on number of slip system families
case ('nslip') case ('nslip')
if (positions(1) < Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_SlipFamilies + 1_pInt) &
call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
if (positions(1) > Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_SlipFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
Nchunks_SlipFamilies = positions(1) - 1_pInt Nchunks_SlipFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_disloKMC_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_disloKMC_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('rhoedge0','rhoedgedip0','slipburgers','qedge','v0','clambdaslip','tau_peierls','p_slip','q_slip',& case ('rhoedge0','rhoedgedip0','slipburgers','qedge','v0','clambdaslip','tau_peierls','p_slip','q_slip',&
'u_slip','s_slip') 'u_slip','s_slip')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
tempPerSlip(j) = IO_floatValue(line,positions,1_pInt+j) tempPerSlip(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('rhoedge0') case ('rhoedge0')
@ -430,17 +429,17 @@ subroutine plastic_disloKMC_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on slip number of twin families ! parameters depending on slip number of twin families
case ('ntwin') case ('ntwin')
if (positions(1) < Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_TwinFamilies + 1_pInt) &
call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
if (positions(1) > Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_TwinFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
Nchunks_TwinFamilies = positions(1) - 1_pInt Nchunks_TwinFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_disloKMC_Ntwin(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_disloKMC_Ntwin(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('ndot0','twinsize','twinburgers','r_twin') case ('ndot0','twinsize','twinburgers','r_twin')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
tempPerTwin(j) = IO_floatValue(line,positions,1_pInt+j) tempPerTwin(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('ndot0') case ('ndot0')
@ -457,71 +456,71 @@ subroutine plastic_disloKMC_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of interactions ! parameters depending on number of interactions
case ('interaction_slipslip','interactionslipslip') case ('interaction_slipslip','interactionslipslip')
if (positions(1) < 1_pInt + Nchunks_SlipSlip) & if (chunkPos(1) < 1_pInt + Nchunks_SlipSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
do j = 1_pInt, Nchunks_SlipSlip do j = 1_pInt, Nchunks_SlipSlip
plastic_disloKMC_interaction_SlipSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloKMC_interaction_SlipSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_sliptwin','interactionsliptwin') case ('interaction_sliptwin','interactionsliptwin')
if (positions(1) < 1_pInt + Nchunks_SlipTwin) & if (chunkPos(1) < 1_pInt + Nchunks_SlipTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
do j = 1_pInt, Nchunks_SlipTwin do j = 1_pInt, Nchunks_SlipTwin
plastic_disloKMC_interaction_SlipTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloKMC_interaction_SlipTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twinslip','interactiontwinslip') case ('interaction_twinslip','interactiontwinslip')
if (positions(1) < 1_pInt + Nchunks_TwinSlip) & if (chunkPos(1) < 1_pInt + Nchunks_TwinSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
do j = 1_pInt, Nchunks_TwinSlip do j = 1_pInt, Nchunks_TwinSlip
plastic_disloKMC_interaction_TwinSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloKMC_interaction_TwinSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twintwin','interactiontwintwin') case ('interaction_twintwin','interactiontwintwin')
if (positions(1) < 1_pInt + Nchunks_TwinTwin) & if (chunkPos(1) < 1_pInt + Nchunks_TwinTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
do j = 1_pInt, Nchunks_TwinTwin do j = 1_pInt, Nchunks_TwinTwin
plastic_disloKMC_interaction_TwinTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloKMC_interaction_TwinTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('nonschmid_coefficients') case ('nonschmid_coefficients')
if (positions(1) < 1_pInt + Nchunks_nonSchmid) & if (chunkPos(1) < 1_pInt + Nchunks_nonSchmid) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOKMC_label//')')
do j = 1_pInt,Nchunks_nonSchmid do j = 1_pInt,Nchunks_nonSchmid
plastic_disloKMC_nonSchmidCoeff(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloKMC_nonSchmidCoeff(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters independent of number of slip/twin systems ! parameters independent of number of slip/twin systems
case ('grainsize') case ('grainsize')
plastic_disloKMC_GrainSize(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_GrainSize(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('maxtwinfraction') case ('maxtwinfraction')
plastic_disloKMC_MaxTwinFraction(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_MaxTwinFraction(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('d0') case ('d0')
plastic_disloKMC_D0(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_D0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('qsd') case ('qsd')
plastic_disloKMC_Qsd(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_Qsd(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_rho') case ('atol_rho')
plastic_disloKMC_aTolRho(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_aTolRho(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_twinfrac') case ('atol_twinfrac')
plastic_disloKMC_aTolTwinFrac(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_aTolTwinFrac(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cmfptwin') case ('cmfptwin')
plastic_disloKMC_Cmfptwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_Cmfptwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cthresholdtwin') case ('cthresholdtwin')
plastic_disloKMC_Cthresholdtwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_Cthresholdtwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('solidsolutionstrength') case ('solidsolutionstrength')
plastic_disloKMC_SolidSolutionStrength(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_SolidSolutionStrength(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('l0') case ('l0')
plastic_disloKMC_L0(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_L0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('xc') case ('xc')
plastic_disloKMC_xc(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_xc(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('vcrossslip') case ('vcrossslip')
plastic_disloKMC_VcrossSlip(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_VcrossSlip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cedgedipmindistance') case ('cedgedipmindistance')
plastic_disloKMC_CEdgeDipMinDistance(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_CEdgeDipMinDistance(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('catomicvolume') case ('catomicvolume')
plastic_disloKMC_CAtomicVolume(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_CAtomicVolume(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('sfe_0k') case ('sfe_0k')
plastic_disloKMC_SFE_0K(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_SFE_0K(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('dsfe_dt') case ('dsfe_dt')
plastic_disloKMC_dSFE_dT(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_dSFE_dT(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('dipoleformationfactor') case ('dipoleformationfactor')
plastic_disloKMC_dipoleFormationFactor(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloKMC_dipoleFormationFactor(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif
enddo parsingFile enddo parsingFile

113
code/plastic_disloUCLA.f90
View File

@ -198,8 +198,7 @@ subroutine plastic_disloUCLA_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = LATTICE_maxNinteraction + 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,maxTotalNslip,maxTotalNtwin,& integer(pInt) :: maxNinstance,mySize=0_pInt,phase,maxTotalNslip,maxTotalNtwin,&
f,instance,j,k,l,m,n,o,p,q,r,s,ns,nt, & f,instance,j,k,l,m,n,o,p,q,r,s,ns,nt, &
Nchunks_SlipSlip = 0_pInt, Nchunks_SlipTwin = 0_pInt, & Nchunks_SlipSlip = 0_pInt, Nchunks_SlipTwin = 0_pInt, &
@ -312,102 +311,102 @@ subroutine plastic_disloUCLA_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_DISLOUCLA_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_DISLOUCLA_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('edge_density') case ('edge_density')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = edge_density_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = edge_density_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('dipole_density') case ('dipole_density')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = dipole_density_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = dipole_density_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_slip','shearrate_slip') case ('shear_rate_slip','shearrate_slip')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = shear_rate_slip_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = shear_rate_slip_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulated_shear_slip') case ('accumulated_shear_slip')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = accumulated_shear_slip_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = accumulated_shear_slip_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('mfp_slip') case ('mfp_slip')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = mfp_slip_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = mfp_slip_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_slip') case ('resolved_stress_slip')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = resolved_stress_slip_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = resolved_stress_slip_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('threshold_stress_slip') case ('threshold_stress_slip')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = threshold_stress_slip_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = threshold_stress_slip_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('edge_dipole_distance') case ('edge_dipole_distance')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = edge_dipole_distance_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = edge_dipole_distance_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('stress_exponent') case ('stress_exponent')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = stress_exponent_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = stress_exponent_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('twin_fraction') case ('twin_fraction')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = twin_fraction_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = twin_fraction_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_twin','shearrate_twin') case ('shear_rate_twin','shearrate_twin')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = shear_rate_twin_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = shear_rate_twin_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulated_shear_twin') case ('accumulated_shear_twin')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = accumulated_shear_twin_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = accumulated_shear_twin_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('mfp_twin') case ('mfp_twin')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = mfp_twin_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = mfp_twin_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_twin') case ('resolved_stress_twin')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = resolved_stress_twin_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = resolved_stress_twin_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('threshold_stress_twin') case ('threshold_stress_twin')
plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt plastic_disloUCLA_Noutput(instance) = plastic_disloUCLA_Noutput(instance) + 1_pInt
plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = threshold_stress_twin_ID plastic_disloUCLA_outputID(plastic_disloUCLA_Noutput(instance),instance) = threshold_stress_twin_ID
plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = & plastic_disloUCLA_output(plastic_disloUCLA_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of slip system families ! parameters depending on number of slip system families
case ('nslip') case ('nslip')
if (positions(1) < Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_SlipFamilies + 1_pInt) &
call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
if (positions(1) > Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_SlipFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
Nchunks_SlipFamilies = positions(1) - 1_pInt Nchunks_SlipFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_disloUCLA_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_disloUCLA_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('rhoedge0','rhoedgedip0','slipburgers','qedge','v0','clambdaslip','tau_peierls','p_slip','q_slip',& case ('rhoedge0','rhoedgedip0','slipburgers','qedge','v0','clambdaslip','tau_peierls','p_slip','q_slip',&
'kink_height','omega','kink_width','dislolength','friction_coeff') 'kink_height','omega','kink_width','dislolength','friction_coeff')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
tempPerSlip(j) = IO_floatValue(line,positions,1_pInt+j) tempPerSlip(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('rhoedge0') case ('rhoedge0')
@ -449,17 +448,17 @@ subroutine plastic_disloUCLA_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on slip number of twin families ! parameters depending on slip number of twin families
case ('ntwin') case ('ntwin')
if (positions(1) < Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_TwinFamilies + 1_pInt) &
call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
if (positions(1) > Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_TwinFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
Nchunks_TwinFamilies = positions(1) - 1_pInt Nchunks_TwinFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_disloUCLA_Ntwin(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_disloUCLA_Ntwin(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('ndot0','twinsize','twinburgers','r_twin') case ('ndot0','twinsize','twinburgers','r_twin')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
tempPerTwin(j) = IO_floatValue(line,positions,1_pInt+j) tempPerTwin(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('ndot0') case ('ndot0')
@ -476,71 +475,71 @@ subroutine plastic_disloUCLA_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of interactions ! parameters depending on number of interactions
case ('interaction_slipslip','interactionslipslip') case ('interaction_slipslip','interactionslipslip')
if (positions(1) < 1_pInt + Nchunks_SlipSlip) & if (chunkPos(1) < 1_pInt + Nchunks_SlipSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
do j = 1_pInt, Nchunks_SlipSlip do j = 1_pInt, Nchunks_SlipSlip
plastic_disloUCLA_interaction_SlipSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloUCLA_interaction_SlipSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_sliptwin','interactionsliptwin') case ('interaction_sliptwin','interactionsliptwin')
if (positions(1) < 1_pInt + Nchunks_SlipTwin) & if (chunkPos(1) < 1_pInt + Nchunks_SlipTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
do j = 1_pInt, Nchunks_SlipTwin do j = 1_pInt, Nchunks_SlipTwin
plastic_disloUCLA_interaction_SlipTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloUCLA_interaction_SlipTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twinslip','interactiontwinslip') case ('interaction_twinslip','interactiontwinslip')
if (positions(1) < 1_pInt + Nchunks_TwinSlip) & if (chunkPos(1) < 1_pInt + Nchunks_TwinSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
do j = 1_pInt, Nchunks_TwinSlip do j = 1_pInt, Nchunks_TwinSlip
plastic_disloUCLA_interaction_TwinSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloUCLA_interaction_TwinSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twintwin','interactiontwintwin') case ('interaction_twintwin','interactiontwintwin')
if (positions(1) < 1_pInt + Nchunks_TwinTwin) & if (chunkPos(1) < 1_pInt + Nchunks_TwinTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
do j = 1_pInt, Nchunks_TwinTwin do j = 1_pInt, Nchunks_TwinTwin
plastic_disloUCLA_interaction_TwinTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloUCLA_interaction_TwinTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('nonschmid_coefficients') case ('nonschmid_coefficients')
if (positions(1) < 1_pInt + Nchunks_nonSchmid) & if (chunkPos(1) < 1_pInt + Nchunks_nonSchmid) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOUCLA_label//')')
do j = 1_pInt,Nchunks_nonSchmid do j = 1_pInt,Nchunks_nonSchmid
plastic_disloUCLA_nonSchmidCoeff(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_disloUCLA_nonSchmidCoeff(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters independent of number of slip/twin systems ! parameters independent of number of slip/twin systems
case ('grainsize') case ('grainsize')
plastic_disloUCLA_GrainSize(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_GrainSize(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('maxtwinfraction') case ('maxtwinfraction')
plastic_disloUCLA_MaxTwinFraction(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_MaxTwinFraction(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('d0') case ('d0')
plastic_disloUCLA_D0(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_D0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('qsd') case ('qsd')
plastic_disloUCLA_Qsd(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_Qsd(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_rho') case ('atol_rho')
plastic_disloUCLA_aTolRho(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_aTolRho(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_twinfrac') case ('atol_twinfrac')
plastic_disloUCLA_aTolTwinFrac(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_aTolTwinFrac(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cmfptwin') case ('cmfptwin')
plastic_disloUCLA_Cmfptwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_Cmfptwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cthresholdtwin') case ('cthresholdtwin')
plastic_disloUCLA_Cthresholdtwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_Cthresholdtwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('solidsolutionstrength') case ('solidsolutionstrength')
plastic_disloUCLA_SolidSolutionStrength(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_SolidSolutionStrength(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('l0') case ('l0')
plastic_disloUCLA_L0(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_L0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('xc') case ('xc')
plastic_disloUCLA_xc(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_xc(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('vcrossslip') case ('vcrossslip')
plastic_disloUCLA_VcrossSlip(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_VcrossSlip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cedgedipmindistance') case ('cedgedipmindistance')
plastic_disloUCLA_CEdgeDipMinDistance(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_CEdgeDipMinDistance(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('catomicvolume') case ('catomicvolume')
plastic_disloUCLA_CAtomicVolume(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_CAtomicVolume(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('sfe_0k') case ('sfe_0k')
plastic_disloUCLA_SFE_0K(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_SFE_0K(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('dsfe_dt') case ('dsfe_dt')
plastic_disloUCLA_dSFE_dT(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_dSFE_dT(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('dipoleformationfactor') case ('dipoleformationfactor')
plastic_disloUCLA_dipoleFormationFactor(instance) = IO_floatValue(line,positions,2_pInt) plastic_disloUCLA_dipoleFormationFactor(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif
enddo parsingFile enddo parsingFile

159
code/plastic_dislotwin.f90
View File

@ -231,8 +231,7 @@ subroutine plastic_dislotwin_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = LATTICE_maxNinteraction + 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,maxTotalNslip,maxTotalNtwin,maxTotalNtrans,& integer(pInt) :: maxNinstance,mySize=0_pInt,phase,maxTotalNslip,maxTotalNtwin,maxTotalNtrans,&
f,instance,j,k,l,m,n,o,p,q,r,s,ns,nt,nr, & f,instance,j,k,l,m,n,o,p,q,r,s,ns,nt,nr, &
Nchunks_SlipSlip = 0_pInt, Nchunks_SlipTwin = 0_pInt, & Nchunks_SlipSlip = 0_pInt, Nchunks_SlipTwin = 0_pInt, &
@ -374,136 +373,136 @@ subroutine plastic_dislotwin_init(fileUnit)
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_DISLOTWIN_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_DISLOTWIN_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('edge_density') case ('edge_density')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = edge_density_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = edge_density_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('dipole_density') case ('dipole_density')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = dipole_density_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = dipole_density_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_slip','shearrate_slip') case ('shear_rate_slip','shearrate_slip')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = shear_rate_slip_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = shear_rate_slip_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulated_shear_slip') case ('accumulated_shear_slip')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = accumulated_shear_slip_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = accumulated_shear_slip_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('mfp_slip') case ('mfp_slip')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = mfp_slip_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = mfp_slip_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_slip') case ('resolved_stress_slip')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = resolved_stress_slip_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = resolved_stress_slip_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('threshold_stress_slip') case ('threshold_stress_slip')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = threshold_stress_slip_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = threshold_stress_slip_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('edge_dipole_distance') case ('edge_dipole_distance')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = edge_dipole_distance_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = edge_dipole_distance_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('stress_exponent') case ('stress_exponent')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = stress_exponent_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = stress_exponent_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('twin_fraction') case ('twin_fraction')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = twin_fraction_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = twin_fraction_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_twin','shearrate_twin') case ('shear_rate_twin','shearrate_twin')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = shear_rate_twin_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = shear_rate_twin_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulated_shear_twin') case ('accumulated_shear_twin')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = accumulated_shear_twin_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = accumulated_shear_twin_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('mfp_twin') case ('mfp_twin')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = mfp_twin_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = mfp_twin_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_twin') case ('resolved_stress_twin')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = resolved_stress_twin_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = resolved_stress_twin_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('threshold_stress_twin') case ('threshold_stress_twin')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = threshold_stress_twin_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = threshold_stress_twin_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolved_stress_shearband') case ('resolved_stress_shearband')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = resolved_stress_shearband_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = resolved_stress_shearband_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_rate_shearband','shearrate_shearband') case ('shear_rate_shearband','shearrate_shearband')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = shear_rate_shearband_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = shear_rate_shearband_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('sb_eigenvalues') case ('sb_eigenvalues')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = sb_eigenvalues_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = sb_eigenvalues_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('sb_eigenvectors') case ('sb_eigenvectors')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = sb_eigenvectors_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = sb_eigenvectors_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('stress_trans_fraction') case ('stress_trans_fraction')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = stress_trans_fraction_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = stress_trans_fraction_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('strain_trans_fraction') case ('strain_trans_fraction')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = strain_trans_fraction_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = strain_trans_fraction_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('trans_fraction','total_trans_fraction') case ('trans_fraction','total_trans_fraction')
plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt plastic_dislotwin_Noutput(instance) = plastic_dislotwin_Noutput(instance) + 1_pInt
plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = trans_fraction_ID plastic_dislotwin_outputID(plastic_dislotwin_Noutput(instance),instance) = trans_fraction_ID
plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = & plastic_dislotwin_output(plastic_dislotwin_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of slip system families ! parameters depending on number of slip system families
case ('nslip') case ('nslip')
if (positions(1) < Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_SlipFamilies + 1_pInt) &
call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
if (positions(1) > Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_SlipFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
Nchunks_SlipFamilies = positions(1) - 1_pInt Nchunks_SlipFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_dislotwin_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_dislotwin_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('rhoedge0','rhoedgedip0','slipburgers','qedge','v0','clambdaslip','tau_peierls','p_slip','q_slip') case ('rhoedge0','rhoedgedip0','slipburgers','qedge','v0','clambdaslip','tau_peierls','p_slip','q_slip')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
tempPerSlip(j) = IO_floatValue(line,positions,1_pInt+j) tempPerSlip(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('rhoedge0') case ('rhoedge0')
@ -530,17 +529,17 @@ subroutine plastic_dislotwin_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on slip number of twin families ! parameters depending on slip number of twin families
case ('ntwin') case ('ntwin')
if (positions(1) < Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_TwinFamilies + 1_pInt) &
call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
if (positions(1) > Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_TwinFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
Nchunks_TwinFamilies = positions(1) - 1_pInt Nchunks_TwinFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_dislotwin_Ntwin(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_dislotwin_Ntwin(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('ndot0','twinsize','twinburgers','r_twin') case ('ndot0','twinsize','twinburgers','r_twin')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
tempPerTwin(j) = IO_floatValue(line,positions,1_pInt+j) tempPerTwin(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('ndot0') case ('ndot0')
@ -557,17 +556,17 @@ subroutine plastic_dislotwin_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of transformation system families ! parameters depending on number of transformation system families
case ('ntrans') case ('ntrans')
if (positions(1) < Nchunks_TransFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_TransFamilies + 1_pInt) &
call IO_warning(53_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(53_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
if (positions(1) > Nchunks_TransFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_TransFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
Nchunks_TransFamilies = positions(1) - 1_pInt Nchunks_TransFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_TransFamilies do j = 1_pInt, Nchunks_TransFamilies
plastic_dislotwin_Ntrans(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_dislotwin_Ntrans(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('lamellarsize','transburgers','s_trans') case ('lamellarsize','transburgers','s_trans')
do j = 1_pInt, Nchunks_TransFamilies do j = 1_pInt, Nchunks_TransFamilies
tempPerTrans(j) = IO_floatValue(line,positions,1_pInt+j) tempPerTrans(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('lamellarsize') case ('lamellarsize')
@ -580,91 +579,91 @@ subroutine plastic_dislotwin_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of interactions ! parameters depending on number of interactions
case ('interaction_slipslip','interactionslipslip') case ('interaction_slipslip','interactionslipslip')
if (positions(1) < 1_pInt + Nchunks_SlipSlip) & if (chunkPos(1) < 1_pInt + Nchunks_SlipSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
do j = 1_pInt, Nchunks_SlipSlip do j = 1_pInt, Nchunks_SlipSlip
plastic_dislotwin_interaction_SlipSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_dislotwin_interaction_SlipSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_sliptwin','interactionsliptwin') case ('interaction_sliptwin','interactionsliptwin')
if (positions(1) < 1_pInt + Nchunks_SlipTwin) & if (chunkPos(1) < 1_pInt + Nchunks_SlipTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
do j = 1_pInt, Nchunks_SlipTwin do j = 1_pInt, Nchunks_SlipTwin
plastic_dislotwin_interaction_SlipTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_dislotwin_interaction_SlipTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twinslip','interactiontwinslip') case ('interaction_twinslip','interactiontwinslip')
if (positions(1) < 1_pInt + Nchunks_TwinSlip) & if (chunkPos(1) < 1_pInt + Nchunks_TwinSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
do j = 1_pInt, Nchunks_TwinSlip do j = 1_pInt, Nchunks_TwinSlip
plastic_dislotwin_interaction_TwinSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_dislotwin_interaction_TwinSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twintwin','interactiontwintwin') case ('interaction_twintwin','interactiontwintwin')
if (positions(1) < 1_pInt + Nchunks_TwinTwin) & if (chunkPos(1) < 1_pInt + Nchunks_TwinTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_DISLOTWIN_label//')')
do j = 1_pInt, Nchunks_TwinTwin do j = 1_pInt, Nchunks_TwinTwin
plastic_dislotwin_interaction_TwinTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_dislotwin_interaction_TwinTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters independent of number of slip/twin/trans systems ! parameters independent of number of slip/twin/trans systems
case ('grainsize') case ('grainsize')
plastic_dislotwin_GrainSize(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_GrainSize(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('maxtwinfraction') case ('maxtwinfraction')
plastic_dislotwin_MaxTwinFraction(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_MaxTwinFraction(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('p_shearband') case ('p_shearband')
plastic_dislotwin_pShearBand(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_pShearBand(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('q_shearband') case ('q_shearband')
plastic_dislotwin_qShearBand(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_qShearBand(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('d0') case ('d0')
plastic_dislotwin_D0(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_D0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('qsd') case ('qsd')
plastic_dislotwin_Qsd(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Qsd(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_rho') case ('atol_rho')
plastic_dislotwin_aTolRho(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_aTolRho(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_twinfrac') case ('atol_twinfrac')
plastic_dislotwin_aTolTwinFrac(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_aTolTwinFrac(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_transfrac') case ('atol_transfrac')
plastic_dislotwin_aTolTransFrac(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_aTolTransFrac(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cmfptwin') case ('cmfptwin')
plastic_dislotwin_Cmfptwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cmfptwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cthresholdtwin') case ('cthresholdtwin')
plastic_dislotwin_Cthresholdtwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cthresholdtwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('solidsolutionstrength') case ('solidsolutionstrength')
plastic_dislotwin_SolidSolutionStrength(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_SolidSolutionStrength(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('l0') case ('l0')
plastic_dislotwin_L0(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_L0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('xc') case ('xc')
plastic_dislotwin_xc(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_xc(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('vcrossslip') case ('vcrossslip')
plastic_dislotwin_VcrossSlip(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_VcrossSlip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cedgedipmindistance') case ('cedgedipmindistance')
plastic_dislotwin_CEdgeDipMinDistance(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_CEdgeDipMinDistance(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('catomicvolume') case ('catomicvolume')
plastic_dislotwin_CAtomicVolume(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_CAtomicVolume(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('sfe_0k') case ('sfe_0k')
plastic_dislotwin_SFE_0K(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_SFE_0K(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('dsfe_dt') case ('dsfe_dt')
plastic_dislotwin_dSFE_dT(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_dSFE_dT(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('dipoleformationfactor') case ('dipoleformationfactor')
plastic_dislotwin_dipoleFormationFactor(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_dipoleFormationFactor(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('shearbandresistance') case ('shearbandresistance')
plastic_dislotwin_sbResistance(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_sbResistance(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('shearbandvelocity') case ('shearbandvelocity')
plastic_dislotwin_sbVelocity(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_sbVelocity(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('qedgepersbsystem') case ('qedgepersbsystem')
plastic_dislotwin_sbQedge(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_sbQedge(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cdwp') case ('cdwp')
plastic_dislotwin_Cdwp(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cdwp(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cnuc') case ('cnuc')
plastic_dislotwin_Cnuc(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cnuc(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cgro') case ('cgro')
plastic_dislotwin_Cgro(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cgro(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('deltag') case ('deltag')
plastic_dislotwin_deltaG(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_deltaG(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cmfptrans') case ('cmfptrans')
plastic_dislotwin_Cmfptrans(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cmfptrans(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cthresholdtrans') case ('cthresholdtrans')
plastic_dislotwin_Cthresholdtrans(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_Cthresholdtrans(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('transstackheight') case ('transstackheight')
plastic_dislotwin_transStackHeight(instance) = IO_floatValue(line,positions,2_pInt) plastic_dislotwin_transStackHeight(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif
enddo parsingFile enddo parsingFile

41
code/plastic_j2.f90
View File

@ -131,9 +131,8 @@ subroutine plastic_j2_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt) :: & integer(pInt) :: &
o, & o, &
phase, & phase, &
@ -218,17 +217,17 @@ subroutine plastic_j2_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_J2_ID) then ! one of my phases. Do not short-circuit here (.and. between if-statements), it's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_J2_ID) then ! one of my phases. Do not short-circuit here (.and. between if-statements), it's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('flowstress') case ('flowstress')
plastic_j2_Noutput(instance) = plastic_j2_Noutput(instance) + 1_pInt plastic_j2_Noutput(instance) = plastic_j2_Noutput(instance) + 1_pInt
plastic_j2_outputID(plastic_j2_Noutput(instance),instance) = flowstress_ID plastic_j2_outputID(plastic_j2_Noutput(instance),instance) = flowstress_ID
plastic_j2_output(plastic_j2_Noutput(instance),instance) = & plastic_j2_output(plastic_j2_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
#ifdef HDF #ifdef HDF
call HDF5_addScalarDataset(outID(instance),myConstituents,'flowstress','MPa') call HDF5_addScalarDataset(outID(instance),myConstituents,'flowstress','MPa')
allocate(plastic_j2_Output2(instance)%flowstress(myConstituents)) allocate(plastic_j2_Output2(instance)%flowstress(myConstituents))
@ -238,7 +237,7 @@ subroutine plastic_j2_init(fileUnit)
plastic_j2_Noutput(instance) = plastic_j2_Noutput(instance) + 1_pInt plastic_j2_Noutput(instance) = plastic_j2_Noutput(instance) + 1_pInt
plastic_j2_outputID(plastic_j2_Noutput(instance),instance) = strainrate_ID plastic_j2_outputID(plastic_j2_Noutput(instance),instance) = strainrate_ID
plastic_j2_output(plastic_j2_Noutput(instance),instance) = & plastic_j2_output(plastic_j2_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
#ifdef HDF #ifdef HDF
call HDF5_addScalarDataset(outID(instance),myConstituents,'strainrate','1/s') call HDF5_addScalarDataset(outID(instance),myConstituents,'strainrate','1/s')
allocate(plastic_j2_Output2(instance)%strainrate(myConstituents)) allocate(plastic_j2_Output2(instance)%strainrate(myConstituents))
@ -248,47 +247,47 @@ subroutine plastic_j2_init(fileUnit)
end select end select
case ('tau0') case ('tau0')
plastic_j2_tau0(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_tau0(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_tau0(instance) < 0.0_pReal) & if (plastic_j2_tau0(instance) < 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('gdot0') case ('gdot0')
plastic_j2_gdot0(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_gdot0(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_gdot0(instance) <= 0.0_pReal) & if (plastic_j2_gdot0(instance) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('n') case ('n')
plastic_j2_n(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_n(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_n(instance) <= 0.0_pReal) & if (plastic_j2_n(instance) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('h0') case ('h0')
plastic_j2_h0(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_h0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('h0_slope','slopelnrate') case ('h0_slope','slopelnrate')
plastic_j2_h0_slopeLnRate(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_h0_slopeLnRate(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('tausat') case ('tausat')
plastic_j2_tausat(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_tausat(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_tausat(instance) <= 0.0_pReal) & if (plastic_j2_tausat(instance) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('tausat_sinhfita') case ('tausat_sinhfita')
plastic_j2_tausat_SinhFitA(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_tausat_SinhFitA(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('tausat_sinhfitb') case ('tausat_sinhfitb')
plastic_j2_tausat_SinhFitB(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_tausat_SinhFitB(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('tausat_sinhfitc') case ('tausat_sinhfitc')
plastic_j2_tausat_SinhFitC(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_tausat_SinhFitC(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('tausat_sinhfitd') case ('tausat_sinhfitd')
plastic_j2_tausat_SinhFitD(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_tausat_SinhFitD(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('a', 'w0') case ('a', 'w0')
plastic_j2_a(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_a(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_a(instance) <= 0.0_pReal) & if (plastic_j2_a(instance) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('taylorfactor') case ('taylorfactor')
plastic_j2_fTaylor(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_fTaylor(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_fTaylor(instance) <= 0.0_pReal) & if (plastic_j2_fTaylor(instance) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('atol_resistance') case ('atol_resistance')
plastic_j2_aTolResistance(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_aTolResistance(instance) = IO_floatValue(line,chunkPos,2_pInt)
if (plastic_j2_aTolResistance(instance) <= 0.0_pReal) & if (plastic_j2_aTolResistance(instance) <= 0.0_pReal) &
call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')') call IO_error(211_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_J2_label//')')
case ('atol_shear') case ('atol_shear')
plastic_j2_aTolShear(instance) = IO_floatValue(line,positions,2_pInt) plastic_j2_aTolShear(instance) = IO_floatValue(line,chunkPos,2_pInt)
case default case default

270
code/plastic_nonlocal.f90
View File

@ -305,9 +305,7 @@ implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
!*** local variables !*** local variables
integer(pInt), parameter :: MAXNCHUNKS = LATTICE_maxNinteraction + 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), &
dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions
integer(pInt) :: phase, & integer(pInt) :: phase, &
maxNinstances, & maxNinstances, &
maxTotalNslip, & maxTotalNslip, &
@ -429,553 +427,553 @@ allocate(nonSchmidCoeff(lattice_maxNnonSchmid,maxNinstances), s
endif endif
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_NONLOCAL_ID) then ! one of my phases. do not short-circuit here (.and. with next if statement). It's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_NONLOCAL_ID) then ! one of my phases. do not short-circuit here (.and. with next if statement). It's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('rho') case ('rho')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('delta') case ('delta')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = delta_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = delta_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_edge') case ('rho_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_screw') case ('rho_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl') case ('rho_sgl')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('delta_sgl') case ('delta_sgl')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = delta_sgl_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = delta_sgl_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge') case ('rho_sgl_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_pos') case ('rho_sgl_edge_pos')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_pos_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_pos_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_neg') case ('rho_sgl_edge_neg')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_neg_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_neg_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw') case ('rho_sgl_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_pos') case ('rho_sgl_screw_pos')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_pos_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_pos_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_neg') case ('rho_sgl_screw_neg')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_neg_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_neg_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_mobile') case ('rho_sgl_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_mobile') case ('rho_sgl_edge_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_pos_mobile') case ('rho_sgl_edge_pos_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_pos_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_pos_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_neg_mobile') case ('rho_sgl_edge_neg_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_neg_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_neg_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_mobile') case ('rho_sgl_screw_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_pos_mobile') case ('rho_sgl_screw_pos_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_pos_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_pos_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_neg_mobile') case ('rho_sgl_screw_neg_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_neg_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_neg_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_immobile') case ('rho_sgl_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_immobile') case ('rho_sgl_edge_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_pos_immobile') case ('rho_sgl_edge_pos_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_pos_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_pos_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_edge_neg_immobile') case ('rho_sgl_edge_neg_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_neg_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_edge_neg_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_immobile') case ('rho_sgl_screw_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_pos_immobile') case ('rho_sgl_screw_pos_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_pos_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_pos_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_sgl_screw_neg_immobile') case ('rho_sgl_screw_neg_immobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_neg_immobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_sgl_screw_neg_immobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dip') case ('rho_dip')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dip_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dip_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('delta_dip') case ('delta_dip')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = delta_dip_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = delta_dip_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dip_edge') case ('rho_dip_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dip_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dip_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dip_screw') case ('rho_dip_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dip_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dip_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('excess_rho') case ('excess_rho')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = excess_rho_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = excess_rho_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('excess_rho_edge') case ('excess_rho_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = excess_rho_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = excess_rho_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('excess_rho_screw') case ('excess_rho_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = excess_rho_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = excess_rho_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_forest') case ('rho_forest')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_forest_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_forest_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shearrate') case ('shearrate')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = shearrate_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = shearrate_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolvedstress') case ('resolvedstress')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resolvedstress_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resolvedstress_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolvedstress_external') case ('resolvedstress_external')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resolvedstress_external_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resolvedstress_external_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolvedstress_back') case ('resolvedstress_back')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resolvedstress_back_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resolvedstress_back_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resistance') case ('resistance')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resistance_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = resistance_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot') case ('rho_dot')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_sgl') case ('rho_dot_sgl')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_sgl_mobile') case ('rho_dot_sgl_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_dip') case ('rho_dot_dip')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_dip_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_dip_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_gen') case ('rho_dot_gen')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_gen_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_gen_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_gen_edge') case ('rho_dot_gen_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_gen_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_gen_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_gen_screw') case ('rho_dot_gen_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_gen_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_gen_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_sgl2dip') case ('rho_dot_sgl2dip')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl2dip_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl2dip_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_sgl2dip_edge') case ('rho_dot_sgl2dip_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl2dip_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl2dip_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_sgl2dip_screw') case ('rho_dot_sgl2dip_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl2dip_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_sgl2dip_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_ann_ath') case ('rho_dot_ann_ath')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_ath_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_ath_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_ann_the') case ('rho_dot_ann_the')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_the_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_the_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_ann_the_edge') case ('rho_dot_ann_the_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_the_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_the_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_ann_the_screw') case ('rho_dot_ann_the_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_the_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_ann_the_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_edgejogs') case ('rho_dot_edgejogs')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_edgejogs_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_edgejogs_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_flux') case ('rho_dot_flux')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_flux_mobile') case ('rho_dot_flux_mobile')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_mobile_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_mobile_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_flux_edge') case ('rho_dot_flux_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rho_dot_flux_screw') case ('rho_dot_flux_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = rho_dot_flux_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('velocity_edge_pos') case ('velocity_edge_pos')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_edge_pos_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_edge_pos_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('velocity_edge_neg') case ('velocity_edge_neg')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_edge_neg_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_edge_neg_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('velocity_screw_pos') case ('velocity_screw_pos')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_screw_pos_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_screw_pos_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('velocity_screw_neg') case ('velocity_screw_neg')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_screw_neg_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = velocity_screw_neg_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('slipdirection.x') case ('slipdirection.x')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipdirectionx_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipdirectionx_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('slipdirection.y') case ('slipdirection.y')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipdirectiony_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipdirectiony_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('slipdirection.z') case ('slipdirection.z')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipdirectionz_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipdirectionz_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('slipnormal.x') case ('slipnormal.x')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipnormalx_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipnormalx_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('slipnormal.y') case ('slipnormal.y')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipnormaly_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipnormaly_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('slipnormal.z') case ('slipnormal.z')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipnormalz_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = slipnormalz_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_edge_pos.x') case ('fluxdensity_edge_pos.x')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_posx_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_posx_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_edge_pos.y') case ('fluxdensity_edge_pos.y')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_posy_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_posy_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_edge_pos.z') case ('fluxdensity_edge_pos.z')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_posz_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_posz_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_edge_neg.x') case ('fluxdensity_edge_neg.x')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_negx_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_negx_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_edge_neg.y') case ('fluxdensity_edge_neg.y')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_negy_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_negy_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_edge_neg.z') case ('fluxdensity_edge_neg.z')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_negz_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_edge_negz_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_screw_pos.x') case ('fluxdensity_screw_pos.x')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_posx_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_posx_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_screw_pos.y') case ('fluxdensity_screw_pos.y')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_posy_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_posy_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_screw_pos.z') case ('fluxdensity_screw_pos.z')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_posz_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_posz_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_screw_neg.x') case ('fluxdensity_screw_neg.x')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_negx_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_negx_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_screw_neg.y') case ('fluxdensity_screw_neg.y')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_negy_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_negy_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('fluxdensity_screw_neg.z') case ('fluxdensity_screw_neg.z')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_negz_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = fluxdensity_screw_negz_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('maximumdipoleheight_edge') case ('maximumdipoleheight_edge')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = maximumdipoleheight_edge_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = maximumdipoleheight_edge_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('maximumdipoleheight_screw') case ('maximumdipoleheight_screw')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = maximumdipoleheight_screw_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = maximumdipoleheight_screw_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulatedshear','accumulated_shear') case ('accumulatedshear','accumulated_shear')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = accumulatedshear_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = accumulatedshear_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('dislocationstress') case ('dislocationstress')
plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt plastic_nonlocal_Noutput(instance) = plastic_nonlocal_Noutput(instance) + 1_pInt
plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = dislocationstress_ID plastic_nonlocal_outputID(plastic_nonlocal_Noutput(instance),instance) = dislocationstress_ID
plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = & plastic_nonlocal_output(plastic_nonlocal_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('nslip') case ('nslip')
if (positions(1) < 1_pInt + Nchunks_SlipFamilies) & if (chunkPos(1) < 1_pInt + Nchunks_SlipFamilies) &
call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_NONLOCAL_LABEL//')') call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_NONLOCAL_LABEL//')')
Nchunks_SlipFamilies = positions(1) - 1_pInt Nchunks_SlipFamilies = chunkPos(1) - 1_pInt
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
Nslip(f,instance) = IO_intValue(line,positions,1_pInt+f) Nslip(f,instance) = IO_intValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('rhosgledgepos0') case ('rhosgledgepos0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
rhoSglEdgePos0(f,instance) = IO_floatValue(line,positions,1_pInt+f) rhoSglEdgePos0(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('rhosgledgeneg0') case ('rhosgledgeneg0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
rhoSglEdgeNeg0(f,instance) = IO_floatValue(line,positions,1_pInt+f) rhoSglEdgeNeg0(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('rhosglscrewpos0') case ('rhosglscrewpos0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
rhoSglScrewPos0(f,instance) = IO_floatValue(line,positions,1_pInt+f) rhoSglScrewPos0(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('rhosglscrewneg0') case ('rhosglscrewneg0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
rhoSglScrewNeg0(f,instance) = IO_floatValue(line,positions,1_pInt+f) rhoSglScrewNeg0(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('rhodipedge0') case ('rhodipedge0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
rhoDipEdge0(f,instance) = IO_floatValue(line,positions,1_pInt+f) rhoDipEdge0(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('rhodipscrew0') case ('rhodipscrew0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
rhoDipScrew0(f,instance) = IO_floatValue(line,positions,1_pInt+f) rhoDipScrew0(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('lambda0') case ('lambda0')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
lambda0PerSlipFamily(f,instance) = IO_floatValue(line,positions,1_pInt+f) lambda0PerSlipFamily(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case ('burgers') case ('burgers')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
burgersPerSlipFamily(f,instance) = IO_floatValue(line,positions,1_pInt+f) burgersPerSlipFamily(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case('cutoffradius','r') case('cutoffradius','r')
cutoffRadius(instance) = IO_floatValue(line,positions,2_pInt) cutoffRadius(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('minimumdipoleheightedge','ddipminedge') case('minimumdipoleheightedge','ddipminedge')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
minDipoleHeightPerSlipFamily(f,1_pInt,instance) = IO_floatValue(line,positions,1_pInt+f) minDipoleHeightPerSlipFamily(f,1_pInt,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case('minimumdipoleheightscrew','ddipminscrew') case('minimumdipoleheightscrew','ddipminscrew')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
minDipoleHeightPerSlipFamily(f,2_pInt,instance) = IO_floatValue(line,positions,1_pInt+f) minDipoleHeightPerSlipFamily(f,2_pInt,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case('atomicvolume') case('atomicvolume')
atomicVolume(instance) = IO_floatValue(line,positions,2_pInt) atomicVolume(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('selfdiffusionprefactor','dsd0') case('selfdiffusionprefactor','dsd0')
Dsd0(instance) = IO_floatValue(line,positions,2_pInt) Dsd0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('selfdiffusionenergy','qsd') case('selfdiffusionenergy','qsd')
selfDiffusionEnergy(instance) = IO_floatValue(line,positions,2_pInt) selfDiffusionEnergy(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('atol_rho','atol_density','absolutetolerancedensity','absolutetolerance_density') case('atol_rho','atol_density','absolutetolerancedensity','absolutetolerance_density')
aTolRho(instance) = IO_floatValue(line,positions,2_pInt) aTolRho(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('atol_shear','atol_plasticshear','atol_accumulatedshear','absolutetoleranceshear','absolutetolerance_shear') case('atol_shear','atol_plasticshear','atol_accumulatedshear','absolutetoleranceshear','absolutetolerance_shear')
aTolShear(instance) = IO_floatValue(line,positions,2_pInt) aTolShear(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('significantrho','significant_rho','significantdensity','significant_density') case('significantrho','significant_rho','significantdensity','significant_density')
significantRho(instance) = IO_floatValue(line,positions,2_pInt) significantRho(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('significantn','significant_n','significantdislocations','significant_dislcations') case('significantn','significant_n','significantdislocations','significant_dislcations')
significantN(instance) = IO_floatValue(line,positions,2_pInt) significantN(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('interaction_slipslip') case ('interaction_slipslip')
if (positions(1) < 1_pInt + Nchunks_SlipSlip) & if (chunkPos(1) < 1_pInt + Nchunks_SlipSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_NONLOCAL_LABEL//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_NONLOCAL_LABEL//')')
do it = 1_pInt,Nchunks_SlipSlip do it = 1_pInt,Nchunks_SlipSlip
interactionSlipSlip(it,instance) = IO_floatValue(line,positions,1_pInt+it) interactionSlipSlip(it,instance) = IO_floatValue(line,chunkPos,1_pInt+it)
enddo enddo
case('linetension','linetensioneffect','linetension_effect') case('linetension','linetensioneffect','linetension_effect')
linetensionEffect(instance) = IO_floatValue(line,positions,2_pInt) linetensionEffect(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('edgejog','edgejogs','edgejogeffect','edgejog_effect') case('edgejog','edgejogs','edgejogeffect','edgejog_effect')
edgeJogFactor(instance) = IO_floatValue(line,positions,2_pInt) edgeJogFactor(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('peierlsstressedge','peierlsstress_edge') case('peierlsstressedge','peierlsstress_edge')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
peierlsStressPerSlipFamily(f,1_pInt,instance) = IO_floatValue(line,positions,1_pInt+f) peierlsStressPerSlipFamily(f,1_pInt,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case('peierlsstressscrew','peierlsstress_screw') case('peierlsstressscrew','peierlsstress_screw')
do f = 1_pInt, Nchunks_SlipFamilies do f = 1_pInt, Nchunks_SlipFamilies
peierlsStressPerSlipFamily(f,2_pInt,instance) = IO_floatValue(line,positions,1_pInt+f) peierlsStressPerSlipFamily(f,2_pInt,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case('doublekinkwidth') case('doublekinkwidth')
doublekinkwidth(instance) = IO_floatValue(line,positions,2_pInt) doublekinkwidth(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('solidsolutionenergy') case('solidsolutionenergy')
solidSolutionEnergy(instance) = IO_floatValue(line,positions,2_pInt) solidSolutionEnergy(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('solidsolutionsize') case('solidsolutionsize')
solidSolutionSize(instance) = IO_floatValue(line,positions,2_pInt) solidSolutionSize(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('solidsolutionconcentration') case('solidsolutionconcentration')
solidSolutionConcentration(instance) = IO_floatValue(line,positions,2_pInt) solidSolutionConcentration(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('p') case('p')
pParam(instance) = IO_floatValue(line,positions,2_pInt) pParam(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('q') case('q')
qParam(instance) = IO_floatValue(line,positions,2_pInt) qParam(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('viscosity','glideviscosity') case('viscosity','glideviscosity')
viscosity(instance) = IO_floatValue(line,positions,2_pInt) viscosity(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('attackfrequency','fattack') case('attackfrequency','fattack')
fattack(instance) = IO_floatValue(line,positions,2_pInt) fattack(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('rhosglscatter') case('rhosglscatter')
rhoSglScatter(instance) = IO_floatValue(line,positions,2_pInt) rhoSglScatter(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('rhosglrandom') case('rhosglrandom')
rhoSglRandom(instance) = IO_floatValue(line,positions,2_pInt) rhoSglRandom(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('rhosglrandombinning') case('rhosglrandombinning')
rhoSglRandomBinning(instance) = IO_floatValue(line,positions,2_pInt) rhoSglRandomBinning(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('surfacetransmissivity') case('surfacetransmissivity')
surfaceTransmissivity(instance) = IO_floatValue(line,positions,2_pInt) surfaceTransmissivity(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('grainboundarytransmissivity') case('grainboundarytransmissivity')
grainboundaryTransmissivity(instance) = IO_floatValue(line,positions,2_pInt) grainboundaryTransmissivity(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('cflfactor') case('cflfactor')
CFLfactor(instance) = IO_floatValue(line,positions,2_pInt) CFLfactor(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('fedgemultiplication','edgemultiplicationfactor','edgemultiplication') case('fedgemultiplication','edgemultiplicationfactor','edgemultiplication')
fEdgeMultiplication(instance) = IO_floatValue(line,positions,2_pInt) fEdgeMultiplication(instance) = IO_floatValue(line,chunkPos,2_pInt)
case('shortrangestresscorrection') case('shortrangestresscorrection')
shortRangeStressCorrection(instance) = IO_floatValue(line,positions,2_pInt) > 0.0_pReal shortRangeStressCorrection(instance) = IO_floatValue(line,chunkPos,2_pInt) > 0.0_pReal
case ('nonschmid_coefficients') case ('nonschmid_coefficients')
if (positions(1) < 1_pInt + Nchunks_nonSchmid) & if (chunkPos(1) < 1_pInt + Nchunks_nonSchmid) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_NONLOCAL_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_NONLOCAL_label//')')
do f = 1_pInt,Nchunks_nonSchmid do f = 1_pInt,Nchunks_nonSchmid
nonSchmidCoeff(f,instance) = IO_floatValue(line,positions,1_pInt+f) nonSchmidCoeff(f,instance) = IO_floatValue(line,chunkPos,1_pInt+f)
enddo enddo
case('probabilisticmultiplication','randomsources','randommultiplication','discretesources') case('probabilisticmultiplication','randomsources','randommultiplication','discretesources')
probabilisticMultiplication(instance) = IO_floatValue(line,positions,2_pInt) > 0.0_pReal probabilisticMultiplication(instance) = IO_floatValue(line,chunkPos,2_pInt) > 0.0_pReal
end select end select
endif; endif endif; endif
enddo parsingFile enddo parsingFile

119
code/plastic_phenopowerlaw.f90
View File

@ -147,8 +147,7 @@ subroutine plastic_phenopowerlaw_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = LATTICE_maxNinteraction + 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions
integer(pInt) :: & integer(pInt) :: &
maxNinstance, & maxNinstance, &
instance,phase,j,k, f,o, & instance,phase,j,k, f,o, &
@ -259,80 +258,80 @@ subroutine plastic_phenopowerlaw_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_PHENOPOWERLAW_ID) then ! one of my phases. Do not short-circuit here (.and. between if-statements), it's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_PHENOPOWERLAW_ID) then ! one of my phases. Do not short-circuit here (.and. between if-statements), it's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('resistance_slip') case ('resistance_slip')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resistance_slip_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resistance_slip_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulatedshear_slip','accumulated_shear_slip') case ('accumulatedshear_slip','accumulated_shear_slip')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = accumulatedshear_slip_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = accumulatedshear_slip_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shearrate_slip') case ('shearrate_slip')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = shearrate_slip_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = shearrate_slip_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolvedstress_slip') case ('resolvedstress_slip')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resolvedstress_slip_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resolvedstress_slip_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('totalshear') case ('totalshear')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = totalshear_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = totalshear_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resistance_twin') case ('resistance_twin')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resistance_twin_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resistance_twin_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('accumulatedshear_twin','accumulated_shear_twin') case ('accumulatedshear_twin','accumulated_shear_twin')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = accumulatedshear_twin_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = accumulatedshear_twin_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shearrate_twin') case ('shearrate_twin')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = shearrate_twin_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = shearrate_twin_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resolvedstress_twin') case ('resolvedstress_twin')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resolvedstress_twin_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = resolvedstress_twin_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('totalvolfrac_twin') case ('totalvolfrac_twin')
plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt plastic_phenopowerlaw_Noutput(instance) = plastic_phenopowerlaw_Noutput(instance) + 1_pInt
plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = totalvolfrac_twin_ID plastic_phenopowerlaw_outputID(plastic_phenopowerlaw_Noutput(instance),instance) = totalvolfrac_twin_ID
plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = & plastic_phenopowerlaw_output(plastic_phenopowerlaw_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case default case default
end select end select
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of slip families ! parameters depending on number of slip families
case ('nslip') case ('nslip')
if (positions(1) < Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_SlipFamilies + 1_pInt) &
call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (positions(1) > Nchunks_SlipFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_SlipFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
Nchunks_SlipFamilies = positions(1) - 1_pInt ! user specified number of (possibly) active slip families (e.g. 6 0 6 --> 3) Nchunks_SlipFamilies = chunkPos(1) - 1_pInt ! user specified number of (possibly) active slip families (e.g. 6 0 6 --> 3)
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_phenopowerlaw_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_phenopowerlaw_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('tausat_slip','tau0_slip') case ('tausat_slip','tau0_slip')
tempPerSlip = 0.0_pReal tempPerSlip = 0.0_pReal
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
if (plastic_phenopowerlaw_Nslip(j,instance) > 0_pInt) & if (plastic_phenopowerlaw_Nslip(j,instance) > 0_pInt) &
tempPerSlip(j) = IO_floatValue(line,positions,1_pInt+j) tempPerSlip(j) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
select case(tag) select case(tag)
case ('tausat_slip') case ('tausat_slip')
@ -343,105 +342,105 @@ subroutine plastic_phenopowerlaw_init(fileUnit)
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of twin families ! parameters depending on number of twin families
case ('ntwin') case ('ntwin')
if (positions(1) < Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_TwinFamilies + 1_pInt) &
call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (positions(1) > Nchunks_TwinFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_TwinFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
Nchunks_TwinFamilies = positions(1) - 1_pInt Nchunks_TwinFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_phenopowerlaw_Ntwin(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_phenopowerlaw_Ntwin(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('tau0_twin') case ('tau0_twin')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
if (plastic_phenopowerlaw_Ntwin(j,instance) > 0_pInt) & if (plastic_phenopowerlaw_Ntwin(j,instance) > 0_pInt) &
plastic_phenopowerlaw_tau0_twin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_phenopowerlaw_tau0_twin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of transformation families ! parameters depending on number of transformation families
case ('ntrans') case ('ntrans')
if (positions(1) < Nchunks_TransFamilies + 1_pInt) & if (chunkPos(1) < Nchunks_TransFamilies + 1_pInt) &
call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
if (positions(1) > Nchunks_TransFamilies + 1_pInt) & if (chunkPos(1) > Nchunks_TransFamilies + 1_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
Nchunks_TransFamilies = positions(1) - 1_pInt Nchunks_TransFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_TransFamilies do j = 1_pInt, Nchunks_TransFamilies
plastic_phenopowerlaw_Ntrans(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_phenopowerlaw_Ntrans(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters depending on number of interactions ! parameters depending on number of interactions
case ('interaction_sliptwin') case ('interaction_sliptwin')
if (positions(1) < 1_pInt + Nchunks_SlipTwin) & if (chunkPos(1) < 1_pInt + Nchunks_SlipTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
do j = 1_pInt, Nchunks_SlipTwin do j = 1_pInt, Nchunks_SlipTwin
plastic_phenopowerlaw_interaction_SlipTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_phenopowerlaw_interaction_SlipTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twinslip') case ('interaction_twinslip')
if (positions(1) < 1_pInt + Nchunks_TwinSlip) & if (chunkPos(1) < 1_pInt + Nchunks_TwinSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
do j = 1_pInt, Nchunks_TwinSlip do j = 1_pInt, Nchunks_TwinSlip
plastic_phenopowerlaw_interaction_TwinSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_phenopowerlaw_interaction_TwinSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twintwin') case ('interaction_twintwin')
if (positions(1) < 1_pInt + Nchunks_TwinTwin) & if (chunkPos(1) < 1_pInt + Nchunks_TwinTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
do j = 1_pInt, Nchunks_TwinTwin do j = 1_pInt, Nchunks_TwinTwin
plastic_phenopowerlaw_interaction_TwinTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_phenopowerlaw_interaction_TwinTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('nonschmid_coefficients') case ('nonschmid_coefficients')
if (positions(1) < 1_pInt + Nchunks_nonSchmid) & if (chunkPos(1) < 1_pInt + Nchunks_nonSchmid) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
do j = 1_pInt,Nchunks_nonSchmid do j = 1_pInt,Nchunks_nonSchmid
plastic_phenopowerlaw_nonSchmidCoeff(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_phenopowerlaw_nonSchmidCoeff(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
!-------------------------------------------------------------------------------------------------- !--------------------------------------------------------------------------------------------------
! parameters independent of number of slip/twin systems ! parameters independent of number of slip/twin systems
case ('gdot0_slip') case ('gdot0_slip')
plastic_phenopowerlaw_gdot0_slip(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_gdot0_slip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('n_slip') case ('n_slip')
plastic_phenopowerlaw_n_slip(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_n_slip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('a_slip', 'w0_slip') case ('a_slip', 'w0_slip')
plastic_phenopowerlaw_a_slip(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_a_slip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('gdot0_twin') case ('gdot0_twin')
plastic_phenopowerlaw_gdot0_twin(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_gdot0_twin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('n_twin') case ('n_twin')
plastic_phenopowerlaw_n_twin(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_n_twin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('s_pr') case ('s_pr')
plastic_phenopowerlaw_spr(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_spr(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('twin_b') case ('twin_b')
plastic_phenopowerlaw_twinB(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_twinB(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('twin_c') case ('twin_c')
plastic_phenopowerlaw_twinC(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_twinC(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('twin_d') case ('twin_d')
plastic_phenopowerlaw_twinD(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_twinD(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('twin_e') case ('twin_e')
plastic_phenopowerlaw_twinE(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_twinE(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('h0_slipslip') case ('h0_slipslip')
plastic_phenopowerlaw_h0_SlipSlip(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_h0_SlipSlip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('h0_twinslip') case ('h0_twinslip')
plastic_phenopowerlaw_h0_TwinSlip(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_h0_TwinSlip(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('h0_twintwin') case ('h0_twintwin')
plastic_phenopowerlaw_h0_TwinTwin(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_h0_TwinTwin(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_resistance') case ('atol_resistance')
plastic_phenopowerlaw_aTolResistance(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_aTolResistance(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_shear') case ('atol_shear')
plastic_phenopowerlaw_aTolShear(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_aTolShear(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_twinfrac') case ('atol_twinfrac')
plastic_phenopowerlaw_aTolTwinfrac(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_aTolTwinfrac(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_transfrac') case ('atol_transfrac')
plastic_phenopowerlaw_aTolTransfrac(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_aTolTransfrac(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cnuc') case ('cnuc')
plastic_phenopowerlaw_Cnuc(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_Cnuc(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cdwp') case ('cdwp')
plastic_phenopowerlaw_Cdwp(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_Cdwp(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('cgro') case ('cgro')
plastic_phenopowerlaw_Cgro(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_Cgro(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('deltag') case ('deltag')
plastic_phenopowerlaw_deltaG(instance) = IO_floatValue(line,positions,2_pInt) plastic_phenopowerlaw_deltaG(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('interaction_slipslip') case ('interaction_slipslip')
if (positions(1) < 1_pInt + Nchunks_SlipSlip) & if (chunkPos(1) < 1_pInt + Nchunks_SlipSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_PHENOPOWERLAW_label//')')
do j = 1_pInt, Nchunks_SlipSlip do j = 1_pInt, Nchunks_SlipSlip
plastic_phenopowerlaw_interaction_SlipSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_phenopowerlaw_interaction_SlipSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case default case default

163
code/plastic_titanmod.f90
View File

@ -224,8 +224,7 @@ subroutine plastic_titanmod_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = LATTICE_maxNinteraction + 1_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1_pInt+2_pInt*MAXNCHUNKS) :: positions
integer(pInt) :: & integer(pInt) :: &
phase, & phase, &
instance, j, k, l, m, n, p, q, r, & instance, j, k, l, m, n, p, q, r, &
@ -347,322 +346,322 @@ subroutine plastic_titanmod_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_TITANMOD_ID) then ! one of my sections. Do not short-circuit here (.and. between if-statements), it's not safe in Fortran if (phase > 0_pInt ) then; if (phase_plasticity(phase) == PLASTICITY_TITANMOD_ID) then ! one of my sections. Do not short-circuit here (.and. between if-statements), it's not safe in Fortran
instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase instance = phase_plasticityInstance(phase) ! which instance of my plasticity is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('rhoedge') case ('rhoedge')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoscrew') case ('rhoscrew')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('segment_edge') case ('segment_edge')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = segment_edge_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = segment_edge_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('segment_screw') case ('segment_screw')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = segment_screw_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = segment_screw_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resistance_edge') case ('resistance_edge')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = resistance_edge_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = resistance_edge_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('resistance_screw') case ('resistance_screw')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = resistance_screw_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = resistance_screw_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('velocity_edge') case ('velocity_edge')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = velocity_edge_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = velocity_edge_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('velocity_screw') case ('velocity_screw')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = velocity_screw_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = velocity_screw_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('tau_slip') case ('tau_slip')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = tau_slip_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = tau_slip_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('gdot_slip_edge') case ('gdot_slip_edge')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = gdot_slip_edge_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = gdot_slip_edge_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('gdot_slip_screw') case ('gdot_slip_screw')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = gdot_slip_screw_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = gdot_slip_screw_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('gdot_slip') case ('gdot_slip')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = gdot_slip_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = gdot_slip_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('stressratio_edge_p') case ('stressratio_edge_p')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = stressratio_edge_p_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = stressratio_edge_p_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('stressratio_screw_p') case ('stressratio_screw_p')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = stressratio_screw_p_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = stressratio_screw_p_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_system') case ('shear_system')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_system_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_system_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('twin_fraction') case ('twin_fraction')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = twin_fraction_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = twin_fraction_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_basal') case ('shear_basal')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_basal_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_basal_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_prism') case ('shear_prism')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_prism_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_prism_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_pyra') case ('shear_pyra')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_pyra_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_pyra_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_pyrca') case ('shear_pyrca')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_pyrca_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_pyrca_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoedge_basal') case ('rhoedge_basal')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_basal_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_basal_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoedge_prism') case ('rhoedge_prism')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_prism_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_prism_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoedge_pyra') case ('rhoedge_pyra')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_pyra_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_pyra_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoedge_pyrca') case ('rhoedge_pyrca')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_pyrca_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoedge_pyrca_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoscrew_basal') case ('rhoscrew_basal')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_basal_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_basal_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoscrew_prism') case ('rhoscrew_prism')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_prism_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_prism_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoscrew_pyra') case ('rhoscrew_pyra')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_pyra_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_pyra_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('rhoscrew_pyrca') case ('rhoscrew_pyrca')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_pyrca_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = rhoscrew_pyrca_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
case ('shear_total') case ('shear_total')
plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt plastic_titanmod_Noutput(instance) = plastic_titanmod_Noutput(instance) + 1_pInt
plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_total_ID plastic_titanmod_outputID(plastic_titanmod_Noutput(instance),instance) = shear_total_ID
plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = & plastic_titanmod_output(plastic_titanmod_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('debyefrequency') case ('debyefrequency')
plastic_titanmod_debyefrequency(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_debyefrequency(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('kinkf0') case ('kinkf0')
plastic_titanmod_kinkf0(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_kinkf0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('nslip') case ('nslip')
if (positions(1) < 1_pInt + Nchunks_SlipFamilies) & if (chunkPos(1) < 1_pInt + Nchunks_SlipFamilies) &
call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')') call IO_warning(50_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_titanmod_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('ntwin') case ('ntwin')
if (positions(1) < 1_pInt + Nchunks_TwinFamilies) & if (chunkPos(1) < 1_pInt + Nchunks_TwinFamilies) &
call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')') call IO_warning(51_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_Ntwin(j,instance) = IO_intValue(line,positions,1_pInt+j) plastic_titanmod_Ntwin(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('rho_edge0') case ('rho_edge0')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_rho_edge0(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_rho_edge0(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('rho_screw0') case ('rho_screw0')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_rho_screw0(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_rho_screw0(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('slipburgers') case ('slipburgers')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_burgersPerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_burgersPerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinburgers') case ('twinburgers')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_burgersPerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_burgersPerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('f0') case ('f0')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_f0_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_f0_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinf0') case ('twinf0')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twinf0_PerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twinf0_PerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('tau0e') case ('tau0e')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_tau0e_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_tau0e_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twintau0') case ('twintau0')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twintau0_PerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twintau0_PerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('tau0s') case ('tau0s')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_tau0s_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_tau0s_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('capre') case ('capre')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_capre_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_capre_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('caprs') case ('caprs')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_caprs_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_caprs_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('v0e') case ('v0e')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_v0e_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_v0e_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twingamma0') case ('twingamma0')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twingamma0_PerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twingamma0_PerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('v0s') case ('v0s')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_v0s_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_v0s_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('kinkcriticallength') case ('kinkcriticallength')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_kinkcriticallength_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_kinkcriticallength_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinsize') case ('twinsize')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twinsizePerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twinsizePerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('celambdaslip') case ('celambdaslip')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_CeLambdaSlipPerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_CeLambdaSlipPerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinlambdaslip') case ('twinlambdaslip')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twinlambdaslipPerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twinlambdaslipPerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('cslambdaslip') case ('cslambdaslip')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_CsLambdaSlipPerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_CsLambdaSlipPerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('grainsize') case ('grainsize')
plastic_titanmod_GrainSize(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_GrainSize(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('maxtwinfraction') case ('maxtwinfraction')
plastic_titanmod_MaxTwinFraction(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_MaxTwinFraction(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('pe') case ('pe')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_pe_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_pe_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinp') case ('twinp')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twinp_PerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twinp_PerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('ps') case ('ps')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_ps_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_ps_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('qe') case ('qe')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_qe_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_qe_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinq') case ('twinq')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twinq_PerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twinq_PerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('qs') case ('qs')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
plastic_titanmod_qs_PerSlipFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_qs_PerSlipFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('twinshearconstant') case ('twinshearconstant')
do j = 1_pInt, Nchunks_TwinFamilies do j = 1_pInt, Nchunks_TwinFamilies
plastic_titanmod_twinshearconstant_PerTwinFam(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_twinshearconstant_PerTwinFam(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('dc') case ('dc')
plastic_titanmod_dc(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_dc(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('twinhpconstant') case ('twinhpconstant')
plastic_titanmod_twinhpconstant(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_twinhpconstant(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('atol_rho') case ('atol_rho')
plastic_titanmod_aTolRho(instance) = IO_floatValue(line,positions,2_pInt) plastic_titanmod_aTolRho(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('interactionee') case ('interactionee')
do j = 1_pInt, lattice_maxNinteraction do j = 1_pInt, lattice_maxNinteraction
plastic_titanmod_interaction_ee(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interaction_ee(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interactionss') case ('interactionss')
do j = 1_pInt, lattice_maxNinteraction do j = 1_pInt, lattice_maxNinteraction
plastic_titanmod_interaction_ss(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interaction_ss(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interactiones') case ('interactiones')
do j = 1_pInt, lattice_maxNinteraction do j = 1_pInt, lattice_maxNinteraction
plastic_titanmod_interaction_es(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interaction_es(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_slipslip','interactionslipslip') case ('interaction_slipslip','interactionslipslip')
if (positions(1) < 1_pInt + Nchunks_SlipSlip) & if (chunkPos(1) < 1_pInt + Nchunks_SlipSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')')
do j = 1_pInt, Nchunks_SlipSlip do j = 1_pInt, Nchunks_SlipSlip
plastic_titanmod_interactionSlipSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interactionSlipSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_sliptwin','interactionsliptwin') case ('interaction_sliptwin','interactionsliptwin')
if (positions(1) < 1_pInt + Nchunks_SlipTwin) & if (chunkPos(1) < 1_pInt + Nchunks_SlipTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')')
do j = 1_pInt, Nchunks_SlipTwin do j = 1_pInt, Nchunks_SlipTwin
plastic_titanmod_interactionSlipTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interactionSlipTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twinslip','interactiontwinslip') case ('interaction_twinslip','interactiontwinslip')
if (positions(1) < 1_pInt + Nchunks_TwinSlip) & if (chunkPos(1) < 1_pInt + Nchunks_TwinSlip) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')')
do j = 1_pInt, Nchunks_TwinSlip do j = 1_pInt, Nchunks_TwinSlip
plastic_titanmod_interactionTwinSlip(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interactionTwinSlip(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('interaction_twintwin','interactiontwintwin') case ('interaction_twintwin','interactiontwintwin')
if (positions(1) < 1_pInt + Nchunks_TwinTwin) & if (chunkPos(1) < 1_pInt + Nchunks_TwinTwin) &
call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')') call IO_warning(52_pInt,ext_msg=trim(tag)//' ('//PLASTICITY_TITANMOD_label//')')
do j = 1_pInt, Nchunks_TwinTwin do j = 1_pInt, Nchunks_TwinTwin
plastic_titanmod_interactionTwinTwin(j,instance) = IO_floatValue(line,positions,1_pInt+j) plastic_titanmod_interactionTwinTwin(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
end select end select
endif; endif endif; endif

11
code/porosity_phasefield.f90
View File

@ -84,8 +84,7 @@ subroutine porosity_phasefield_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -131,16 +130,16 @@ subroutine porosity_phasefield_init(fileUnit)
if (section > 0_pInt ) then; if (porosity_type(section) == POROSITY_phasefield_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (porosity_type(section) == POROSITY_phasefield_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = porosity_typeInstance(section) ! which instance of my porosity is present homog instance = porosity_typeInstance(section) ! which instance of my porosity is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('porosity') case ('porosity')
porosity_phasefield_Noutput(instance) = porosity_phasefield_Noutput(instance) + 1_pInt porosity_phasefield_Noutput(instance) = porosity_phasefield_Noutput(instance) + 1_pInt
porosity_phasefield_outputID(porosity_phasefield_Noutput(instance),instance) = porosity_ID porosity_phasefield_outputID(porosity_phasefield_Noutput(instance),instance) = porosity_ID
porosity_phasefield_output(porosity_phasefield_Noutput(instance),instance) = & porosity_phasefield_output(porosity_phasefield_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

25
code/source_damage_anisoBrittle.f90
View File

@ -103,8 +103,7 @@ subroutine source_damage_anisoBrittle_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -169,41 +168,41 @@ subroutine source_damage_anisoBrittle_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_anisoBrittle_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_anisoBrittle_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_damage_anisoBrittle_instance(phase) ! which instance of my damage is present phase instance = source_damage_anisoBrittle_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('anisobrittle_drivingforce') case ('anisobrittle_drivingforce')
source_damage_anisoBrittle_Noutput(instance) = source_damage_anisoBrittle_Noutput(instance) + 1_pInt source_damage_anisoBrittle_Noutput(instance) = source_damage_anisoBrittle_Noutput(instance) + 1_pInt
source_damage_anisoBrittle_outputID(source_damage_anisoBrittle_Noutput(instance),instance) = damage_drivingforce_ID source_damage_anisoBrittle_outputID(source_damage_anisoBrittle_Noutput(instance),instance) = damage_drivingforce_ID
source_damage_anisoBrittle_output(source_damage_anisoBrittle_Noutput(instance),instance) = & source_damage_anisoBrittle_output(source_damage_anisoBrittle_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('anisobrittle_atol') case ('anisobrittle_atol')
source_damage_anisoBrittle_aTol(instance) = IO_floatValue(line,positions,2_pInt) source_damage_anisoBrittle_aTol(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisobrittle_sdot0') case ('anisobrittle_sdot0')
source_damage_anisoBrittle_sdot_0(instance) = IO_floatValue(line,positions,2_pInt) source_damage_anisoBrittle_sdot_0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisobrittle_ratesensitivity') case ('anisobrittle_ratesensitivity')
source_damage_anisoBrittle_N(instance) = IO_floatValue(line,positions,2_pInt) source_damage_anisoBrittle_N(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('ncleavage') ! case ('ncleavage') !
Nchunks_CleavageFamilies = positions(1) - 1_pInt Nchunks_CleavageFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_CleavageFamilies do j = 1_pInt, Nchunks_CleavageFamilies
source_damage_anisoBrittle_Ncleavage(j,instance) = IO_intValue(line,positions,1_pInt+j) source_damage_anisoBrittle_Ncleavage(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisobrittle_criticaldisplacement') case ('anisobrittle_criticaldisplacement')
do j = 1_pInt, Nchunks_CleavageFamilies do j = 1_pInt, Nchunks_CleavageFamilies
source_damage_anisoBrittle_critDisp(j,instance) = IO_floatValue(line,positions,1_pInt+j) source_damage_anisoBrittle_critDisp(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisobrittle_criticalload') case ('anisobrittle_criticalload')
do j = 1_pInt, Nchunks_CleavageFamilies do j = 1_pInt, Nchunks_CleavageFamilies
source_damage_anisoBrittle_critLoad(j,instance) = IO_floatValue(line,positions,1_pInt+j) source_damage_anisoBrittle_critLoad(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
end select end select

25
code/source_damage_anisoDuctile.f90
View File

@ -107,8 +107,7 @@ subroutine source_damage_anisoDuctile_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -173,41 +172,41 @@ subroutine source_damage_anisoDuctile_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_anisoDuctile_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_anisoDuctile_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_damage_anisoDuctile_instance(phase) ! which instance of my damage is present phase instance = source_damage_anisoDuctile_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('anisoductile_drivingforce') case ('anisoductile_drivingforce')
source_damage_anisoDuctile_Noutput(instance) = source_damage_anisoDuctile_Noutput(instance) + 1_pInt source_damage_anisoDuctile_Noutput(instance) = source_damage_anisoDuctile_Noutput(instance) + 1_pInt
source_damage_anisoDuctile_outputID(source_damage_anisoDuctile_Noutput(instance),instance) = damage_drivingforce_ID source_damage_anisoDuctile_outputID(source_damage_anisoDuctile_Noutput(instance),instance) = damage_drivingforce_ID
source_damage_anisoDuctile_output(source_damage_anisoDuctile_Noutput(instance),instance) = & source_damage_anisoDuctile_output(source_damage_anisoDuctile_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('anisoductile_atol') case ('anisoductile_atol')
source_damage_anisoDuctile_aTol(instance) = IO_floatValue(line,positions,2_pInt) source_damage_anisoDuctile_aTol(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('nslip') ! case ('nslip') !
Nchunks_SlipFamilies = positions(1) - 1_pInt Nchunks_SlipFamilies = chunkPos(1) - 1_pInt
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
source_damage_anisoDuctile_Nslip(j,instance) = IO_intValue(line,positions,1_pInt+j) source_damage_anisoDuctile_Nslip(j,instance) = IO_intValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisoductile_sdot0') case ('anisoductile_sdot0')
source_damage_anisoDuctile_sdot_0(instance) = IO_floatValue(line,positions,2_pInt) source_damage_anisoDuctile_sdot_0(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisoductile_criticalplasticstrain') case ('anisoductile_criticalplasticstrain')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
source_damage_anisoDuctile_critPlasticStrain(j,instance) = IO_floatValue(line,positions,1_pInt+j) source_damage_anisoDuctile_critPlasticStrain(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
case ('anisoductile_ratesensitivity') case ('anisoductile_ratesensitivity')
source_damage_anisoDuctile_N(instance) = IO_floatValue(line,positions,2_pInt) source_damage_anisoDuctile_N(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('anisoductile_criticalload') case ('anisoductile_criticalload')
do j = 1_pInt, Nchunks_SlipFamilies do j = 1_pInt, Nchunks_SlipFamilies
source_damage_anisoDuctile_critLoad(j,instance) = IO_floatValue(line,positions,1_pInt+j) source_damage_anisoDuctile_critLoad(j,instance) = IO_floatValue(line,chunkPos,1_pInt+j)
enddo enddo
end select end select

17
code/source_damage_isoBrittle.f90
View File

@ -90,8 +90,7 @@ subroutine source_damage_isoBrittle_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -151,26 +150,26 @@ subroutine source_damage_isoBrittle_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_isoBrittle_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_isoBrittle_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_damage_isoBrittle_instance(phase) ! which instance of my damage is present phase instance = source_damage_isoBrittle_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('isobrittle_drivingforce') case ('isobrittle_drivingforce')
source_damage_isoBrittle_Noutput(instance) = source_damage_isoBrittle_Noutput(instance) + 1_pInt source_damage_isoBrittle_Noutput(instance) = source_damage_isoBrittle_Noutput(instance) + 1_pInt
source_damage_isoBrittle_outputID(source_damage_isoBrittle_Noutput(instance),instance) = damage_drivingforce_ID source_damage_isoBrittle_outputID(source_damage_isoBrittle_Noutput(instance),instance) = damage_drivingforce_ID
source_damage_isoBrittle_output(source_damage_isoBrittle_Noutput(instance),instance) = & source_damage_isoBrittle_output(source_damage_isoBrittle_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('isobrittle_criticalstrainenergy') case ('isobrittle_criticalstrainenergy')
source_damage_isoBrittle_critStrainEnergy(instance) = IO_floatValue(line,positions,2_pInt) source_damage_isoBrittle_critStrainEnergy(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('isobrittle_n') case ('isobrittle_n')
source_damage_isoBrittle_N(instance) = IO_floatValue(line,positions,2_pInt) source_damage_isoBrittle_N(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('isobrittle_atol') case ('isobrittle_atol')
source_damage_isoBrittle_aTol(instance) = IO_floatValue(line,positions,2_pInt) source_damage_isoBrittle_aTol(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

17
code/source_damage_isoDuctile.f90
View File

@ -90,8 +90,7 @@ subroutine source_damage_isoDuctile_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o integer(pInt) :: maxNinstance,mySize=0_pInt,phase,instance,source,sourceOffset,o
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -151,26 +150,26 @@ subroutine source_damage_isoDuctile_init(fileUnit)
endif endif
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_isoDuctile_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_damage_isoDuctile_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_damage_isoDuctile_instance(phase) ! which instance of my damage is present phase instance = source_damage_isoDuctile_instance(phase) ! which instance of my damage is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('isoductile_drivingforce') case ('isoductile_drivingforce')
source_damage_isoDuctile_Noutput(instance) = source_damage_isoDuctile_Noutput(instance) + 1_pInt source_damage_isoDuctile_Noutput(instance) = source_damage_isoDuctile_Noutput(instance) + 1_pInt
source_damage_isoDuctile_outputID(source_damage_isoDuctile_Noutput(instance),instance) = damage_drivingforce_ID source_damage_isoDuctile_outputID(source_damage_isoDuctile_Noutput(instance),instance) = damage_drivingforce_ID
source_damage_isoDuctile_output(source_damage_isoDuctile_Noutput(instance),instance) = & source_damage_isoDuctile_output(source_damage_isoDuctile_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('isoductile_criticalplasticstrain') case ('isoductile_criticalplasticstrain')
source_damage_isoDuctile_critPlasticStrain(instance) = IO_floatValue(line,positions,2_pInt) source_damage_isoDuctile_critPlasticStrain(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('isoductile_ratesensitivity') case ('isoductile_ratesensitivity')
source_damage_isoDuctile_N(instance) = IO_floatValue(line,positions,2_pInt) source_damage_isoDuctile_N(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('isoductile_atol') case ('isoductile_atol')
source_damage_isoDuctile_aTol(instance) = IO_floatValue(line,positions,2_pInt) source_damage_isoDuctile_aTol(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

9
code/source_thermal_dissipation.f90
View File

@ -76,8 +76,7 @@ subroutine source_thermal_dissipation_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -135,11 +134,11 @@ subroutine source_thermal_dissipation_init(fileUnit)
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_thermal_dissipation_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_thermal_dissipation_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_thermal_dissipation_instance(phase) ! which instance of my source is present phase instance = source_thermal_dissipation_instance(phase) ! which instance of my source is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('dissipation_coldworkcoeff') case ('dissipation_coldworkcoeff')
source_thermal_dissipation_coldworkCoeff(instance) = IO_floatValue(line,positions,2_pInt) source_thermal_dissipation_coldworkCoeff(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

15
code/source_thermal_externalheat.f90
View File

@ -81,8 +81,7 @@ subroutine source_thermal_externalheat_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 1000_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase,interval integer(pInt) :: NofMyPhase,interval
@ -144,20 +143,20 @@ subroutine source_thermal_externalheat_init(fileUnit)
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_thermal_externalheat_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_thermal_externalheat_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_thermal_externalheat_instance(phase) ! which instance of my source is present phase instance = source_thermal_externalheat_instance(phase) ! which instance of my source is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('externalheat_time') case ('externalheat_time')
if (positions(1) <= 2_pInt) & if (chunkPos(1) <= 2_pInt) &
call IO_error(150_pInt,ext_msg=trim(tag)//' ('//SOURCE_thermal_externalheat_label//')') call IO_error(150_pInt,ext_msg=trim(tag)//' ('//SOURCE_thermal_externalheat_label//')')
source_thermal_externalheat_nIntervals(instance) = positions(1) - 2_pInt source_thermal_externalheat_nIntervals(instance) = chunkPos(1) - 2_pInt
do interval = 1, source_thermal_externalheat_nIntervals(instance) + 1_pInt do interval = 1, source_thermal_externalheat_nIntervals(instance) + 1_pInt
temp_time(instance, interval) = IO_floatValue(line,positions,1_pInt + interval) temp_time(instance, interval) = IO_floatValue(line,chunkPos,1_pInt + interval)
enddo enddo
case ('externalheat_rate') case ('externalheat_rate')
do interval = 1, source_thermal_externalheat_nIntervals(instance) + 1_pInt do interval = 1, source_thermal_externalheat_nIntervals(instance) + 1_pInt
temp_rate(instance, interval) = IO_floatValue(line,positions,1_pInt + interval) temp_rate(instance, interval) = IO_floatValue(line,chunkPos,1_pInt + interval)
enddo enddo
end select end select

11
code/source_vacancy_irradiation.f90
View File

@ -78,8 +78,7 @@ subroutine source_vacancy_irradiation_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -138,14 +137,14 @@ subroutine source_vacancy_irradiation_init(fileUnit)
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_vacancy_irradiation_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_vacancy_irradiation_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_vacancy_irradiation_instance(phase) ! which instance of my vacancy is present phase instance = source_vacancy_irradiation_instance(phase) ! which instance of my vacancy is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('irradiation_cascadeprobability') case ('irradiation_cascadeprobability')
source_vacancy_irradiation_cascadeProb(instance) = IO_floatValue(line,positions,2_pInt) source_vacancy_irradiation_cascadeProb(instance) = IO_floatValue(line,chunkPos,2_pInt)
case ('irradiation_cascadevolume') case ('irradiation_cascadevolume')
source_vacancy_irradiation_cascadeVolume(instance) = IO_floatValue(line,positions,2_pInt) source_vacancy_irradiation_cascadeVolume(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

9
code/source_vacancy_phenoplasticity.f90
View File

@ -76,8 +76,7 @@ subroutine source_vacancy_phenoplasticity_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -135,11 +134,11 @@ subroutine source_vacancy_phenoplasticity_init(fileUnit)
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_vacancy_phenoplasticity_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_vacancy_phenoplasticity_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_vacancy_phenoplasticity_instance(phase) ! which instance of my vacancy is present phase instance = source_vacancy_phenoplasticity_instance(phase) ! which instance of my vacancy is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('phenoplasticity_ratecoeff') case ('phenoplasticity_ratecoeff')
source_vacancy_phenoplasticity_rateCoeff(instance) = IO_floatValue(line,positions,2_pInt) source_vacancy_phenoplasticity_rateCoeff(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

9
code/source_vacancy_thermalfluc.f90
View File

@ -80,8 +80,7 @@ subroutine source_vacancy_thermalfluc_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset integer(pInt) :: maxNinstance,phase,instance,source,sourceOffset
integer(pInt) :: sizeState, sizeDotState, sizeDeltaState integer(pInt) :: sizeState, sizeDotState, sizeDeltaState
integer(pInt) :: NofMyPhase integer(pInt) :: NofMyPhase
@ -140,11 +139,11 @@ subroutine source_vacancy_thermalfluc_init(fileUnit)
if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_vacancy_thermalfluc_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (phase > 0_pInt ) then; if (any(phase_source(:,phase) == SOURCE_vacancy_thermalfluc_ID)) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = source_vacancy_thermalfluc_instance(phase) ! which instance of my vacancy is present phase instance = source_vacancy_thermalfluc_instance(phase) ! which instance of my vacancy is present phase
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('thermalfluctuation_amplitude') case ('thermalfluctuation_amplitude')
source_vacancy_thermalfluc_amplitude(instance) = IO_floatValue(line,positions,2_pInt) source_vacancy_thermalfluc_amplitude(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

11
code/thermal_adiabatic.f90
View File

@ -82,8 +82,7 @@ subroutine thermal_adiabatic_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -129,16 +128,16 @@ subroutine thermal_adiabatic_init(fileUnit)
if (section > 0_pInt ) then; if (thermal_type(section) == THERMAL_adiabatic_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (thermal_type(section) == THERMAL_adiabatic_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = thermal_typeInstance(section) ! which instance of my thermal is present homog instance = thermal_typeInstance(section) ! which instance of my thermal is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('temperature') case ('temperature')
thermal_adiabatic_Noutput(instance) = thermal_adiabatic_Noutput(instance) + 1_pInt thermal_adiabatic_Noutput(instance) = thermal_adiabatic_Noutput(instance) + 1_pInt
thermal_adiabatic_outputID(thermal_adiabatic_Noutput(instance),instance) = temperature_ID thermal_adiabatic_outputID(thermal_adiabatic_Noutput(instance),instance) = temperature_ID
thermal_adiabatic_output(thermal_adiabatic_Noutput(instance),instance) = & thermal_adiabatic_output(thermal_adiabatic_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

11
code/thermal_conduction.f90
View File

@ -83,8 +83,7 @@ subroutine thermal_conduction_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -130,16 +129,16 @@ subroutine thermal_conduction_init(fileUnit)
if (section > 0_pInt ) then; if (thermal_type(section) == THERMAL_conduction_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (thermal_type(section) == THERMAL_conduction_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = thermal_typeInstance(section) ! which instance of my thermal is present homog instance = thermal_typeInstance(section) ! which instance of my thermal is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('temperature') case ('temperature')
thermal_conduction_Noutput(instance) = thermal_conduction_Noutput(instance) + 1_pInt thermal_conduction_Noutput(instance) = thermal_conduction_Noutput(instance) + 1_pInt
thermal_conduction_outputID(thermal_conduction_Noutput(instance),instance) = temperature_ID thermal_conduction_outputID(thermal_conduction_Noutput(instance),instance) = temperature_ID
thermal_conduction_output(thermal_conduction_Noutput(instance),instance) = & thermal_conduction_output(thermal_conduction_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

13
code/vacancyflux_cahnhilliard.f90
View File

@ -98,8 +98,7 @@ subroutine vacancyflux_cahnhilliard_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o,offset integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o,offset
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -148,20 +147,20 @@ subroutine vacancyflux_cahnhilliard_init(fileUnit)
if (section > 0_pInt ) then; if (vacancyflux_type(section) == VACANCYFLUX_cahnhilliard_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (vacancyflux_type(section) == VACANCYFLUX_cahnhilliard_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = vacancyflux_typeInstance(section) ! which instance of my vacancyflux is present homog instance = vacancyflux_typeInstance(section) ! which instance of my vacancyflux is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('vacancyconc') case ('vacancyconc')
vacancyflux_cahnhilliard_Noutput(instance) = vacancyflux_cahnhilliard_Noutput(instance) + 1_pInt vacancyflux_cahnhilliard_Noutput(instance) = vacancyflux_cahnhilliard_Noutput(instance) + 1_pInt
vacancyflux_cahnhilliard_outputID(vacancyflux_cahnhilliard_Noutput(instance),instance) = vacancyConc_ID vacancyflux_cahnhilliard_outputID(vacancyflux_cahnhilliard_Noutput(instance),instance) = vacancyConc_ID
vacancyflux_cahnhilliard_output(vacancyflux_cahnhilliard_Noutput(instance),instance) = & vacancyflux_cahnhilliard_output(vacancyflux_cahnhilliard_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
case ('vacancyflux_flucamplitude') case ('vacancyflux_flucamplitude')
vacancyflux_cahnhilliard_flucAmplitude(instance) = IO_floatValue(line,positions,2_pInt) vacancyflux_cahnhilliard_flucAmplitude(instance) = IO_floatValue(line,chunkPos,2_pInt)
end select end select
endif; endif endif; endif

11
code/vacancyflux_isochempot.f90
View File

@ -80,8 +80,7 @@ subroutine vacancyflux_isochempot_init(fileUnit)
implicit none implicit none
integer(pInt), intent(in) :: fileUnit integer(pInt), intent(in) :: fileUnit
integer(pInt), parameter :: MAXNCHUNKS = 7_pInt integer(pInt), allocatable, dimension(:) :: chunkPos
integer(pInt), dimension(1+2*MAXNCHUNKS) :: positions
integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o integer(pInt) :: maxNinstance,mySize=0_pInt,section,instance,o
integer(pInt) :: sizeState integer(pInt) :: sizeState
integer(pInt) :: NofMyHomog integer(pInt) :: NofMyHomog
@ -127,16 +126,16 @@ subroutine vacancyflux_isochempot_init(fileUnit)
if (section > 0_pInt ) then; if (vacancyflux_type(section) == VACANCYFLUX_isochempot_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran if (section > 0_pInt ) then; if (vacancyflux_type(section) == VACANCYFLUX_isochempot_ID) then ! do not short-circuit here (.and. with next if statemen). It's not safe in Fortran
instance = vacancyflux_typeInstance(section) ! which instance of my vacancyflux is present homog instance = vacancyflux_typeInstance(section) ! which instance of my vacancyflux is present homog
positions = IO_stringPos(line,MAXNCHUNKS) chunkPos = IO_stringPos(line)
tag = IO_lc(IO_stringValue(line,positions,1_pInt)) ! extract key tag = IO_lc(IO_stringValue(line,chunkPos,1_pInt)) ! extract key
select case(tag) select case(tag)
case ('(output)') case ('(output)')
select case(IO_lc(IO_stringValue(line,positions,2_pInt))) select case(IO_lc(IO_stringValue(line,chunkPos,2_pInt)))
case ('vacancyconc') case ('vacancyconc')
vacancyflux_isochempot_Noutput(instance) = vacancyflux_isochempot_Noutput(instance) + 1_pInt vacancyflux_isochempot_Noutput(instance) = vacancyflux_isochempot_Noutput(instance) + 1_pInt
vacancyflux_isochempot_outputID(vacancyflux_isochempot_Noutput(instance),instance) = vacancyconc_ID vacancyflux_isochempot_outputID(vacancyflux_isochempot_Noutput(instance),instance) = vacancyconc_ID
vacancyflux_isochempot_output(vacancyflux_isochempot_Noutput(instance),instance) = & vacancyflux_isochempot_output(vacancyflux_isochempot_Noutput(instance),instance) = &
IO_lc(IO_stringValue(line,positions,2_pInt)) IO_lc(IO_stringValue(line,chunkPos,2_pInt))
end select end select
end select end select

2
lib/damask/__init__.py
View File

@ -35,11 +35,9 @@ try:
core.numerics.init = core.numerics.numerics_init core.numerics.init = core.numerics.numerics_init
core.debug.init = core.debug.debug_init core.debug.init = core.debug.debug_init
core.math.init = core.math.math_init core.math.init = core.math.math_init
core.math.periodicNearestNeighborDistances = core.math.math_periodicNearestNeighborDistances
core.math.tensorAvg = core.math.math_tensorAvg core.math.tensorAvg = core.math.math_tensorAvg
core.FEsolving.init = core.FEsolving.FE_init core.FEsolving.init = core.FEsolving.FE_init
core.mesh.init = core.mesh.mesh_init core.mesh.init = core.mesh.mesh_init
core.mesh.regrid = core.mesh.mesh_regrid
core.mesh.nodesAroundCentres = core.mesh.mesh_nodesAroundCentres core.mesh.nodesAroundCentres = core.mesh.mesh_nodesAroundCentres
core.mesh.deformedCoordsFFT = core.mesh.mesh_deformedCoordsFFT core.mesh.deformedCoordsFFT = core.mesh.mesh_deformedCoordsFFT
core.mesh.volumeMismatch = core.mesh.mesh_volumeMismatch core.mesh.volumeMismatch = core.mesh.mesh_volumeMismatch

1925
lib/kdtree2.f90
View File

File diff suppressed because it is too large Load Diff