From 8286a289df62bb4f8ae2fbcab107356a70ab3eb4 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 12 May 2019 09:47:21 +0200 Subject: [PATCH 01/36] try to directly allocate pointers --- src/mesh/FEM_mech.f90 | 66 ++++++++++++++++++------------------------- 1 file changed, 28 insertions(+), 38 deletions(-) diff --git a/src/mesh/FEM_mech.f90 b/src/mesh/FEM_mech.f90 index dd9872110..d3a6e48c1 100644 --- a/src/mesh/FEM_mech.f90 +++ b/src/mesh/FEM_mech.f90 @@ -84,11 +84,9 @@ subroutine FEM_mech_init(fieldBC) PetscDS :: mechDS PetscDualSpace :: mechDualSpace DMLabel :: BCLabel - PetscInt, dimension(:), allocatable, target :: numComp, numDoF, bcField PetscInt, dimension(:), pointer :: pNumComp, pNumDof, pBcField, pBcPoint PetscInt :: numBC, bcSize, nc IS :: bcPoint - IS, allocatable, target :: bcComps(:), bcPoints(:) IS, pointer :: pBcComps(:), pBcPoints(:) PetscSection :: section PetscInt :: field, faceSet, topologDim, nNodalPoints @@ -98,7 +96,7 @@ subroutine FEM_mech_init(fieldBC) PetscScalar, pointer :: px_scal(:) PetscScalar, allocatable, target :: x_scal(:) PetscReal :: detJ - PetscReal, allocatable, target :: v0(:), cellJ(:), invcellJ(:), cellJMat(:,:) + PetscReal, allocatable, target :: cellJMat(:,:) PetscReal, pointer :: pV0(:), pCellJ(:), pInvcellJ(:) PetscInt :: cellStart, cellEnd, cell, basis character(len=7) :: prefix = 'mechFE_' @@ -139,26 +137,26 @@ subroutine FEM_mech_init(fieldBC) call DMGetLabel(mech_mesh,'Face Sets',BCLabel,ierr); CHKERRQ(ierr) call DMPlexLabelComplete(mech_mesh,BCLabel,ierr); CHKERRQ(ierr) call DMGetSection(mech_mesh,section,ierr); CHKERRQ(ierr) - allocate(numComp(1), source=dimPlex); pNumComp => numComp - allocate(numDof(dimPlex+1), source = 0); pNumDof => numDof + allocate(pnumComp(1), source=dimPlex) + allocate(pnumDof(dimPlex+1), source = 0) do topologDim = 0, dimPlex call DMPlexGetDepthStratum(mech_mesh,topologDim,cellStart,cellEnd,ierr) CHKERRQ(ierr) - call PetscSectionGetDof(section,cellStart,numDof(topologDim+1),ierr) + call PetscSectionGetDof(section,cellStart,pnumDof(topologDim+1),ierr) CHKERRQ(ierr) enddo numBC = 0 do field = 1, dimPlex; do faceSet = 1, mesh_Nboundaries if (fieldBC%componentBC(field)%Mask(faceSet)) numBC = numBC + 1 enddo; enddo - allocate(bcField(numBC), source=0); pBcField => bcField - allocate(bcComps(numBC)); pBcComps => bcComps - allocate(bcPoints(numBC)); pBcPoints => bcPoints + allocate(pbcField(numBC), source=0) + allocate(pbcComps(numBC)) + allocate(pbcPoints(numBC)) numBC = 0 do field = 1, dimPlex; do faceSet = 1, mesh_Nboundaries if (fieldBC%componentBC(field)%Mask(faceSet)) then numBC = numBC + 1 - call ISCreateGeneral(PETSC_COMM_WORLD,1,[field-1],PETSC_COPY_VALUES,bcComps(numBC),ierr) + call ISCreateGeneral(PETSC_COMM_WORLD,1,[field-1],PETSC_COPY_VALUES,pbcComps(numBC),ierr) CHKERRQ(ierr) call DMGetStratumSize(mech_mesh,'Face Sets',mesh_boundaries(faceSet),bcSize,ierr) CHKERRQ(ierr) @@ -166,12 +164,12 @@ subroutine FEM_mech_init(fieldBC) call DMGetStratumIS(mech_mesh,'Face Sets',mesh_boundaries(faceSet),bcPoint,ierr) CHKERRQ(ierr) call ISGetIndicesF90(bcPoint,pBcPoint,ierr); CHKERRQ(ierr) - call ISCreateGeneral(PETSC_COMM_WORLD,bcSize,pBcPoint,PETSC_COPY_VALUES,bcPoints(numBC),ierr) + call ISCreateGeneral(PETSC_COMM_WORLD,bcSize,pBcPoint,PETSC_COPY_VALUES,pbcPoints(numBC),ierr) CHKERRQ(ierr) call ISRestoreIndicesF90(bcPoint,pBcPoint,ierr); CHKERRQ(ierr) call ISDestroy(bcPoint,ierr); CHKERRQ(ierr) else - call ISCreateGeneral(PETSC_COMM_WORLD,0,[0],PETSC_COPY_VALUES,bcPoints(numBC),ierr) + call ISCreateGeneral(PETSC_COMM_WORLD,0,[0],PETSC_COPY_VALUES,pbcPoints(numBC),ierr) CHKERRQ(ierr) endif endif @@ -182,7 +180,7 @@ subroutine FEM_mech_init(fieldBC) CHKERRQ(ierr) call DMSetSection(mech_mesh,section,ierr); CHKERRQ(ierr) do faceSet = 1, numBC - call ISDestroy(bcPoints(faceSet),ierr); CHKERRQ(ierr) + call ISDestroy(pbcPoints(faceSet),ierr); CHKERRQ(ierr) enddo !-------------------------------------------------------------------------------------------------- @@ -213,13 +211,10 @@ subroutine FEM_mech_init(fieldBC) allocate(nodalWeights(1)) nodalPointsP => nodalPoints nodalWeightsP => nodalWeights - allocate(v0(dimPlex)) - allocate(cellJ(dimPlex*dimPlex)) - allocate(invcellJ(dimPlex*dimPlex)) + allocate(pv0(dimPlex)) + allocate(pcellJ(dimPlex*dimPlex)) + allocate(pinvcellJ(dimPlex*dimPlex)) allocate(cellJMat(dimPlex,dimPlex)) - pV0 => v0 - pCellJ => cellJ - pInvcellJ => invcellJ call DMGetSection(mech_mesh,section,ierr); CHKERRQ(ierr) call DMGetDS(mech_mesh,mechDS,ierr); CHKERRQ(ierr) call PetscDSGetDiscretization(mechDS,0,mechFE,ierr) @@ -325,22 +320,19 @@ subroutine FEM_mech_formResidual(dm_local,xx_local,f_local,dummy,ierr) PetscScalar, dimension(:), pointer :: x_scal, pf_scal PetscScalar, target :: f_scal(cellDof) PetscReal :: detJ, IcellJMat(dimPlex,dimPlex) - PetscReal, target :: v0(dimPlex), cellJ(dimPlex*dimPlex), & - invcellJ(dimPlex*dimPlex) - PetscReal, pointer :: pV0(:), pCellJ(:), pInvcellJ(:) - PetscReal, pointer :: basisField(:), basisFieldDer(:) + PetscReal, pointer,dimension(:) :: pV0, pCellJ, pInvcellJ, basisField, basisFieldDer PetscInt :: cellStart, cellEnd, cell, field, face, & qPt, basis, comp, cidx PetscReal :: detFAvg PetscReal :: BMat(dimPlex*dimPlex,cellDof) - PetscObject :: dummy + PetscObject,intent(in) :: dummy PetscInt :: bcSize IS :: bcPoints PetscErrorCode :: ierr - pV0 => v0 - pCellJ => cellJ - pInvcellJ => invcellJ + allocate(pV0(dimPlex)) + allocate(pcellJ(dimPlex**2)) + allocate(pinvcellJ(dimPlex**2)) call DMGetSection(dm_local,section,ierr); CHKERRQ(ierr) call DMGetDS(dm_local,prob,ierr); CHKERRQ(ierr) call PetscDSGetTabulation(prob,0,basisField,basisFieldDer,ierr) @@ -460,13 +452,11 @@ subroutine FEM_mech_formJacobian(dm_local,xx_local,Jac_pre,Jac,dummy,ierr) Vec :: x_local, xx_local Mat :: Jac_pre, Jac PetscSection :: section, gSection - PetscReal :: detJ, IcellJMat(dimPlex,dimPlex) - PetscReal, target :: v0(dimPlex), cellJ(dimPlex*dimPlex), & - invcellJ(dimPlex*dimPlex) + PetscReal :: detJ PetscReal, dimension(:), pointer :: basisField, basisFieldDer, & pV0, pCellJ, pInvcellJ PetscInt :: cellStart, cellEnd, cell, field, face, & - qPt, basis, comp, cidx + qPt, basis, comp, cidx,bcSize PetscScalar,dimension(cellDOF,cellDOF), target :: K_e, & K_eA , & K_eB @@ -477,14 +467,14 @@ subroutine FEM_mech_formJacobian(dm_local,xx_local,Jac_pre,Jac,dummy,ierr) MatB (1 ,cellDof) PetscScalar, dimension(:), pointer :: pK_e, x_scal PetscReal, dimension(3,3) :: F, FAvg, FInv - PetscObject :: dummy - PetscInt :: bcSize + PetscObject, intent(in) :: dummy IS :: bcPoints PetscErrorCode :: ierr - pV0 => v0 - pCellJ => cellJ - pInvcellJ => invcellJ + allocate(pV0(dimPlex)) + allocate(pcellJ(dimPlex**2)) + allocate(pinvcellJ(dimPlex**2)) + call MatSetOption(Jac,MAT_KEEP_NONZERO_PATTERN,PETSC_TRUE,ierr); CHKERRQ(ierr) call MatSetOption(Jac,MAT_NEW_NONZERO_ALLOCATION_ERR,PETSC_FALSE,ierr); CHKERRQ(ierr) call MatZeroEntries(Jac,ierr); CHKERRQ(ierr) @@ -513,7 +503,6 @@ subroutine FEM_mech_formJacobian(dm_local,xx_local,Jac_pre,Jac,dummy,ierr) CHKERRQ(ierr) call DMPlexComputeCellGeometryAffineFEM(dm_local,cell,pV0,pCellJ,pInvcellJ,detJ,ierr) CHKERRQ(ierr) - IcellJMat = reshape(pInvcellJ, shape = [dimPlex,dimPlex]) K_eA = 0.0 K_eB = 0.0 MatB = 0.0 @@ -525,7 +514,8 @@ subroutine FEM_mech_formJacobian(dm_local,xx_local,Jac_pre,Jac,dummy,ierr) do comp = 0, dimPlex-1 cidx = basis*dimPlex+comp BMat(comp*dimPlex+1:(comp+1)*dimPlex,basis*dimPlex+comp+1) = & - matmul(IcellJMat,basisFieldDer((((qPt*nBasis + basis)*dimPlex + comp)*dimPlex+comp )*dimPlex+1: & + matmul( reshape(pInvcellJ, shape = [dimPlex,dimPlex]),& + basisFieldDer((((qPt*nBasis + basis)*dimPlex + comp)*dimPlex+comp )*dimPlex+1: & (((qPt*nBasis + basis)*dimPlex + comp)*dimPlex+comp+1)*dimPlex)) enddo enddo From f0f8be7840f618dd758db33ced3b92d2d429f3dc Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 12 May 2019 10:05:40 +0200 Subject: [PATCH 02/36] not used --- src/mesh/FEM_utilities.f90 | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/src/mesh/FEM_utilities.f90 b/src/mesh/FEM_utilities.f90 index a2ba2d345..937c46a32 100644 --- a/src/mesh/FEM_utilities.f90 +++ b/src/mesh/FEM_utilities.f90 @@ -24,9 +24,7 @@ use PETScis ! grid related information information real(pReal), public :: wgt !< weighting factor 1/Nelems -!-------------------------------------------------------------------------------------------------- -! output data - Vec, public :: coordinatesVec + !-------------------------------------------------------------------------------------------------- ! field labels information character(len=*), parameter, public :: & @@ -53,7 +51,6 @@ use PETScis type, public :: tSolutionState !< return type of solution from FEM solver variants logical :: converged = .true. logical :: stagConverged = .true. - logical :: regrid = .false. integer(pInt) :: iterationsNeeded = 0_pInt end type tSolutionState @@ -79,18 +76,6 @@ use PETScis integer(pInt), allocatable :: faceID(:) type(tFieldBC), allocatable :: fieldBC(:) end type tLoadCase - - type, public :: tFEMInterpolation - integer(pInt) :: n - real(pReal), dimension(:,:) , allocatable :: shapeFunc, shapeDerivReal, geomShapeDerivIso - real(pReal), dimension(:,:,:), allocatable :: shapeDerivIso - end type tFEMInterpolation - - type, public :: tQuadrature - integer(pInt) :: n - real(pReal), dimension(:) , allocatable :: Weights - real(pReal), dimension(:,:), allocatable :: Points - end type tQuadrature public :: & utilities_init, & From 7d5f5afe01610ad5f5be1c6f839748c63234abeb Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 12 May 2019 13:11:30 +0200 Subject: [PATCH 03/36] further cleaning --- src/grid/spectral_utilities.f90 | 7 +------ src/mesh/DAMASK_FEM.f90 | 14 ++++++-------- src/mesh/FEM_utilities.f90 | 23 ++--------------------- 3 files changed, 9 insertions(+), 35 deletions(-) diff --git a/src/grid/spectral_utilities.f90 b/src/grid/spectral_utilities.f90 index 4c5dc3169..1d5e42070 100644 --- a/src/grid/spectral_utilities.f90 +++ b/src/grid/spectral_utilities.f90 @@ -942,9 +942,6 @@ subroutine utilities_constitutiveResponse(P,P_av,C_volAvg,C_minmaxAvg,& IO_error use numerics, only: & worldrank - use debug, only: & - debug_reset, & - debug_info use math, only: & math_rotate_forward33, & math_det33 @@ -977,7 +974,6 @@ subroutine utilities_constitutiveResponse(P,P_av,C_volAvg,C_minmaxAvg,& materialpoint_F = reshape(F,[3,3,1,product(grid(1:2))*grid3]) ! set materialpoint target F to estimated field - call debug_reset() ! this has no effect on rank >0 call materialpoint_stressAndItsTangent(.true.,timeinc) ! calculate P field P = reshape(materialpoint_P, [3,3,grid(1),grid(2),grid3]) @@ -1023,8 +1019,7 @@ subroutine utilities_constitutiveResponse(P,P_av,C_volAvg,C_minmaxAvg,& C_volAvg = sum(sum(materialpoint_dPdF,dim=6),dim=5) call MPI_Allreduce(MPI_IN_PLACE,C_volAvg,81,MPI_DOUBLE,MPI_SUM,PETSC_COMM_WORLD,ierr) C_volAvg = C_volAvg * wgt - - call debug_info() ! this has no effect on rank >0 + end subroutine utilities_constitutiveResponse diff --git a/src/mesh/DAMASK_FEM.f90 b/src/mesh/DAMASK_FEM.f90 index 611be46e0..052c30071 100644 --- a/src/mesh/DAMASK_FEM.f90 +++ b/src/mesh/DAMASK_FEM.f90 @@ -28,8 +28,7 @@ program DAMASK_FEM IO_intOut, & IO_warning use math ! need to include the whole module for FFTW - use CPFEM2, only: & - CPFEM_initAll + use CPFEM2 use FEsolving, only: & restartWrite, & restartInc @@ -114,7 +113,7 @@ program DAMASK_FEM write(6,'(/,a)') ' <<<+- DAMASK_FEM init -+>>>' ! reading basic information from load case file and allocate data structure containing load cases - call DMGetDimension(geomMesh,dimPlex,ierr)! CHKERRQ(ierr) !< dimension of mesh (2D or 3D) + call DMGetDimension(geomMesh,dimPlex,ierr); CHKERRA(ierr) !< dimension of mesh (2D or 3D) nActiveFields = 1 allocate(solres(nActiveFields)) @@ -394,8 +393,7 @@ program DAMASK_FEM cutBack = .False. if(.not. all(solres(:)%converged .and. solres(:)%stagConverged)) then ! no solution found if (cutBackLevel < maxCutBack) then ! do cut back - if (worldrank == 0) & - write(6,'(/,a)') ' cut back detected' + write(6,'(/,a)') ' cut back detected' cutBack = .True. stepFraction = (stepFraction - 1_pInt) * subStepFactor ! adjust to new denominator cutBackLevel = cutBackLevel + 1_pInt @@ -403,7 +401,7 @@ program DAMASK_FEM timeinc = timeinc/2.0_pReal else ! default behavior, exit if spectral solver does not converge call IO_warning(850_pInt) - call quit(-1_pInt*(lastRestartWritten+1_pInt)) ! quit and provide information about last restart inc written (e.g. for regridding) ! continue from non-converged solution and start guessing after accepted (sub)inc + call quit(-1_pInt*(lastRestartWritten+1_pInt)) ! quit and provide information about last restart inc written endif else guess = .true. ! start guessing after first converged (sub)inc @@ -428,7 +426,8 @@ program DAMASK_FEM endif; flush(6) if (mod(inc,loadCases(currentLoadCase)%outputFrequency) == 0_pInt) then ! at output frequency - write(6,'(1/,a)') ' ToDo: ... writing results to file ......................................' + write(6,'(1/,a)') ' ... writing results to file ......................................' + call CPFEM_results(totalIncsCounter,time) endif if ( loadCases(currentLoadCase)%restartFrequency > 0_pInt & ! writing of restart info requested ... .and. mod(inc,loadCases(currentLoadCase)%restartFrequency) == 0_pInt) then ! ... and at frequency of writing restart information @@ -452,7 +451,6 @@ program DAMASK_FEM real(convergedCounter, pReal)/& real(notConvergedCounter + convergedCounter,pReal)*100.0_pReal, ' %) increments converged!' flush(6) - call MPI_file_close(fileUnit,ierr) close(statUnit) if (notConvergedCounter > 0_pInt) call quit(2_pInt) ! error if some are not converged diff --git a/src/mesh/FEM_utilities.f90 b/src/mesh/FEM_utilities.f90 index 937c46a32..b2f9d35f5 100644 --- a/src/mesh/FEM_utilities.f90 +++ b/src/mesh/FEM_utilities.f90 @@ -104,11 +104,8 @@ subroutine utilities_init use math ! must use the whole module for use of FFTW use mesh, only: & mesh_NcpElemsGlobal, & - mesh_maxNips, & - geomMesh - - implicit none - + mesh_maxNips + character(len=1024) :: petsc_optionsPhysics PetscErrorCode :: ierr @@ -142,35 +139,21 @@ end subroutine utilities_init !> @brief calculates constitutive response !-------------------------------------------------------------------------------------------------- subroutine utilities_constitutiveResponse(timeinc,P_av,forwardData) - use math, only: & - math_det33 use FEsolving, only: & restartWrite use homogenization, only: & materialpoint_P, & materialpoint_stressAndItsTangent - implicit none real(pReal), intent(in) :: timeinc !< loading time logical, intent(in) :: forwardData !< age results real(pReal),intent(out), dimension(3,3) :: P_av !< average PK stress - logical :: & - age - PetscErrorCode :: ierr write(6,'(/,a)') ' ... evaluating constitutive response ......................................' - age = .False. - if (forwardData) then ! aging results - age = .True. - endif - if (cutBack) then ! restore saved variables - age = .False. - endif - call materialpoint_stressAndItsTangent(.true.,timeinc) ! calculate P field restartWrite = .false. ! reset restartWrite status @@ -187,8 +170,6 @@ end subroutine utilities_constitutiveResponse !-------------------------------------------------------------------------------------------------- subroutine utilities_projectBCValues(localVec,section,field,comp,bcPointsIS,BCValue,BCDotValue,timeinc) - implicit none - Vec :: localVec PetscInt :: field, comp, nBcPoints, point, dof, numDof, numComp, offset PetscSection :: section From 344e6ca51a32ffd0e2ab3f93901fee8520e3237b Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 12 May 2019 23:56:44 +0200 Subject: [PATCH 04/36] IP volume is trivial for spectral solver --- src/mesh_grid.f90 | 79 +++-------------------------------------------- 1 file changed, 4 insertions(+), 75 deletions(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index 7274582a2..f8a874c55 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -127,7 +127,6 @@ integer(pInt), dimension(:,:), allocatable, private :: & mesh_spectral_build_elements, & mesh_spectral_build_ipNeighborhood, & mesh_build_cellnodes, & - mesh_build_ipVolumes, & mesh_build_ipCoordinates type, public, extends(tMesh) :: tMesh_grid @@ -190,7 +189,7 @@ subroutine mesh_init(ip,el) implicit none include 'fftw3-mpi.f03' integer(C_INTPTR_T) :: devNull, local_K, local_K_offset - integer :: ierr, worldsize + integer :: ierr, worldsize, i integer(pInt), intent(in), optional :: el, ip integer(pInt) :: j logical :: myDebug @@ -244,7 +243,7 @@ subroutine mesh_init(ip,el) if (myDebug) write(6,'(a)') ' Built cell nodes'; flush(6) call mesh_build_ipCoordinates if (myDebug) write(6,'(a)') ' Built IP coordinates'; flush(6) - call mesh_build_ipVolumes + allocate(mesh_ipVolume(1,theMesh%nElems),source=product([geomSize(1:2),size3]/real([grid(1:2),grid3]))) if (myDebug) write(6,'(a)') ' Built IP volumes'; flush(6) call mesh_build_ipAreas if (myDebug) write(6,'(a)') ' Built IP areas'; flush(6) @@ -508,7 +507,7 @@ subroutine mesh_spectral_build_ipNeighborhood integer(pInt) :: & x,y,z, & e - allocate(mesh_ipNeighborhood(3,theMesh%elem%nIPneighbors,theMesh%elem%nIPs,theMesh%nElems),source=0_pInt) + allocate(mesh_ipNeighborhood(3,6,1,theMesh%nElems),source=0_pInt) e = 0_pInt do z = 0_pInt,grid3-1_pInt @@ -768,75 +767,6 @@ function mesh_build_cellnodes(nodes,Ncellnodes) end function mesh_build_cellnodes -!-------------------------------------------------------------------------------------------------- -!> @brief Calculates IP volume. Allocates global array 'mesh_ipVolume' -!> @details The IP volume is calculated differently depending on the cell type. -!> 2D cells assume an element depth of one in order to calculate the volume. -!> For the hexahedral cell we subdivide the cell into subvolumes of pyramidal -!> shape with a cell face as basis and the central ip at the tip. This subvolume is -!> calculated as an average of four tetrahedals with three corners on the cell face -!> and one corner at the central ip. -!-------------------------------------------------------------------------------------------------- -subroutine mesh_build_ipVolumes - use math, only: & - math_volTetrahedron, & - math_areaTriangle - - implicit none - integer(pInt) :: e,t,g,c,i,m,f,n - real(pReal), dimension(FE_maxNcellnodesPerCellface,FE_maxNcellfaces) :: subvolume - - - allocate(mesh_ipVolume(theMesh%elem%nIPs,theMesh%nElems),source=0.0_pReal) - - - !$OMP PARALLEL DO PRIVATE(t,g,c,m,subvolume) - do e = 1_pInt,theMesh%nElems ! loop over cpElems - select case (theMesh%elem%cellType) - - case (1_pInt) ! 2D 3node - forall (i = 1_pInt:theMesh%elem%nIPs) & ! loop over ips=cells in this element - mesh_ipVolume(i,e) = math_areaTriangle(mesh_cellnode(1:3,mesh_cell(1,i,e)), & - mesh_cellnode(1:3,mesh_cell(2,i,e)), & - mesh_cellnode(1:3,mesh_cell(3,i,e))) - - case (2_pInt) ! 2D 4node - forall (i = 1_pInt:theMesh%elem%nIPs) & ! loop over ips=cells in this element - mesh_ipVolume(i,e) = math_areaTriangle(mesh_cellnode(1:3,mesh_cell(1,i,e)), & ! here we assume a planar shape, so division in two triangles suffices - mesh_cellnode(1:3,mesh_cell(2,i,e)), & - mesh_cellnode(1:3,mesh_cell(3,i,e))) & - + math_areaTriangle(mesh_cellnode(1:3,mesh_cell(3,i,e)), & - mesh_cellnode(1:3,mesh_cell(4,i,e)), & - mesh_cellnode(1:3,mesh_cell(1,i,e))) - - case (3_pInt) ! 3D 4node - forall (i = 1_pInt:theMesh%elem%nIPs) & ! loop over ips=cells in this element - mesh_ipVolume(i,e) = math_volTetrahedron(mesh_cellnode(1:3,mesh_cell(1,i,e)), & - mesh_cellnode(1:3,mesh_cell(2,i,e)), & - mesh_cellnode(1:3,mesh_cell(3,i,e)), & - mesh_cellnode(1:3,mesh_cell(4,i,e))) - - case (4_pInt) - c = theMesh%elem%cellType ! 3D 8node - m = FE_NcellnodesPerCellface(c) - do i = 1_pInt,theMesh%elem%nIPs ! loop over ips=cells in this element - subvolume = 0.0_pReal - forall(f = 1_pInt:FE_NipNeighbors(c), n = 1_pInt:FE_NcellnodesPerCellface(c)) & - subvolume(n,f) = math_volTetrahedron(& - mesh_cellnode(1:3,mesh_cell(FE_cellface( n ,f,c),i,e)), & - mesh_cellnode(1:3,mesh_cell(FE_cellface(1+mod(n ,m),f,c),i,e)), & - mesh_cellnode(1:3,mesh_cell(FE_cellface(1+mod(n+1,m),f,c),i,e)), & - mesh_ipCoordinates(1:3,i,e)) - mesh_ipVolume(i,e) = 0.5_pReal * sum(subvolume) ! each subvolume is based on four tetrahedrons, altough the face consists of only two triangles -> averaging factor two - enddo - - end select - enddo - !$OMP END PARALLEL DO - -end subroutine mesh_build_ipVolumes - - !-------------------------------------------------------------------------------------------------- !> @brief Calculates IP Coordinates. Allocates global array 'mesh_ipCoordinates' ! Called by all solvers in mesh_init in order to initialize the ip coordinates. @@ -855,8 +785,7 @@ subroutine mesh_build_ipCoordinates integer(pInt) :: e,c,i,n real(pReal), dimension(3) :: myCoords - if (.not. allocated(mesh_ipCoordinates)) & - allocate(mesh_ipCoordinates(3,theMesh%elem%nIPs,theMesh%nElems),source=0.0_pReal) + allocate(mesh_ipCoordinates(3,theMesh%elem%nIPs,theMesh%nElems),source=0.0_pReal) !$OMP PARALLEL DO PRIVATE(c,myCoords) do e = 1_pInt,theMesh%nElems ! loop over cpElems From df01a3ff36ac227b41bef9ce13263835d0fcecda Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Mon, 13 May 2019 00:00:14 +0200 Subject: [PATCH 05/36] only for internal use --- src/mesh_grid.f90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index f8a874c55..094f7da4e 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -34,7 +34,7 @@ module mesh real(pReal), public, protected :: & mesh_unitlength !< physical length of one unit in mesh - real(pReal), dimension(:,:), allocatable, public :: & + real(pReal), dimension(:,:), allocatable, private :: & mesh_node, & !< node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) mesh_cellnode !< cell node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) From 4c148f1a07f8cbb5e8d3b546c09ea06e4f91f448 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Mon, 13 May 2019 08:47:53 +0200 Subject: [PATCH 06/36] not needed --- src/mesh_grid.f90 | 38 +++----------------------------------- 1 file changed, 3 insertions(+), 35 deletions(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index 094f7da4e..11afe0175 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -69,8 +69,6 @@ integer(pInt), dimension(:,:), allocatable, private :: & integer(pInt), parameter, private :: & FE_Ngeomtypes = 10_pInt, & FE_Ncelltypes = 4_pInt, & - FE_maxNmatchingNodesPerFace = 4_pInt, & - FE_maxNfaces = 6_pInt, & FE_maxNcellnodesPerCell = 8_pInt, & FE_maxNcellfaces = 6_pInt, & FE_maxNcellnodesPerCellface = 4_pInt @@ -116,8 +114,7 @@ integer(pInt), dimension(:,:), allocatable, private :: & size3offset !< (local) size offset in 3rd direction public :: & - mesh_init, & - mesh_cellCenterCoordinates + mesh_init private :: & mesh_build_cellconnectivity, & @@ -460,12 +457,8 @@ end subroutine mesh_spectral_build_nodes !-------------------------------------------------------------------------------------------------- !> @brief Store FEid, type, material, texture, and node list per element. !! Allocates global array 'mesh_element' -!> @todo does the IO_error makes sense? !-------------------------------------------------------------------------------------------------- subroutine mesh_spectral_build_elements() - use IO, only: & - IO_error - implicit none integer(pInt) :: & e, & elemOffset @@ -474,11 +467,9 @@ subroutine mesh_spectral_build_elements() allocate(mesh_element (4_pInt+8_pInt,theMesh%nElems), source = 0_pInt) elemOffset = product(grid(1:2))*grid3Offset - e = 0_pInt - do while (e < theMesh%nElems) ! fill expected number of elements, stop at end of data - e = e+1_pInt ! valid element entry + do e=1, theMesh%nElems mesh_element( 1,e) = -1_pInt ! DEPRECATED - mesh_element( 2,e) = 10_pInt + mesh_element( 2,e) = -1_pInt ! DEPRECATED mesh_element( 3,e) = mesh_homogenizationAt(e) mesh_element( 4,e) = microGlobal(e+elemOffset) ! microstructure mesh_element( 5,e) = e + (e-1_pInt)/grid(1) + & @@ -492,8 +483,6 @@ subroutine mesh_spectral_build_elements() mesh_element(12,e) = mesh_element(9,e) + grid(1) + 1_pInt enddo - if (e /= theMesh%nElems) call IO_error(880_pInt,e) - end subroutine mesh_spectral_build_elements @@ -803,27 +792,6 @@ subroutine mesh_build_ipCoordinates end subroutine mesh_build_ipCoordinates -!-------------------------------------------------------------------------------------------------- -!> @brief Calculates cell center coordinates. -!-------------------------------------------------------------------------------------------------- -pure function mesh_cellCenterCoordinates(ip,el) - - implicit none - integer(pInt), intent(in) :: el, & !< element number - ip !< integration point number - real(pReal), dimension(3) :: mesh_cellCenterCoordinates !< x,y,z coordinates of the cell center of the requested IP cell - integer(pInt) :: c,n - - c = theMesh%elem%cellType - mesh_cellCenterCoordinates = 0.0_pReal - do n = 1_pInt,FE_NcellnodesPerCell(c) ! loop over cell nodes in this cell - mesh_cellCenterCoordinates = mesh_cellCenterCoordinates + mesh_cellnode(1:3,mesh_cell(n,ip,el)) - enddo - mesh_cellCenterCoordinates = mesh_cellCenterCoordinates / real(FE_NcellnodesPerCell(c),pReal) - -end function mesh_cellCenterCoordinates - - !-------------------------------------------------------------------------------------------------- !> @brief calculation of IP interface areas, allocate globals '_ipArea', and '_ipAreaNormal' !-------------------------------------------------------------------------------------------------- From fb49acdb976c48fb088a0a057fcc3c7b46eda5de Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Mon, 13 May 2019 22:54:18 +0200 Subject: [PATCH 07/36] more explicit --- src/mesh_grid.f90 | 36 +++++++++++++++--------------------- 1 file changed, 15 insertions(+), 21 deletions(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index 11afe0175..39e0111c1 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -221,7 +221,8 @@ subroutine mesh_init(ip,el) mesh_Nnodes = product(grid(1:2) + 1_pInt)*(grid3 + 1_pInt) - call mesh_spectral_build_nodes() + mesh_node0 = mesh_spectral_build_nodes() + mesh_node = mesh_node0 if (myDebug) write(6,'(a)') ' Built nodes'; flush(6) call theMesh%init(mesh_node) @@ -429,29 +430,22 @@ end subroutine mesh_spectral_read_grid !> @brief Store x,y,z coordinates of all nodes in mesh. !! Allocates global arrays 'mesh_node0' and 'mesh_node' !-------------------------------------------------------------------------------------------------- -subroutine mesh_spectral_build_nodes() +pure function mesh_spectral_build_nodes() - implicit none - integer(pInt) :: n + real(pReal), dimension(3,mesh_Nnodes) :: mesh_spectral_build_nodes + integer :: n,a,b,c - allocate (mesh_node0 (3,mesh_Nnodes), source = 0.0_pReal) + n = 0 + do c = 0, grid3 + do b = 0, grid(2) + do a = 0, grid(1) + n = n + 1 + mesh_spectral_build_nodes(1:3,n) = geomSize/real(grid,pReal) * real([a,b,grid3Offset+c],pReal) + enddo + enddo + enddo - forall (n = 0_pInt:mesh_Nnodes-1_pInt) - mesh_node0(1,n+1_pInt) = mesh_unitlength * & - geomSize(1)*real(mod(n,(grid(1)+1_pInt) ),pReal) & - / real(grid(1),pReal) - mesh_node0(2,n+1_pInt) = mesh_unitlength * & - geomSize(2)*real(mod(n/(grid(1)+1_pInt),(grid(2)+1_pInt)),pReal) & - / real(grid(2),pReal) - mesh_node0(3,n+1_pInt) = mesh_unitlength * & - size3*real(mod(n/(grid(1)+1_pInt)/(grid(2)+1_pInt),(grid3+1_pInt)),pReal) & - / real(grid3,pReal) + & - size3offset - end forall - - mesh_node = mesh_node0 - -end subroutine mesh_spectral_build_nodes +end function mesh_spectral_build_nodes !-------------------------------------------------------------------------------------------------- From c8794af3bbbf5a771ee703fc6e82e505881055dd Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Mon, 13 May 2019 23:18:02 +0200 Subject: [PATCH 08/36] better readable --- src/mesh_grid.f90 | 92 ++++++++++++++--------------------------------- 1 file changed, 27 insertions(+), 65 deletions(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index 39e0111c1..e752f5d41 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -239,7 +239,7 @@ subroutine mesh_init(ip,el) if (myDebug) write(6,'(a)') ' Built cell connectivity'; flush(6) mesh_cellnode = mesh_build_cellnodes(mesh_node,mesh_Ncellnodes) if (myDebug) write(6,'(a)') ' Built cell nodes'; flush(6) - call mesh_build_ipCoordinates + mesh_ipCoordinates = mesh_build_ipCoordinates() if (myDebug) write(6,'(a)') ' Built IP coordinates'; flush(6) allocate(mesh_ipVolume(1,theMesh%nElems),source=product([geomSize(1:2),size3]/real([grid(1:2),grid3]))) if (myDebug) write(6,'(a)') ' Built IP volumes'; flush(6) @@ -391,7 +391,7 @@ subroutine mesh_spectral_read_grid() allocate(mesh_homogenizationAt(product(grid)), source = h) ! too large in case of MPI (shrink later, not very elegant) !-------------------------------------------------------------------------------------------------- -! read and interprete content +! read and interpret content e = 1_pInt do while (startPos < len(rawData)) endPos = startPos + index(rawData(startPos:),new_line('')) - 1_pInt @@ -426,10 +426,9 @@ subroutine mesh_spectral_read_grid() end subroutine mesh_spectral_read_grid -!-------------------------------------------------------------------------------------------------- -!> @brief Store x,y,z coordinates of all nodes in mesh. -!! Allocates global arrays 'mesh_node0' and 'mesh_node' -!-------------------------------------------------------------------------------------------------- +!--------------------------------------------------------------------------------------------------- +!> @brief Calculates position of nodes (pretend to be an element) +!--------------------------------------------------------------------------------------------------- pure function mesh_spectral_build_nodes() real(pReal), dimension(3,mesh_Nnodes) :: mesh_spectral_build_nodes @@ -448,6 +447,27 @@ pure function mesh_spectral_build_nodes() end function mesh_spectral_build_nodes +!--------------------------------------------------------------------------------------------------- +!> @brief Calculates position of IPs/cell centres (pretend to be an element) +!--------------------------------------------------------------------------------------------------- +function mesh_build_ipCoordinates() + + real(pReal), dimension(3,1,theMesh%nElems) :: mesh_build_ipCoordinates + integer :: n,a,b,c + + n = 0 + do c = 1, grid3 + do b = 1, grid(2) + do a = 1, grid(1) + n = n + 1 + mesh_build_ipCoordinates(1:3,1,n) = geomSize/real(grid,pReal) * (real([a,b,grid3Offset+c],pReal) -0.5_pReal) + enddo + enddo + enddo + +end function mesh_build_ipCoordinates + + !-------------------------------------------------------------------------------------------------- !> @brief Store FEid, type, material, texture, and node list per element. !! Allocates global array 'mesh_element' @@ -544,7 +564,6 @@ function mesh_nodesAroundCentres(gDim,Favg,centres) result(nodes) debug_level, & debug_levelBasic - implicit none real(pReal), intent(in), dimension(:,:,:,:) :: & centres real(pReal), dimension(3,size(centres,2)+1,size(centres,3)+1,size(centres,4)+1) :: & @@ -623,16 +642,6 @@ function mesh_nodesAroundCentres(gDim,Favg,centres) result(nodes) end function mesh_nodesAroundCentres -!################################################################################################################# -!################################################################################################################# -!################################################################################################################# -! The following routines are not solver specific and should be included in mesh_base (most likely in modified form) -!################################################################################################################# -!################################################################################################################# -!################################################################################################################# - - - !-------------------------------------------------------------------------------------------------- !> @brief Split CP elements into cells. !> @details Build a mapping between cells and the corresponding cell nodes ('mesh_cell'). @@ -762,28 +771,6 @@ end function mesh_build_cellnodes ! HAS TO BE CHANGED IN A LATER VERSION. ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !-------------------------------------------------------------------------------------------------- -subroutine mesh_build_ipCoordinates - - implicit none - integer(pInt) :: e,c,i,n - real(pReal), dimension(3) :: myCoords - - allocate(mesh_ipCoordinates(3,theMesh%elem%nIPs,theMesh%nElems),source=0.0_pReal) - - !$OMP PARALLEL DO PRIVATE(c,myCoords) - do e = 1_pInt,theMesh%nElems ! loop over cpElems - c = theMesh%elem%cellType - do i = 1_pInt,theMesh%elem%nIPs ! loop over ips=cells in this element - myCoords = 0.0_pReal - do n = 1_pInt,FE_NcellnodesPerCell(c) ! loop over cell nodes in this cell - myCoords = myCoords + mesh_cellnode(1:3,mesh_cell(n,i,e)) - enddo - mesh_ipCoordinates(1:3,i,e) = myCoords / real(FE_NcellnodesPerCell(c),pReal) - enddo - enddo - !$OMP END PARALLEL DO - -end subroutine mesh_build_ipCoordinates !-------------------------------------------------------------------------------------------------- @@ -806,32 +793,7 @@ subroutine mesh_build_ipAreas c = theMesh%elem%cellType select case (c) - case (1_pInt,2_pInt) ! 2D 3 or 4 node - do i = 1_pInt,theMesh%elem%nIPs ! loop over ips=cells in this element - do f = 1_pInt,FE_NipNeighbors(c) ! loop over cell faces - forall(n = 1_pInt:FE_NcellnodesPerCellface(c)) & - nodePos(1:3,n) = mesh_cellnode(1:3,mesh_cell(FE_cellface(n,f,c),i,e)) - normal(1) = nodePos(2,2) - nodePos(2,1) ! x_normal = y_connectingVector - normal(2) = -(nodePos(1,2) - nodePos(1,1)) ! y_normal = -x_connectingVector - normal(3) = 0.0_pReal - mesh_ipArea(f,i,e) = norm2(normal) - mesh_ipAreaNormal(1:3,f,i,e) = normal / norm2(normal) ! ensure unit length of area normal - enddo - enddo - - case (3_pInt) ! 3D 4node - do i = 1_pInt,theMesh%elem%nIPs ! loop over ips=cells in this element - do f = 1_pInt,FE_NipNeighbors(c) ! loop over cell faces - forall(n = 1_pInt:FE_NcellnodesPerCellface(c)) & - nodePos(1:3,n) = mesh_cellnode(1:3,mesh_cell(FE_cellface(n,f,c),i,e)) - normal = math_crossproduct(nodePos(1:3,2) - nodePos(1:3,1), & - nodePos(1:3,3) - nodePos(1:3,1)) - mesh_ipArea(f,i,e) = norm2(normal) - mesh_ipAreaNormal(1:3,f,i,e) = normal / norm2(normal) ! ensure unit length of area normal - enddo - enddo - - case (4_pInt) ! 3D 8node + case (4_pInt) ! for this cell type we get the normal of the quadrilateral face as an average of ! four normals of triangular subfaces; since the face consists only of two triangles, ! the sum has to be divided by two; this whole prcedure tries to compensate for From cac472c506b135f5bb2bae8ddd8f792e5ef5ab63 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 14 May 2019 00:13:43 +0200 Subject: [PATCH 09/36] cleaning more complex initialization will be used by FEM solvers only --- src/mesh_grid.f90 | 295 ++++------------------------------------------ 1 file changed, 23 insertions(+), 272 deletions(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index e752f5d41..a7da77bf0 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -35,8 +35,8 @@ module mesh mesh_unitlength !< physical length of one unit in mesh real(pReal), dimension(:,:), allocatable, private :: & - mesh_node, & !< node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) - mesh_cellnode !< cell node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) + mesh_node !< node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) + real(pReal), dimension(:,:), allocatable, public, protected :: & mesh_ipVolume, & !< volume associated with IP (initially!) @@ -53,53 +53,14 @@ module mesh logical, dimension(3), public, parameter :: mesh_periodicSurface = .true. !< flag indicating periodic outer surfaces (used for fluxes) -integer(pInt), dimension(:,:), allocatable, private :: & - mesh_cellnodeParent !< cellnode's parent element ID, cellnode's intra-element ID integer(pInt),dimension(:,:,:), allocatable, private :: & mesh_cell !< cell connectivity for each element,ip/cell - integer(pInt), dimension(:,:,:), allocatable, private :: & - FE_cellface !< list of intra-cell cell node IDs that constitute the cell faces of a specific type of cell - - -! These definitions should actually reside in the FE-solver specific part (different for MARC/ABAQUS) -! Hence, I suggest to prefix with "FE_" - integer(pInt), parameter, private :: & FE_Ngeomtypes = 10_pInt, & FE_Ncelltypes = 4_pInt, & - FE_maxNcellnodesPerCell = 8_pInt, & - FE_maxNcellfaces = 6_pInt, & - FE_maxNcellnodesPerCellface = 4_pInt - - - - integer(pInt), dimension(FE_Ncelltypes), parameter, private :: FE_NcellnodesPerCell = & !< number of cell nodes in a specific cell type - int([ & - 3, & ! (2D 3node) - 4, & ! (2D 4node) - 4, & ! (3D 4node) - 8 & ! (3D 8node) - ],pInt) - - integer(pInt), dimension(FE_Ncelltypes), parameter, private :: FE_NcellnodesPerCellface = & !< number of cell nodes per cell face in a specific cell type - int([& - 2, & ! (2D 3node) - 2, & ! (2D 4node) - 3, & ! (3D 4node) - 4 & ! (3D 8node) - ],pInt) - - - integer(pInt), dimension(FE_Ncelltypes), parameter, private :: FE_NipNeighbors = & !< number of ip neighbors / cell faces in a specific cell type - int([& - 3, & ! (2D 3node) - 4, & ! (2D 4node) - 4, & ! (3D 4node) - 6 & ! (3D 8node) - ],pInt) - + FE_maxNcellnodesPerCell = 8_pInt integer(pInt), dimension(3), public, protected :: & grid !< (global) grid @@ -117,13 +78,10 @@ integer(pInt), dimension(:,:), allocatable, private :: & mesh_init private :: & - mesh_build_cellconnectivity, & mesh_build_ipAreas, & - mesh_build_FEdata, & mesh_spectral_build_nodes, & mesh_spectral_build_elements, & mesh_spectral_build_ipNeighborhood, & - mesh_build_cellnodes, & mesh_build_ipCoordinates type, public, extends(tMesh) :: tMesh_grid @@ -234,16 +192,14 @@ subroutine mesh_init(ip,el) if (myDebug) write(6,'(a)') ' Built elements'; flush(6) - call mesh_build_FEdata ! get properties of the different types of elements - call mesh_build_cellconnectivity - if (myDebug) write(6,'(a)') ' Built cell connectivity'; flush(6) - mesh_cellnode = mesh_build_cellnodes(mesh_node,mesh_Ncellnodes) + if (myDebug) write(6,'(a)') ' Built cell nodes'; flush(6) mesh_ipCoordinates = mesh_build_ipCoordinates() if (myDebug) write(6,'(a)') ' Built IP coordinates'; flush(6) allocate(mesh_ipVolume(1,theMesh%nElems),source=product([geomSize(1:2),size3]/real([grid(1:2),grid3]))) if (myDebug) write(6,'(a)') ' Built IP volumes'; flush(6) - call mesh_build_ipAreas + mesh_ipArea = mesh_build_ipAreas() + call mesh_build_ipAreas2 if (myDebug) write(6,'(a)') ' Built IP areas'; flush(6) call mesh_spectral_build_ipNeighborhood @@ -261,9 +217,6 @@ subroutine mesh_init(ip,el) !!!! COMPATIBILITY HACK !!!! -! for a homogeneous mesh, all elements have the same number of IPs and and cell nodes. -! hence, xxPerElem instead of maxXX -! better name theMesh%homogenizationAt = mesh_element(3,:) theMesh%microstructureAt = mesh_element(4,:) !!!!!!!!!!!!!!!!!!!!!!!! @@ -643,236 +596,34 @@ end function mesh_nodesAroundCentres !-------------------------------------------------------------------------------------------------- -!> @brief Split CP elements into cells. -!> @details Build a mapping between cells and the corresponding cell nodes ('mesh_cell'). -!> Cell nodes that are also matching nodes are unique in the list of cell nodes, -!> all others (currently) might be stored more than once. -!> Also allocates the 'mesh_node' array. +!> @brief calculation of IP interface areas, allocate globals '_ipArea', and '_ipAreaNormal' !-------------------------------------------------------------------------------------------------- -subroutine mesh_build_cellconnectivity +pure function mesh_build_ipAreas() - implicit none - integer(pInt), dimension(:), allocatable :: & - matchingNode2cellnode - integer(pInt), dimension(:,:), allocatable :: & - cellnodeParent - integer(pInt), dimension(theMesh%elem%Ncellnodes) :: & - localCellnode2globalCellnode - integer(pInt) :: & - e,n,i, & - matchingNodeID, & - localCellnodeID - - integer(pInt), dimension(FE_Ngeomtypes), parameter :: FE_NmatchingNodes = & !< number of nodes that are needed for face matching in a specific type of element geometry - int([ & - 3, & ! element 6 (2D 3node 1ip) - 3, & ! element 125 (2D 6node 3ip) - 4, & ! element 11 (2D 4node 4ip) - 4, & ! element 27 (2D 8node 9ip) - 4, & ! element 134 (3D 4node 1ip) - 4, & ! element 127 (3D 10node 4ip) - 6, & ! element 136 (3D 6node 6ip) - 8, & ! element 117 (3D 8node 1ip) - 8, & ! element 7 (3D 8node 8ip) - 8 & ! element 21 (3D 20node 27ip) - ],pInt) + real(pReal), dimension(6,1,theMesh%nElems) :: mesh_build_ipAreas - allocate(mesh_cell(FE_maxNcellnodesPerCell,theMesh%elem%nIPs,theMesh%nElems), source=0_pInt) - allocate(matchingNode2cellnode(theMesh%nNodes), source=0_pInt) - allocate(cellnodeParent(2_pInt,theMesh%elem%Ncellnodes*theMesh%nElems), source=0_pInt) - - mesh_Ncells = theMesh%nElems*theMesh%elem%nIPs -!-------------------------------------------------------------------------------------------------- -! Count cell nodes (including duplicates) and generate cell connectivity list - mesh_Ncellnodes = 0_pInt - - do e = 1_pInt,theMesh%nElems - localCellnode2globalCellnode = 0_pInt - do i = 1_pInt,theMesh%elem%nIPs - do n = 1_pInt,theMesh%elem%NcellnodesPerCell - localCellnodeID = theMesh%elem%cell(n,i) - if (localCellnodeID <= FE_NmatchingNodes(theMesh%elem%geomType)) then ! this cell node is a matching node - matchingNodeID = mesh_element(4_pInt+localCellnodeID,e) - if (matchingNode2cellnode(matchingNodeID) == 0_pInt) then ! if this matching node does not yet exist in the glbal cell node list ... - mesh_Ncellnodes = mesh_Ncellnodes + 1_pInt ! ... count it as cell node ... - matchingNode2cellnode(matchingNodeID) = mesh_Ncellnodes ! ... and remember its global ID - cellnodeParent(1_pInt,mesh_Ncellnodes) = e ! ... and where it belongs to - cellnodeParent(2_pInt,mesh_Ncellnodes) = localCellnodeID - endif - mesh_cell(n,i,e) = matchingNode2cellnode(matchingNodeID) - else ! this cell node is no matching node - if (localCellnode2globalCellnode(localCellnodeID) == 0_pInt) then ! if this local cell node does not yet exist in the global cell node list ... - mesh_Ncellnodes = mesh_Ncellnodes + 1_pInt ! ... count it as cell node ... - localCellnode2globalCellnode(localCellnodeID) = mesh_Ncellnodes ! ... and remember its global ID ... - cellnodeParent(1_pInt,mesh_Ncellnodes) = e ! ... and it belongs to - cellnodeParent(2_pInt,mesh_Ncellnodes) = localCellnodeID - endif - mesh_cell(n,i,e) = localCellnode2globalCellnode(localCellnodeID) - endif - enddo - enddo - enddo - - allocate(mesh_cellnodeParent(2_pInt,mesh_Ncellnodes)) - allocate(mesh_cellnode(3_pInt,mesh_Ncellnodes)) - - forall(n = 1_pInt:mesh_Ncellnodes) - mesh_cellnodeParent(1,n) = cellnodeParent(1,n) - mesh_cellnodeParent(2,n) = cellnodeParent(2,n) - endforall - -end subroutine mesh_build_cellconnectivity - - -!-------------------------------------------------------------------------------------------------- -!> @brief Calculate position of cellnodes from the given position of nodes -!> Build list of cellnodes' coordinates. -!> Cellnode coordinates are calculated from a weighted sum of node coordinates. -!-------------------------------------------------------------------------------------------------- -function mesh_build_cellnodes(nodes,Ncellnodes) - - implicit none - integer(pInt), intent(in) :: Ncellnodes !< requested number of cellnodes - real(pReal), dimension(3,mesh_Nnodes), intent(in) :: nodes - real(pReal), dimension(3,Ncellnodes) :: mesh_build_cellnodes - - integer(pInt) :: & - e,n,m, & - localCellnodeID - real(pReal), dimension(3) :: & - myCoords - - mesh_build_cellnodes = 0.0_pReal -!$OMP PARALLEL DO PRIVATE(e,localCellnodeID,myCoords) - do n = 1_pInt,Ncellnodes ! loop over cell nodes - e = mesh_cellnodeParent(1,n) - localCellnodeID = mesh_cellnodeParent(2,n) - myCoords = 0.0_pReal - do m = 1_pInt,theMesh%elem%nNodes - myCoords = myCoords + nodes(1:3,mesh_element(4_pInt+m,e)) & - * theMesh%elem%cellNodeParentNodeWeights(m,localCellnodeID) - enddo - mesh_build_cellnodes(1:3,n) = myCoords / sum(theMesh%elem%cellNodeParentNodeWeights(:,localCellnodeID)) - enddo -!$OMP END PARALLEL DO - -end function mesh_build_cellnodes - - -!-------------------------------------------------------------------------------------------------- -!> @brief Calculates IP Coordinates. Allocates global array 'mesh_ipCoordinates' -! Called by all solvers in mesh_init in order to initialize the ip coordinates. -! Later on the current ip coordinates are directly prvided by the spectral solver and by Abaqus, -! so no need to use this subroutine anymore; Marc however only provides nodal displacements, -! so in this case the ip coordinates are always calculated on the basis of this subroutine. -! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -! FOR THE MOMENT THIS SUBROUTINE ACTUALLY CALCULATES THE CELL CENTER AND NOT THE IP COORDINATES, -! AS THE IP IS NOT (ALWAYS) LOCATED IN THE CENTER OF THE IP VOLUME. -! HAS TO BE CHANGED IN A LATER VERSION. -! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -!-------------------------------------------------------------------------------------------------- + mesh_build_ipAreas(1:2,1,:) = geomSize(2)/real(grid(2)) * geomSize(3)/real(grid(3)) + mesh_build_ipAreas(3:4,1,:) = geomSize(3)/real(grid(3)) * geomSize(1)/real(grid(1)) + mesh_build_ipAreas(5:6,1,:) = geomSize(1)/real(grid(1)) * geomSize(2)/real(grid(2)) + +end function mesh_build_ipAreas !-------------------------------------------------------------------------------------------------- !> @brief calculation of IP interface areas, allocate globals '_ipArea', and '_ipAreaNormal' !-------------------------------------------------------------------------------------------------- -subroutine mesh_build_ipAreas - use math, only: & - math_crossproduct +subroutine mesh_build_ipAreas2 - implicit none - integer(pInt) :: e,t,g,c,i,f,n,m - real(pReal), dimension (3,FE_maxNcellnodesPerCellface) :: nodePos, normals - real(pReal), dimension(3) :: normal + allocate(mesh_ipAreaNormal(3,6,1,theMesh%nElems), source=0.0_pReal) - allocate(mesh_ipArea(theMesh%elem%nIPneighbors,theMesh%elem%nIPs,theMesh%nElems), source=0.0_pReal) - allocate(mesh_ipAreaNormal(3_pInt,theMesh%elem%nIPneighbors,theMesh%elem%nIPs,theMesh%nElems), source=0.0_pReal) - - !$OMP PARALLEL DO PRIVATE(t,g,c,nodePos,normal,normals) - do e = 1_pInt,theMesh%nElems ! loop over cpElems - c = theMesh%elem%cellType - select case (c) - - case (4_pInt) - ! for this cell type we get the normal of the quadrilateral face as an average of - ! four normals of triangular subfaces; since the face consists only of two triangles, - ! the sum has to be divided by two; this whole prcedure tries to compensate for - ! probable non-planar cell surfaces - m = FE_NcellnodesPerCellface(c) - do i = 1_pInt,theMesh%elem%nIPs ! loop over ips=cells in this element - do f = 1_pInt,FE_NipNeighbors(c) ! loop over cell faces - forall(n = 1_pInt:FE_NcellnodesPerCellface(c)) & - nodePos(1:3,n) = mesh_cellnode(1:3,mesh_cell(FE_cellface(n,f,c),i,e)) - forall(n = 1_pInt:FE_NcellnodesPerCellface(c)) & - normals(1:3,n) = 0.5_pReal & - * math_crossproduct(nodePos(1:3,1+mod(n ,m)) - nodePos(1:3,n), & - nodePos(1:3,1+mod(n+1,m)) - nodePos(1:3,n)) - normal = 0.5_pReal * sum(normals,2) - mesh_ipArea(f,i,e) = norm2(normal) - mesh_ipAreaNormal(1:3,f,i,e) = normal / norm2(normal) - enddo - enddo - - end select - enddo - !$OMP END PARALLEL DO - -end subroutine mesh_build_ipAreas - - -!-------------------------------------------------------------------------------------------------- -!> @brief get properties of different types of finite elements -!> @details assign globals: FE_nodesAtIP, FE_ipNeighbor, FE_subNodeOnIPFace -!-------------------------------------------------------------------------------------------------- -subroutine mesh_build_FEdata - - implicit none - integer(pInt) :: me - allocate(FE_cellface(FE_maxNcellnodesPerCellface,FE_maxNcellfaces,FE_Ncelltypes), source=0_pInt) - - - ! *** FE_cellface *** - me = 0_pInt - - me = me + 1_pInt - FE_cellface(1:FE_NcellnodesPerCellface(me),1:FE_NipNeighbors(me),me) = & ! 2D 3node, VTK_TRIANGLE (5) - reshape(int([& - 2,3, & - 3,1, & - 1,2 & - ],pInt),[FE_NcellnodesPerCellface(me),FE_NipNeighbors(me)]) - - me = me + 1_pInt - FE_cellface(1:FE_NcellnodesPerCellface(me),1:FE_NipNeighbors(me),me) = & ! 2D 4node, VTK_QUAD (9) - reshape(int([& - 2,3, & - 4,1, & - 3,4, & - 1,2 & - ],pInt),[FE_NcellnodesPerCellface(me),FE_NipNeighbors(me)]) - - me = me + 1_pInt - FE_cellface(1:FE_NcellnodesPerCellface(me),1:FE_NipNeighbors(me),me) = & ! 3D 4node, VTK_TETRA (10) - reshape(int([& - 1,3,2, & - 1,2,4, & - 2,3,4, & - 1,4,3 & - ],pInt),[FE_NcellnodesPerCellface(me),FE_NipNeighbors(me)]) - - me = me + 1_pInt - FE_cellface(1:FE_NcellnodesPerCellface(me),1:FE_NipNeighbors(me),me) = & ! 3D 8node, VTK_HEXAHEDRON (12) - reshape(int([& - 2,3,7,6, & - 4,1,5,8, & - 3,4,8,7, & - 1,2,6,5, & - 5,6,7,8, & - 1,4,3,2 & - ],pInt),[FE_NcellnodesPerCellface(me),FE_NipNeighbors(me)]) + mesh_ipAreaNormal(1:3,1,1,:) = spread([+1.0_pReal, 0.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_ipAreaNormal(1:3,2,1,:) = spread([-1.0_pReal, 0.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_ipAreaNormal(1:3,3,1,:) = spread([ 0.0_pReal,+1.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_ipAreaNormal(1:3,4,1,:) = spread([ 0.0_pReal,-1.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_ipAreaNormal(1:3,5,1,:) = spread([ 0.0_pReal, 0.0_pReal,+1.0_pReal],2,theMesh%nElems) + mesh_ipAreaNormal(1:3,6,1,:) = spread([ 0.0_pReal, 0.0_pReal,-1.0_pReal],2,theMesh%nElems) - -end subroutine mesh_build_FEdata +end subroutine mesh_build_ipAreas2 end module mesh From c9f1f8756d48a632df05cb9bac2c35b500edd171 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 14 May 2019 06:06:01 +0200 Subject: [PATCH 10/36] better name/not needed --- src/mesh_grid.f90 | 36 +++++++++++++++--------------------- 1 file changed, 15 insertions(+), 21 deletions(-) diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index a7da77bf0..320024dc3 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -35,7 +35,7 @@ module mesh mesh_unitlength !< physical length of one unit in mesh real(pReal), dimension(:,:), allocatable, private :: & - mesh_node !< node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) + mesh_node !< node x,y,z coordinates (after deformation! ONLY FOR MARC!!!) real(pReal), dimension(:,:), allocatable, public, protected :: & @@ -54,14 +54,7 @@ module mesh logical, dimension(3), public, parameter :: mesh_periodicSurface = .true. !< flag indicating periodic outer surfaces (used for fluxes) - integer(pInt),dimension(:,:,:), allocatable, private :: & - mesh_cell !< cell connectivity for each element,ip/cell - - integer(pInt), parameter, private :: & - FE_Ngeomtypes = 10_pInt, & - FE_Ncelltypes = 4_pInt, & - FE_maxNcellnodesPerCell = 8_pInt - +! grid specific integer(pInt), dimension(3), public, protected :: & grid !< (global) grid integer(pInt), public, protected :: & @@ -79,6 +72,7 @@ module mesh private :: & mesh_build_ipAreas, & + mesh_build_ipNormals, & mesh_spectral_build_nodes, & mesh_spectral_build_elements, & mesh_spectral_build_ipNeighborhood, & @@ -198,8 +192,8 @@ subroutine mesh_init(ip,el) if (myDebug) write(6,'(a)') ' Built IP coordinates'; flush(6) allocate(mesh_ipVolume(1,theMesh%nElems),source=product([geomSize(1:2),size3]/real([grid(1:2),grid3]))) if (myDebug) write(6,'(a)') ' Built IP volumes'; flush(6) - mesh_ipArea = mesh_build_ipAreas() - call mesh_build_ipAreas2 + mesh_ipArea = mesh_build_ipAreas() + mesh_ipAreaNormal = mesh_build_ipNormals() if (myDebug) write(6,'(a)') ' Built IP areas'; flush(6) call mesh_spectral_build_ipNeighborhood @@ -220,7 +214,7 @@ subroutine mesh_init(ip,el) theMesh%homogenizationAt = mesh_element(3,:) theMesh%microstructureAt = mesh_element(4,:) !!!!!!!!!!!!!!!!!!!!!!!! - deallocate(mesh_cell) + end subroutine mesh_init @@ -612,18 +606,18 @@ end function mesh_build_ipAreas !-------------------------------------------------------------------------------------------------- !> @brief calculation of IP interface areas, allocate globals '_ipArea', and '_ipAreaNormal' !-------------------------------------------------------------------------------------------------- -subroutine mesh_build_ipAreas2 +pure function mesh_build_ipNormals() - allocate(mesh_ipAreaNormal(3,6,1,theMesh%nElems), source=0.0_pReal) + real, dimension(3,6,1,theMesh%nElems) :: mesh_build_ipNormals - mesh_ipAreaNormal(1:3,1,1,:) = spread([+1.0_pReal, 0.0_pReal, 0.0_pReal],2,theMesh%nElems) - mesh_ipAreaNormal(1:3,2,1,:) = spread([-1.0_pReal, 0.0_pReal, 0.0_pReal],2,theMesh%nElems) - mesh_ipAreaNormal(1:3,3,1,:) = spread([ 0.0_pReal,+1.0_pReal, 0.0_pReal],2,theMesh%nElems) - mesh_ipAreaNormal(1:3,4,1,:) = spread([ 0.0_pReal,-1.0_pReal, 0.0_pReal],2,theMesh%nElems) - mesh_ipAreaNormal(1:3,5,1,:) = spread([ 0.0_pReal, 0.0_pReal,+1.0_pReal],2,theMesh%nElems) - mesh_ipAreaNormal(1:3,6,1,:) = spread([ 0.0_pReal, 0.0_pReal,-1.0_pReal],2,theMesh%nElems) + mesh_build_ipNormals(1:3,1,1,:) = spread([+1.0_pReal, 0.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_build_ipNormals(1:3,2,1,:) = spread([-1.0_pReal, 0.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_build_ipNormals(1:3,3,1,:) = spread([ 0.0_pReal,+1.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_build_ipNormals(1:3,4,1,:) = spread([ 0.0_pReal,-1.0_pReal, 0.0_pReal],2,theMesh%nElems) + mesh_build_ipNormals(1:3,5,1,:) = spread([ 0.0_pReal, 0.0_pReal,+1.0_pReal],2,theMesh%nElems) + mesh_build_ipNormals(1:3,6,1,:) = spread([ 0.0_pReal, 0.0_pReal,-1.0_pReal],2,theMesh%nElems) -end subroutine mesh_build_ipAreas2 +end function mesh_build_ipNormals end module mesh From 8dea95879c22fadfde569e8b6704246f8ddcd45a Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 14 May 2019 07:22:29 +0200 Subject: [PATCH 11/36] specific for nonlocal, can be calculated during post processing --- src/crystallite.f90 | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/src/crystallite.f90 b/src/crystallite.f90 index 02aec8b7a..41d1cb1c3 100644 --- a/src/crystallite.f90 +++ b/src/crystallite.f90 @@ -87,7 +87,6 @@ module crystallite enumerator :: undefined_ID, & phase_ID, & texture_ID, & - volume_ID, & orientation_ID, & grainrotation_ID, & defgrad_ID, & @@ -273,8 +272,6 @@ subroutine crystallite_init crystallite_outputID(o,c) = phase_ID case ('texture') outputName crystallite_outputID(o,c) = texture_ID - case ('volume') outputName - crystallite_outputID(o,c) = volume_ID case ('orientation') outputName crystallite_outputID(o,c) = orientation_ID case ('grainrotation') outputName @@ -323,7 +320,7 @@ subroutine crystallite_init do r = 1,size(config_crystallite) do o = 1,crystallite_Noutput(r) select case(crystallite_outputID(o,r)) - case(phase_ID,texture_ID,volume_ID) + case(phase_ID,texture_ID) mySize = 1 case(orientation_ID,grainrotation_ID) mySize = 4 @@ -948,7 +945,6 @@ function crystallite_postResults(ipc, ip, el) use mesh, only: & theMesh, & mesh_element, & - mesh_ipVolume, & mesh_ipNeighborhood use material, only: & plasticState, & @@ -999,11 +995,6 @@ function crystallite_postResults(ipc, ip, el) case (texture_ID) mySize = 1 crystallite_postResults(c+1) = real(material_texture(ipc,ip,el),pReal) ! textureID of grain - case (volume_ID) - mySize = 1 - detF = math_det33(crystallite_partionedF(1:3,1:3,ipc,ip,el)) ! V_current = det(F) * V_reference - crystallite_postResults(c+1) = detF * mesh_ipVolume(ip,el) & - / real(homogenization_Ngrains(mesh_element(3,el)),pReal) ! grain volume (not fraction but absolute) case (orientation_ID) mySize = 4 crystallite_postResults(c+1:c+mySize) = crystallite_orientation(ipc,ip,el)%asQuaternion() From a8b9b5d1c901ce6f5750a9c7807054d73794e3d8 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 14 May 2019 08:11:23 +0200 Subject: [PATCH 12/36] homogenizationAt array had wrong shape for MPI (too large) --- src/crystallite.f90 | 2 +- src/mesh_grid.f90 | 16 +++++----------- 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/crystallite.f90 b/src/crystallite.f90 index 41d1cb1c3..e972ff162 100644 --- a/src/crystallite.f90 +++ b/src/crystallite.f90 @@ -299,7 +299,7 @@ subroutine crystallite_init case ('neighboringelement') outputName ! ToDo: this is not a result, it is static. Should be written out by mesh crystallite_outputID(o,c) = neighboringelement_ID case default outputName - call IO_error(105,ext_msg=trim(str(o))//' (Crystallite)') + !call IO_error(105,ext_msg=trim(str(o))//' (Crystallite)') end select outputName enddo enddo diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index 320024dc3..685a53ba8 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -13,12 +13,7 @@ module mesh implicit none private integer(pInt), public, protected :: & - mesh_Nnodes, & !< total number of nodes in mesh - mesh_Ncellnodes, & !< total number of cell nodes in mesh (including duplicates) - mesh_Ncells, & !< total number of cells in mesh - mesh_maxNipNeighbors, & !< max number of IP neighbors in any CP element - mesh_maxNsharedElems !< max number of CP elements sharing a node - + mesh_Nnodes integer(pInt), dimension(:), allocatable, private :: & microGlobal @@ -138,9 +133,8 @@ subroutine mesh_init(ip,el) implicit none include 'fftw3-mpi.f03' integer(C_INTPTR_T) :: devNull, local_K, local_K_offset - integer :: ierr, worldsize, i + integer :: ierr, worldsize, j integer(pInt), intent(in), optional :: el, ip - integer(pInt) :: j logical :: myDebug write(6,'(/,a)') ' <<<+- mesh init -+>>>' @@ -179,10 +173,10 @@ subroutine mesh_init(ip,el) call theMesh%init(mesh_node) call theMesh%setNelems(product(grid(1:2))*grid3) - mesh_homogenizationAt = mesh_homogenizationAt(product(grid(1:2))*grid3) ! reallocate/shrink in case of MPI - mesh_maxNipNeighbors = theMesh%elem%nIPneighbors - call mesh_spectral_build_elements() + mesh_homogenizationAt = mesh_homogenizationAt(product(grid(1:2))*grid3Offset+1: & + product(grid(1:2))*(grid3Offset+grid3)) ! reallocate/shrink in case of MPI + if (myDebug) write(6,'(a)') ' Built elements'; flush(6) From 4bce087d3d44350aa591b9bfefd103d2e3aa446d Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 14 May 2019 11:32:25 +0200 Subject: [PATCH 13/36] separating functionality (stub only) - mesh (initialization depends on type of solver) only provides information about number of elements, IPs and writes out displacements - new module (will get setter functions for solver specific initialization) will provide information that is only used by the nonlocal model --- src/commercialFEM_fileList.f90 | 1 + src/geometry_plastic_nonlocal.f90 | 28 ++++++++++++++++++++++++++++ src/plastic_nonlocal.f90 | 11 ++++++++--- 3 files changed, 37 insertions(+), 3 deletions(-) create mode 100644 src/geometry_plastic_nonlocal.f90 diff --git a/src/commercialFEM_fileList.f90 b/src/commercialFEM_fileList.f90 index 0ae1323f0..ef3870ece 100644 --- a/src/commercialFEM_fileList.f90 +++ b/src/commercialFEM_fileList.f90 @@ -28,6 +28,7 @@ #endif #include "material.f90" #include "lattice.f90" +#include "geometry_plastic_nonlocal.f90" #include "source_thermal_dissipation.f90" #include "source_thermal_externalheat.f90" #include "source_damage_isoBrittle.f90" diff --git a/src/geometry_plastic_nonlocal.f90 b/src/geometry_plastic_nonlocal.f90 new file mode 100644 index 000000000..579004b2f --- /dev/null +++ b/src/geometry_plastic_nonlocal.f90 @@ -0,0 +1,28 @@ +!-------------------------------------------------------------------------------------------------- +!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH +!> @author Christoph Koords, Max-Planck-Institut für Eisenforschung GmbH +!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH +!> @brief Geometric information about the IP cells needed for the nonlocal +! plasticity model +!-------------------------------------------------------------------------------------------------- +module geometry_plastic_nonlocal + use prec + + implicit none + private + logical, dimension(3), public, parameter :: & + geometry_plastic_nonlocal_periodicSurface = .true. !< flag indicating periodic outer surfaces (used for fluxes) NEEDED? + + integer, dimension(:,:,:,:), allocatable, public, protected :: & + geometry_plastic_nonlocal_IPneighborhood !< 6 or less neighboring IPs as [element_num, IP_index, neighbor_index that points to me] + + real(pReal), dimension(:,:), allocatable, public, protected :: & + geometry_plastic_nonlocal_IPvolume !< volume associated with IP (initially!) + + real(pReal), dimension(:,:,:), allocatable, public, protected :: & + geometry_plastic_nonlocal_IParea !< area of interface to neighboring IP (initially!) + + real(pReal),dimension(:,:,:,:), allocatable, public, protected :: & + geometry_plastic_nonlocal_IPareaNormal !< area normal of interface to neighboring IP (initially!) + +end module geometry_plastic_nonlocal diff --git a/src/plastic_nonlocal.f90 b/src/plastic_nonlocal.f90 index 6097bbbc8..66e8f8980 100644 --- a/src/plastic_nonlocal.f90 +++ b/src/plastic_nonlocal.f90 @@ -5,10 +5,15 @@ !> @brief material subroutine for plasticity including dislocation flux !-------------------------------------------------------------------------------------------------- module plastic_nonlocal - use prec, only: & - pReal + use prec use future - + use geometry_plastic_nonlocal, only: & + periodicSurface => geometry_plastic_nonlocal_periodicSurface, & + IPneighborhood => geometry_plastic_nonlocal_IPneighborhood, & + IPvolume => geometry_plastic_nonlocal_IPvolume, & + IParea => geometry_plastic_nonlocal_IParea, & + IPareaNormal => geometry_plastic_nonlocal_IPareaNormal + implicit none private real(pReal), parameter, private :: & From 0dbc6fb435f0dc503410672894c08deb89de516e Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 14 May 2019 11:52:28 +0200 Subject: [PATCH 14/36] usage example --- src/commercialFEM_fileList.f90 | 2 +- src/geometry_plastic_nonlocal.f90 | 24 ++++++++++++++++++++++++ src/mesh_grid.f90 | 4 +++- 3 files changed, 28 insertions(+), 2 deletions(-) diff --git a/src/commercialFEM_fileList.f90 b/src/commercialFEM_fileList.f90 index ef3870ece..1c7287813 100644 --- a/src/commercialFEM_fileList.f90 +++ b/src/commercialFEM_fileList.f90 @@ -14,6 +14,7 @@ #include "Lambert.f90" #include "rotations.f90" #include "FEsolving.f90" +#include "geometry_plastic_nonlocal.f90" #include "element.f90" #include "mesh_base.f90" #ifdef Abaqus @@ -28,7 +29,6 @@ #endif #include "material.f90" #include "lattice.f90" -#include "geometry_plastic_nonlocal.f90" #include "source_thermal_dissipation.f90" #include "source_thermal_externalheat.f90" #include "source_damage_isoBrittle.f90" diff --git a/src/geometry_plastic_nonlocal.f90 b/src/geometry_plastic_nonlocal.f90 index 579004b2f..0b63b7f9c 100644 --- a/src/geometry_plastic_nonlocal.f90 +++ b/src/geometry_plastic_nonlocal.f90 @@ -24,5 +24,29 @@ module geometry_plastic_nonlocal real(pReal),dimension(:,:,:,:), allocatable, public, protected :: & geometry_plastic_nonlocal_IPareaNormal !< area normal of interface to neighboring IP (initially!) + + public :: & + geometry_plastic_nonlocal_set_IPneighborhood, & + geometry_plastic_nonlocal_set_IPvolume + + contains + +subroutine geometry_plastic_nonlocal_set_IPneighborhood(IPneighborhood) + + integer, dimension(:,:,:,:), intent(in) :: IPneighborhood + + geometry_plastic_nonlocal_IPneighborhood = IPneighborhood + +end subroutine geometry_plastic_nonlocal_set_IPneighborhood + + +subroutine geometry_plastic_nonlocal_set_IPvolume(IPvolume) + + real(pReal), dimension(:,:), intent(in) :: IPvolume + + geometry_plastic_nonlocal_IPvolume = IPvolume + +end subroutine geometry_plastic_nonlocal_set_IPvolume + end module geometry_plastic_nonlocal diff --git a/src/mesh_grid.f90 b/src/mesh_grid.f90 index 685a53ba8..d873e3542 100644 --- a/src/mesh_grid.f90 +++ b/src/mesh_grid.f90 @@ -7,7 +7,8 @@ !-------------------------------------------------------------------------------------------------- module mesh use, intrinsic :: iso_c_binding - use prec, only: pReal, pInt + use prec + use geometry_plastic_nonlocal use mesh_base implicit none @@ -191,6 +192,7 @@ subroutine mesh_init(ip,el) if (myDebug) write(6,'(a)') ' Built IP areas'; flush(6) call mesh_spectral_build_ipNeighborhood + call geometry_plastic_nonlocal_set_IPneighborhood(mesh_ipNeighborhood) if (myDebug) write(6,'(a)') ' Built IP neighborhood'; flush(6) From e49e3a5d579e1c9beb2dea36f44ecdc1d36f5853 Mon Sep 17 00:00:00 2001 From: Test User Date: Wed, 15 May 2019 23:51:29 +0200 Subject: [PATCH 15/36] [skip ci] updated version information after successful test of v2.0.3-301-g789420c9 --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index acf2aa8dc..69faed072 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-297-gae084bb2 +v2.0.3-301-g789420c9 From f8b335a3a485a1269e93670cd51e8f5db46d5c78 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Thu, 16 May 2019 18:24:54 +0200 Subject: [PATCH 16/36] loop (forall) over integration points wrong this was done for each integration point, but this was not detected for the forall loop --- src/homogenization.f90 | 119 ++++++++++++++++++++--------------------- 1 file changed, 59 insertions(+), 60 deletions(-) diff --git a/src/homogenization.f90 b/src/homogenization.f90 index 77a2e004f..605cf5094 100644 --- a/src/homogenization.f90 +++ b/src/homogenization.f90 @@ -375,43 +375,46 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt) ! initialize restoration points of ... do e = FEsolving_execElem(1),FEsolving_execElem(2) myNgrains = homogenization_Ngrains(mesh_element(3,e)) - do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e); do g = 1,myNgrains + do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e); + do g = 1,myNgrains + + plasticState (phaseAt(g,i,e))%partionedState0(:,phasememberAt(g,i,e)) = & + plasticState (phaseAt(g,i,e))%state0( :,phasememberAt(g,i,e)) + do mySource = 1, phase_Nsources(phaseAt(g,i,e)) + sourceState(phaseAt(g,i,e))%p(mySource)%partionedState0(:,phasememberAt(g,i,e)) = & + sourceState(phaseAt(g,i,e))%p(mySource)%state0( :,phasememberAt(g,i,e)) + enddo + + crystallite_partionedFp0(1:3,1:3,g,i,e) = crystallite_Fp0(1:3,1:3,g,i,e) + crystallite_partionedLp0(1:3,1:3,g,i,e) = crystallite_Lp0(1:3,1:3,g,i,e) + crystallite_partionedFi0(1:3,1:3,g,i,e) = crystallite_Fi0(1:3,1:3,g,i,e) + crystallite_partionedLi0(1:3,1:3,g,i,e) = crystallite_Li0(1:3,1:3,g,i,e) + crystallite_partionedF0(1:3,1:3,g,i,e) = crystallite_F0(1:3,1:3,g,i,e) + crystallite_partionedS0(1:3,1:3,g,i,e) = crystallite_S0(1:3,1:3,g,i,e) - plasticState (phaseAt(g,i,e))%partionedState0(:,phasememberAt(g,i,e)) = & - plasticState (phaseAt(g,i,e))%state0( :,phasememberAt(g,i,e)) - do mySource = 1, phase_Nsources(phaseAt(g,i,e)) - sourceState(phaseAt(g,i,e))%p(mySource)%partionedState0(:,phasememberAt(g,i,e)) = & - sourceState(phaseAt(g,i,e))%p(mySource)%state0( :,phasememberAt(g,i,e)) enddo - crystallite_partionedFp0(1:3,1:3,g,i,e) = crystallite_Fp0(1:3,1:3,g,i,e) ! ...plastic def grads - crystallite_partionedLp0(1:3,1:3,g,i,e) = crystallite_Lp0(1:3,1:3,g,i,e) ! ...plastic velocity grads - crystallite_partionedFi0(1:3,1:3,g,i,e) = crystallite_Fi0(1:3,1:3,g,i,e) ! ...intermediate def grads - crystallite_partionedLi0(1:3,1:3,g,i,e) = crystallite_Li0(1:3,1:3,g,i,e) ! ...intermediate velocity grads - crystallite_partionedF0(1:3,1:3,g,i,e) = crystallite_F0(1:3,1:3,g,i,e) ! ...def grads - crystallite_partionedS0(1:3,1:3,g,i,e) = crystallite_S0(1:3,1:3,g,i,e) ! ...2nd PK stress - enddo; enddo - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e)) - materialpoint_subF0(1:3,1:3,i,e) = materialpoint_F0(1:3,1:3,i,e) ! ...def grad + materialpoint_subF0(1:3,1:3,i,e) = materialpoint_F0(1:3,1:3,i,e) materialpoint_subFrac(i,e) = 0.0_pReal materialpoint_subStep(i,e) = 1.0_pReal/subStepSizeHomog ! <> materialpoint_converged(i,e) = .false. ! pretend failed step of twice the required size materialpoint_requested(i,e) = .true. ! everybody requires calculation - endforall - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - homogState(material_homogenizationAt(e))%sizeState > 0) & - homogState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & - homogState(material_homogenizationAt(e))%State0( :,mappingHomogenization(1,i,e)) ! ...internal homogenization state - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - thermalState(material_homogenizationAt(e))%sizeState > 0) & - thermalState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & - thermalState(material_homogenizationAt(e))%State0( :,mappingHomogenization(1,i,e)) ! ...internal thermal state - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - damageState(material_homogenizationAt(e))%sizeState > 0) & - damageState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & - damageState(material_homogenizationAt(e))%State0( :,mappingHomogenization(1,i,e)) ! ...internal damage state + + if (homogState(material_homogenizationAt(e))%sizeState > 0) & + homogState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & + homogState(material_homogenizationAt(e))%State0( :,mappingHomogenization(1,i,e)) ! ...internal homogenization state + + if (thermalState(material_homogenizationAt(e))%sizeState > 0) & + thermalState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & + thermalState(material_homogenizationAt(e))%State0( :,mappingHomogenization(1,i,e)) ! ...internal thermal state + + if (damageState(material_homogenizationAt(e))%sizeState > 0) & + damageState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & + damageState(material_homogenizationAt(e))%State0( :,mappingHomogenization(1,i,e)) ! ...internal damage state + enddo enddo + NiterationHomog = 0 cutBackLooping: do while (.not. terminallyIll .and. & @@ -422,7 +425,7 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt) myNgrains = homogenization_Ngrains(mesh_element(3,e)) IpLooping1: do i = FEsolving_execIP(1,e),FEsolving_execIP(2,e) - converged: if ( materialpoint_converged(i,e) ) then + converged: if (materialpoint_converged(i,e)) then #ifdef DEBUG if (iand(debug_level(debug_homogenization), debug_levelExtensive) /= 0 & .and. ((e == debug_e .and. i == debug_i) & @@ -443,22 +446,22 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt) ! wind forward grain starting point of... crystallite_partionedF0 (1:3,1:3,1:myNgrains,i,e) = & - crystallite_partionedF(1:3,1:3,1:myNgrains,i,e) ! ...def grads + crystallite_partionedF(1:3,1:3,1:myNgrains,i,e) crystallite_partionedFp0 (1:3,1:3,1:myNgrains,i,e) = & - crystallite_Fp (1:3,1:3,1:myNgrains,i,e) ! ...plastic def grads + crystallite_Fp (1:3,1:3,1:myNgrains,i,e) crystallite_partionedLp0 (1:3,1:3,1:myNgrains,i,e) = & - crystallite_Lp (1:3,1:3,1:myNgrains,i,e) ! ...plastic velocity grads + crystallite_Lp (1:3,1:3,1:myNgrains,i,e) crystallite_partionedFi0 (1:3,1:3,1:myNgrains,i,e) = & - crystallite_Fi (1:3,1:3,1:myNgrains,i,e) ! ...intermediate def grads + crystallite_Fi (1:3,1:3,1:myNgrains,i,e) crystallite_partionedLi0 (1:3,1:3,1:myNgrains,i,e) = & - crystallite_Li (1:3,1:3,1:myNgrains,i,e) ! ...intermediate velocity grads + crystallite_Li (1:3,1:3,1:myNgrains,i,e) crystallite_partionedS0 (1:3,1:3,1:myNgrains,i,e) = & - crystallite_S (1:3,1:3,1:myNgrains,i,e) ! ...2nd PK stress + crystallite_S (1:3,1:3,1:myNgrains,i,e) do g = 1,myNgrains plasticState (phaseAt(g,i,e))%partionedState0(:,phasememberAt(g,i,e)) = & @@ -469,23 +472,22 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt) enddo enddo - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - homogState(material_homogenizationAt(e))%sizeState > 0) & + if(homogState(material_homogenizationAt(e))%sizeState > 0) & homogState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & - homogState(material_homogenizationAt(e))%State (:,mappingHomogenization(1,i,e)) ! ...internal homogenization state - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - thermalState(material_homogenizationAt(e))%sizeState > 0) & + homogState(material_homogenizationAt(e))%State (:,mappingHomogenization(1,i,e)) + if(thermalState(material_homogenizationAt(e))%sizeState > 0) & thermalState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & - thermalState(material_homogenizationAt(e))%State (:,mappingHomogenization(1,i,e)) ! ...internal thermal state - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - damageState(material_homogenizationAt(e))%sizeState > 0) & + thermalState(material_homogenizationAt(e))%State (:,mappingHomogenization(1,i,e)) + if(damageState(material_homogenizationAt(e))%sizeState > 0) & damageState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) = & - damageState(material_homogenizationAt(e))%State (:,mappingHomogenization(1,i,e)) ! ...internal damage state - materialpoint_subF0(1:3,1:3,i,e) = materialpoint_subF(1:3,1:3,i,e) ! ...def grad + damageState(material_homogenizationAt(e))%State (:,mappingHomogenization(1,i,e)) + + materialpoint_subF0(1:3,1:3,i,e) = materialpoint_subF(1:3,1:3,i,e) + endif steppingNeeded else converged - if ( (myNgrains == 1 .and. materialpoint_subStep(i,e) <= 1.0 ) .or. & ! single grain already tried internal subStepping in crystallite + if ( (myNgrains == 1 .and. materialpoint_subStep(i,e) <= 1.0 ) .or. & ! single grain already tried internal subStepping in crystallite subStepSizeHomog * materialpoint_subStep(i,e) <= subStepMinHomog ) then ! would require too small subStep ! cutback makes no sense !$OMP FLUSH(terminallyIll) @@ -514,16 +516,16 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt) ! restore... if (materialpoint_subStep(i,e) < 1.0_pReal) then ! protect against fake cutback from \Delta t = 2 to 1. Maybe that "trick" is not necessary anymore at all? I.e. start with \Delta t = 1 crystallite_Lp(1:3,1:3,1:myNgrains,i,e) = & - crystallite_partionedLp0(1:3,1:3,1:myNgrains,i,e) ! ...plastic velocity grads + crystallite_partionedLp0(1:3,1:3,1:myNgrains,i,e) crystallite_Li(1:3,1:3,1:myNgrains,i,e) = & - crystallite_partionedLi0(1:3,1:3,1:myNgrains,i,e) ! ...intermediate velocity grads + crystallite_partionedLi0(1:3,1:3,1:myNgrains,i,e) endif ! maybe protecting everything from overwriting (not only L) makes even more sense crystallite_Fp(1:3,1:3,1:myNgrains,i,e) = & - crystallite_partionedFp0(1:3,1:3,1:myNgrains,i,e) ! ...plastic def grads + crystallite_partionedFp0(1:3,1:3,1:myNgrains,i,e) crystallite_Fi(1:3,1:3,1:myNgrains,i,e) = & - crystallite_partionedFi0(1:3,1:3,1:myNgrains,i,e) ! ...intermediate def grads + crystallite_partionedFi0(1:3,1:3,1:myNgrains,i,e) crystallite_S(1:3,1:3,1:myNgrains,i,e) = & - crystallite_partionedS0(1:3,1:3,1:myNgrains,i,e) ! ...2nd PK stress + crystallite_partionedS0(1:3,1:3,1:myNgrains,i,e) do g = 1, myNgrains plasticState (phaseAt(g,i,e))%state( :,phasememberAt(g,i,e)) = & plasticState (phaseAt(g,i,e))%partionedState0(:,phasememberAt(g,i,e)) @@ -532,18 +534,15 @@ subroutine materialpoint_stressAndItsTangent(updateJaco,dt) sourceState(phaseAt(g,i,e))%p(mySource)%partionedState0(:,phasememberAt(g,i,e)) enddo enddo - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - homogState(material_homogenizationAt(e))%sizeState > 0) & + if(homogState(material_homogenizationAt(e))%sizeState > 0) & homogState(material_homogenizationAt(e))%State( :,mappingHomogenization(1,i,e)) = & - homogState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) ! ...internal homogenization state - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - thermalState(material_homogenizationAt(e))%sizeState > 0) & + homogState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) + if(thermalState(material_homogenizationAt(e))%sizeState > 0) & thermalState(material_homogenizationAt(e))%State( :,mappingHomogenization(1,i,e)) = & - thermalState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) ! ...internal thermal state - forall(i = FEsolving_execIP(1,e):FEsolving_execIP(2,e), & - damageState(material_homogenizationAt(e))%sizeState > 0) & + thermalState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) + if(damageState(material_homogenizationAt(e))%sizeState > 0) & damageState(material_homogenizationAt(e))%State( :,mappingHomogenization(1,i,e)) = & - damageState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) ! ...internal damage state + damageState(material_homogenizationAt(e))%subState0(:,mappingHomogenization(1,i,e)) endif endif converged From 028bdcff22aed5717f70f63a07a8ee8f5fa3716d Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Thu, 16 May 2019 22:24:42 +0200 Subject: [PATCH 17/36] less compiler complaints --- src/crystallite.f90 | 5 ----- src/damage_local.f90 | 2 +- src/kinematics_cleavage_opening.f90 | 2 +- src/kinematics_slipplane_opening.f90 | 2 +- src/thermal_adiabatic.f90 | 1 - 5 files changed, 3 insertions(+), 9 deletions(-) diff --git a/src/crystallite.f90 b/src/crystallite.f90 index 3116345b6..dce93695a 100644 --- a/src/crystallite.f90 +++ b/src/crystallite.f90 @@ -1125,9 +1125,6 @@ subroutine crystallite_results use config, only: & config_name_phase => phase_name ! anticipate logical name - use material, only: & - material_phase_plasticity_type => phase_plasticity - integer :: p,o real(pReal), allocatable, dimension(:,:,:) :: selected_tensors type(rotation), allocatable, dimension(:) :: selected_rotations @@ -2588,8 +2585,6 @@ logical function stateJump(ipc,ip,el) sourceState, & phase_Nsources, & phaseAt, phasememberAt - use mesh, only: & - mesh_element use constitutive, only: & constitutive_collectDeltaState diff --git a/src/damage_local.f90 b/src/damage_local.f90 index 1ec42f863..2db8cccc1 100644 --- a/src/damage_local.f90 +++ b/src/damage_local.f90 @@ -61,7 +61,7 @@ subroutine damage_local_init config_homogenization - integer :: maxNinstance,homog,instance,o,i + integer :: maxNinstance,homog,instance,i integer :: sizeState integer :: NofMyHomog, h integer(kind(undefined_ID)) :: & diff --git a/src/kinematics_cleavage_opening.f90 b/src/kinematics_cleavage_opening.f90 index 349551d4d..a79dc4042 100644 --- a/src/kinematics_cleavage_opening.f90 +++ b/src/kinematics_cleavage_opening.f90 @@ -71,7 +71,7 @@ subroutine kinematics_cleavage_opening_init() integer, allocatable, dimension(:) :: tempInt real(pReal), allocatable, dimension(:) :: tempFloat - integer :: maxNinstance,p,instance,kinematics + integer :: maxNinstance,p,instance write(6,'(/,a)') ' <<<+- kinematics_'//KINEMATICS_cleavage_opening_LABEL//' init -+>>>' diff --git a/src/kinematics_slipplane_opening.f90 b/src/kinematics_slipplane_opening.f90 index 7a0b2fe99..f29c0e252 100644 --- a/src/kinematics_slipplane_opening.f90 +++ b/src/kinematics_slipplane_opening.f90 @@ -57,7 +57,7 @@ subroutine kinematics_slipplane_opening_init() use lattice - integer :: maxNinstance,p,instance,kinematics + integer :: maxNinstance,p,instance write(6,'(/,a)') ' <<<+- kinematics_'//KINEMATICS_slipplane_opening_LABEL//' init -+>>>' diff --git a/src/thermal_adiabatic.f90 b/src/thermal_adiabatic.f90 index bfc34d1c4..bfd5633d1 100644 --- a/src/thermal_adiabatic.f90 +++ b/src/thermal_adiabatic.f90 @@ -163,7 +163,6 @@ subroutine thermal_adiabatic_getSourceAndItsTangent(Tdot, dTdot_dT, T, ip, el) use material, only: & homogenization_Ngrains, & material_homogenizationAt, & - mappingHomogenization, & phaseAt, & phasememberAt, & thermal_typeInstance, & From 01e3b646c288e1e35535491981cd8304e21f19dd Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Thu, 16 May 2019 22:56:48 +0200 Subject: [PATCH 18/36] don't clutter the code with useless stuff we only need to be more strict about prefixing functions/subroutines/variables to see in which module they reside --- src/Lambert.f90 | 17 +- src/config.f90 | 42 ++-- src/crystallite.f90 | 323 +++-------------------------- src/lattice.f90 | 208 +++++-------------- src/plastic_dislotwin.f90 | 103 ++------- src/plastic_isotropic.f90 | 63 ++---- src/plastic_kinematichardening.f90 | 62 ++---- src/plastic_none.f90 | 7 +- src/plastic_phenopowerlaw.f90 | 50 ++--- src/quaternions.f90 | 5 +- src/rotations.f90 | 86 +------- 11 files changed, 184 insertions(+), 782 deletions(-) diff --git a/src/Lambert.f90 b/src/Lambert.f90 index c7b2c0d49..601cf9984 100644 --- a/src/Lambert.f90 +++ b/src/Lambert.f90 @@ -42,7 +42,8 @@ module Lambert implicit none private - real(pReal), parameter, private :: & + + real(pReal), parameter :: & SPI = sqrt(PI), & PREF = sqrt(6.0_pReal/PI), & A = PI**(5.0_pReal/6.0_pReal)/6.0_pReal**(1.0_pReal/6.0_pReal), & @@ -55,10 +56,8 @@ module Lambert PREK = R1 * 2.0_pReal**(1.0_pReal/4.0_pReal)/BETA public :: & - LambertCubeToBall, & - LambertBallToCube - private :: & - GetPyramidOrder + Lambert_CubeToBall, & + Lambert_BallToCube contains @@ -68,7 +67,7 @@ contains !> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH !> @brief map from 3D cubic grid to 3D ball !-------------------------------------------------------------------------- -function LambertCubeToBall(cube) result(ball) +function Lambert_CubeToBall(cube) result(ball) real(pReal), intent(in), dimension(3) :: cube real(pReal), dimension(3) :: ball, LamXYZ, XYZ @@ -116,7 +115,7 @@ function LambertCubeToBall(cube) result(ball) endif center -end function LambertCubeToBall +end function Lambert_CubeToBall !-------------------------------------------------------------------------- @@ -124,7 +123,7 @@ end function LambertCubeToBall !> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH !> @brief map from 3D ball to 3D cubic grid !-------------------------------------------------------------------------- -pure function LambertBallToCube(xyz) result(cube) +pure function Lambert_BallToCube(xyz) result(cube) real(pReal), intent(in), dimension(3) :: xyz real(pReal), dimension(3) :: cube, xyz1, xyz3 @@ -170,7 +169,7 @@ pure function LambertBallToCube(xyz) result(cube) endif center -end function LambertBallToCube +end function Lambert_BallToCube !-------------------------------------------------------------------------- diff --git a/src/config.f90 b/src/config.f90 index 6bc9e9c0b..8729014ce 100644 --- a/src/config.f90 +++ b/src/config.f90 @@ -7,21 +7,26 @@ !-------------------------------------------------------------------------------------------------- module config use prec + use DAMASK_interface + use IO + use debug use list implicit none private - type(tPartitionedStringList), public, protected, allocatable, dimension(:) :: & + + type(tPartitionedStringList), public, protected, allocatable, dimension(:) :: & config_phase, & config_microstructure, & config_homogenization, & config_texture, & config_crystallite - type(tPartitionedStringList), public, protected :: & + type(tPartitionedStringList), public, protected :: & config_numerics, & config_debug + !ToDo: bad names (how should one know that those variables are defined in config?) character(len=64), dimension(:), allocatable, public, protected :: & phase_name, & !< name of each phase homogenization_name, & !< name of each homogenization @@ -45,19 +50,9 @@ contains !> @brief reads material.config and stores its content per part !-------------------------------------------------------------------------------------------------- subroutine config_init - use DAMASK_interface, only: & - getSolverJobName - use IO, only: & - IO_read_ASCII, & - IO_error, & - IO_lc, & - IO_getTag - use debug, only: & - debug_level, & - debug_material, & - debug_levelBasic - integer :: myDebug,i + integer :: i + logical :: verbose character(len=pStringLen) :: & line, & @@ -67,7 +62,7 @@ subroutine config_init write(6,'(/,a)') ' <<<+- config init -+>>>' - myDebug = debug_level(debug_material) + verbose = iand(debug_level(debug_material),debug_levelBasic) /= 0 inquire(file=trim(getSolverJobName())//'.materialConfig',exist=fileExists) if(fileExists) then @@ -87,23 +82,23 @@ subroutine config_init case (trim('phase')) call parse_materialConfig(phase_name,config_phase,line,fileContent(i+1:)) - if (iand(myDebug,debug_levelBasic) /= 0) write(6,'(a)') ' Phase parsed'; flush(6) + if (verbose) write(6,'(a)') ' Phase parsed'; flush(6) case (trim('microstructure')) call parse_materialConfig(microstructure_name,config_microstructure,line,fileContent(i+1:)) - if (iand(myDebug,debug_levelBasic) /= 0) write(6,'(a)') ' Microstructure parsed'; flush(6) + if (verbose) write(6,'(a)') ' Microstructure parsed'; flush(6) case (trim('crystallite')) call parse_materialConfig(crystallite_name,config_crystallite,line,fileContent(i+1:)) - if (iand(myDebug,debug_levelBasic) /= 0) write(6,'(a)') ' Crystallite parsed'; flush(6) + if (verbose) write(6,'(a)') ' Crystallite parsed'; flush(6) case (trim('homogenization')) call parse_materialConfig(homogenization_name,config_homogenization,line,fileContent(i+1:)) - if (iand(myDebug,debug_levelBasic) /= 0) write(6,'(a)') ' Homogenization parsed'; flush(6) + if (verbose) write(6,'(a)') ' Homogenization parsed'; flush(6) case (trim('texture')) call parse_materialConfig(texture_name,config_texture,line,fileContent(i+1:)) - if (iand(myDebug,debug_levelBasic) /= 0) write(6,'(a)') ' Texture parsed'; flush(6) + if (verbose) write(6,'(a)') ' Texture parsed'; flush(6) end select @@ -141,8 +136,6 @@ contains !! Recursion is triggered by "{path/to/inputfile}" in a line !-------------------------------------------------------------------------------------------------- recursive function read_materialConfig(fileName,cnt) result(fileContent) - use IO, only: & - IO_warning character(len=*), intent(in) :: fileName integer, intent(in), optional :: cnt !< recursion counter @@ -226,9 +219,6 @@ end function read_materialConfig subroutine parse_materialConfig(sectionNames,part,line, & fileContent) - use IO, only: & - IO_intOut - character(len=64), allocatable, dimension(:), intent(out) :: sectionNames type(tPartitionedStringList), allocatable, dimension(:), intent(inout) :: part character(len=pStringLen), intent(inout) :: line @@ -298,8 +288,6 @@ end subroutine config_init !> @brief deallocates the linked lists that store the content of the configuration files !-------------------------------------------------------------------------------------------------- subroutine config_deallocate(what) - use IO, only: & - IO_error character(len=*), intent(in) :: what diff --git a/src/crystallite.f90 b/src/crystallite.f90 index dce93695a..31c859e30 100644 --- a/src/crystallite.f90 +++ b/src/crystallite.f90 @@ -9,36 +9,43 @@ !-------------------------------------------------------------------------------------------------- module crystallite - use prec, only: & - pReal, & - pStringLen - use rotations, only: & - rotation - use FEsolving, only: & - FEsolving_execElem, & - FEsolving_execIP - use material, only: & - homogenization_Ngrains + use prec + use IO + use config + use debug + use numerics + use rotations + use math + use mesh + use FEsolving + use material + use constitutive + use lattice use future + use plastic_nonlocal +#if defined(PETSc) || defined(DAMASK_HDF5) + use HDF5_utilities + use results +#endif implicit none private - character(len=64), dimension(:,:), allocatable, private :: & + character(len=64), dimension(:,:), allocatable :: & crystallite_output !< name of each post result output integer, public, protected :: & crystallite_maxSizePostResults !< description not available integer, dimension(:), allocatable, public, protected :: & crystallite_sizePostResults !< description not available - integer, dimension(:,:), allocatable, private :: & + integer, dimension(:,:), allocatable :: & crystallite_sizePostResult !< description not available real(pReal), dimension(:,:,:), allocatable, public :: & crystallite_dt !< requested time increment of each grain - real(pReal), dimension(:,:,:), allocatable, private :: & + real(pReal), dimension(:,:,:), allocatable :: & crystallite_subdt, & !< substepped time increment of each grain crystallite_subFrac, & !< already calculated fraction of increment crystallite_subStep !< size of next integration step - type(rotation), dimension(:,:,:), allocatable, private :: & + type(rotation), dimension(:,:,:), allocatable :: & crystallite_orientation, & !< orientation crystallite_orientation0 !< initial orientation real(pReal), dimension(:,:,:,:,:), allocatable, public, protected :: & @@ -63,7 +70,7 @@ module crystallite crystallite_Li, & !< current intermediate velocitiy grad (end of converged time step) crystallite_Li0, & !< intermediate velocitiy grad at start of FE inc crystallite_partionedLi0 !< intermediate velocity grad at start of homog inc - real(pReal), dimension(:,:,:,:,:), allocatable, private :: & + real(pReal), dimension(:,:,:,:,:), allocatable :: & crystallite_subS0, & !< 2nd Piola-Kirchhoff stress vector at start of crystallite inc crystallite_invFp, & !< inverse of current plastic def grad (end of converged time step) crystallite_subFp0,& !< plastic def grad at start of crystallite inc @@ -77,7 +84,7 @@ module crystallite crystallite_dPdF !< current individual dPdF per grain (end of converged time step) logical, dimension(:,:,:), allocatable, public :: & crystallite_requested !< used by upper level (homogenization) to request crystallite calculation - logical, dimension(:,:,:), allocatable, private :: & + logical, dimension(:,:,:), allocatable :: & crystallite_converged, & !< convergence flag crystallite_todo, & !< flag to indicate need for further computation crystallite_localPlasticity !< indicates this grain to have purely local constitutive law @@ -101,16 +108,16 @@ module crystallite neighboringip_ID, & neighboringelement_ID end enum - integer(kind(undefined_ID)),dimension(:,:), allocatable, private :: & + integer(kind(undefined_ID)),dimension(:,:), allocatable :: & crystallite_outputID !< ID of each post result output - type, private :: tOutput !< new requested output (per phase) + type :: tOutput !< new requested output (per phase) character(len=65536), allocatable, dimension(:) :: & label end type tOutput - type(tOutput), allocatable, dimension(:), private :: output_constituent + type(tOutput), allocatable, dimension(:) :: output_constituent - type, private :: tNumerics + type :: tNumerics integer :: & iJacoLpresiduum, & !< frequency of Jacobian update of residuum in Lp nState, & !< state loop limit @@ -138,15 +145,6 @@ module crystallite crystallite_push33ToRef, & crystallite_postResults, & crystallite_results - private :: & - integrateStress, & - integrateState, & - integrateStateFPI, & - integrateStateEuler, & - integrateStateAdaptiveEuler, & - integrateStateRK4, & - integrateStateRKCK45, & - stateJump contains @@ -155,39 +153,6 @@ contains !> @brief allocates and initialize per grain variables !-------------------------------------------------------------------------------------------------- subroutine crystallite_init -#ifdef DEBUG - use debug, only: & - debug_info, & - debug_reset, & - debug_level, & - debug_crystallite, & - debug_levelBasic -#endif - use numerics, only: & - numerics_integrator, & - worldrank, & - usePingPong - use math, only: & - math_I3, & - math_EulerToR, & - math_inv33 - use mesh, only: & - theMesh, & - mesh_element - use IO, only: & - IO_stringValue, & - IO_write_jobFile, & - IO_error - use material - use config, only: & - config_deallocate, & - config_crystallite, & - config_numerics, & - config_phase, & - crystallite_name - use constitutive, only: & - constitutive_initialFi, & - constitutive_microstructure ! derived (shortcut) quantities of given state integer, parameter :: FILEUNIT=434 logical, dimension(:,:), allocatable :: devNull @@ -478,34 +443,6 @@ end subroutine crystallite_init !> @brief calculate stress (P) !-------------------------------------------------------------------------------------------------- function crystallite_stress(dummyArgumentToPreventInternalCompilerErrorWithGCC) - use prec, only: & - tol_math_check, & - dNeq0 -#ifdef DEBUG - use debug, only: & - debug_level, & - debug_crystallite, & - debug_levelBasic, & - debug_levelExtensive, & - debug_levelSelective, & - debug_e, & - debug_i, & - debug_g -#endif - use IO, only: & - IO_warning, & - IO_error - use math, only: & - math_inv33 - use mesh, only: & - theMesh, & - mesh_element - use material, only: & - homogenization_Ngrains, & - plasticState, & - sourceState, & - phase_Nsources, & - phaseAt, phasememberAt logical, dimension(theMesh%elem%nIPs,theMesh%Nelems) :: crystallite_stress real(pReal), intent(in), optional :: & @@ -746,30 +683,6 @@ end function crystallite_stress !> @brief calculate tangent (dPdF) !-------------------------------------------------------------------------------------------------- subroutine crystallite_stressTangent - use prec, only: & - tol_math_check, & - dNeq0 - use IO, only: & - IO_warning, & - IO_error - use math, only: & - math_inv33, & - math_identity2nd, & - math_3333to99, & - math_99to3333, & - math_I3, & - math_mul3333xx3333, & - math_mul33xx33, & - math_invert2, & - math_det33 - use mesh, only: & - mesh_element - use material, only: & - homogenization_Ngrains - use constitutive, only: & - constitutive_SandItsTangents, & - constitutive_LpAndItsTangents, & - constitutive_LiAndItsTangents integer :: & c, & !< counter in integration point component loop @@ -910,19 +823,6 @@ end subroutine crystallite_stressTangent !> @brief calculates orientations !-------------------------------------------------------------------------------------------------- subroutine crystallite_orientations - use math, only: & - math_rotationalPart33, & - math_RtoQ - use material, only: & - plasticState, & - material_phase, & - homogenization_Ngrains - use mesh, only: & - mesh_element - use lattice, only: & - lattice_qDisorientation - use plastic_nonlocal, only: & - plastic_nonlocal_updateCompatibility integer & c, & !< counter in integration point component loop @@ -979,28 +879,6 @@ end function crystallite_push33ToRef !> @brief return results of particular grain !-------------------------------------------------------------------------------------------------- function crystallite_postResults(ipc, ip, el) - use math, only: & - math_det33, & - math_I3, & - inDeg - use mesh, only: & - theMesh, & - mesh_element, & - mesh_ipVolume, & - mesh_ipNeighborhood - use material, only: & - plasticState, & - sourceState, & - microstructure_crystallite, & - crystallite_Noutput, & - material_phase, & - material_texture, & - homogenization_Ngrains - use constitutive, only: & - constitutive_homogenizedC, & - constitutive_postResults - use rotations, only: & - rotation integer, intent(in):: & el, & !< element index @@ -1118,10 +996,6 @@ end function crystallite_postResults !-------------------------------------------------------------------------------------------------- subroutine crystallite_results #if defined(PETSc) || defined(DAMASK_HDF5) - use lattice - use results - use HDF5_utilities - use rotations use config, only: & config_name_phase => phase_name ! anticipate logical name @@ -1264,33 +1138,6 @@ end subroutine crystallite_results !> intermediate acceleration of the Newton-Raphson correction !-------------------------------------------------------------------------------------------------- logical function integrateStress(ipc,ip,el,timeFraction) - use, intrinsic :: & - IEEE_arithmetic - use prec, only: tol_math_check, & - dEq0 -#ifdef DEBUG - use debug, only: debug_level, & - debug_e, & - debug_i, & - debug_g, & - debug_crystallite, & - debug_levelBasic, & - debug_levelExtensive, & - debug_levelSelective -#endif - - use constitutive, only: constitutive_LpAndItsTangents, & - constitutive_LiAndItsTangents, & - constitutive_SandItsTangents - use math, only: math_mul33xx33, & - math_mul3333xx3333, & - math_inv33, & - math_det33, & - math_I3, & - math_identity2nd, & - math_3333to99, & - math_33to9, & - math_9to33 integer, intent(in):: el, & ! element index ip, & ! integration point index @@ -1690,27 +1537,6 @@ end function integrateStress !> using Fixed Point Iteration to adapt the stepsize !-------------------------------------------------------------------------------------------------- subroutine integrateStateFPI -#ifdef DEBUG - use debug, only: debug_level, & - debug_e, & - debug_i, & - debug_g, & - debug_crystallite, & - debug_levelBasic, & - debug_levelExtensive, & - debug_levelSelective -#endif - use mesh, only: & - mesh_element - use material, only: & - plasticState, & - sourceState, & - phaseAt, phasememberAt, & - phase_Nsources, & - homogenization_Ngrains - use constitutive, only: & - constitutive_plasticity_maxSizeDotState, & - constitutive_source_maxSizeDotState integer :: & NiterationState, & !< number of iterations in state loop @@ -1898,8 +1724,6 @@ end subroutine integrateStateFPI !> @brief integrate state with 1st order explicit Euler method !-------------------------------------------------------------------------------------------------- subroutine integrateStateEuler - use material, only: & - plasticState call update_dotState(1.0_pReal) call update_state(1.0_pReal) @@ -1916,19 +1740,6 @@ end subroutine integrateStateEuler !> @brief integrate stress, state with 1st order Euler method with adaptive step size !-------------------------------------------------------------------------------------------------- subroutine integrateStateAdaptiveEuler - use mesh, only: & - theMesh, & - mesh_element - use material, only: & - homogenization_Ngrains, & - plasticState, & - sourceState, & - phaseAt, phasememberAt, & - phase_Nsources, & - homogenization_maxNgrains - use constitutive, only: & - constitutive_plasticity_maxSizeDotState, & - constitutive_source_maxSizeDotState integer :: & e, & ! element index in element loop @@ -2022,14 +1833,6 @@ end subroutine integrateStateAdaptiveEuler ! ToDo: This is totally BROKEN: RK4dotState is never used!!! !-------------------------------------------------------------------------------------------------- subroutine integrateStateRK4 - use mesh, only: & - mesh_element - use material, only: & - homogenization_Ngrains, & - plasticState, & - sourceState, & - phase_Nsources, & - phaseAt, phasememberAt real(pReal), dimension(4), parameter :: & TIMESTEPFRACTION = [0.5_pReal, 0.5_pReal, 1.0_pReal, 1.0_pReal] ! factor giving the fraction of the original timestep used for Runge Kutta Integration @@ -2089,19 +1892,6 @@ end subroutine integrateStateRK4 !> adaptive step size (use 5th order solution to advance = "local extrapolation") !-------------------------------------------------------------------------------------------------- subroutine integrateStateRKCK45 - use mesh, only: & - mesh_element, & - theMesh - use material, only: & - homogenization_Ngrains, & - plasticState, & - sourceState, & - phase_Nsources, & - phaseAt, phasememberAt, & - homogenization_maxNgrains - use constitutive, only: & - constitutive_plasticity_maxSizeDotState, & - constitutive_source_maxSizeDotState real(pReal), dimension(5,5), parameter :: & A = reshape([& @@ -2284,8 +2074,6 @@ end subroutine nonlocalConvergenceCheck !> @details: For explicitEuler, RK4 and RKCK45, adaptive Euler and FPI have their on criteria !-------------------------------------------------------------------------------------------------- subroutine setConvergenceFlag - use mesh, only: & - mesh_element integer :: & e, & !< element index in element loop @@ -2324,8 +2112,6 @@ end subroutine setConvergenceFlag !> @brief Standard forwarding of state as state = state0 + dotState * (delta t) !-------------------------------------------------------------------------------------------------- subroutine update_stress(timeFraction) - use mesh, only: & - mesh_element real(pReal), intent(in) :: & timeFraction @@ -2357,8 +2143,6 @@ end subroutine update_stress !> @brief tbd !-------------------------------------------------------------------------------------------------- subroutine update_dependentState - use mesh, only: & - mesh_element use constitutive, only: & constitutive_dependentState => constitutive_microstructure @@ -2384,13 +2168,6 @@ end subroutine update_dependentState !> @brief Standard forwarding of state as state = state0 + dotState * (delta t) !-------------------------------------------------------------------------------------------------- subroutine update_state(timeFraction) - use material, only: & - plasticState, & - sourceState, & - phase_Nsources, & - phaseAt, phasememberAt - use mesh, only: & - mesh_element real(pReal), intent(in) :: & timeFraction @@ -2432,17 +2209,6 @@ end subroutine update_state !> if NaN occurs, crystallite_todo is set to FALSE. Any NaN in a nonlocal propagates to all others !-------------------------------------------------------------------------------------------------- subroutine update_dotState(timeFraction) - use, intrinsic :: & - IEEE_arithmetic - use material, only: & - plasticState, & - sourceState, & - phaseAt, phasememberAt, & - phase_Nsources - use mesh, only: & - mesh_element - use constitutive, only: & - constitutive_collectDotState real(pReal), intent(in) :: & timeFraction @@ -2489,19 +2255,7 @@ end subroutine update_DotState subroutine update_deltaState - use, intrinsic :: & - IEEE_arithmetic - use prec, only: & - dNeq0 - use mesh, only: & - mesh_element - use material, only: & - plasticState, & - sourceState, & - phase_Nsources, & - phaseAt, phasememberAt - use constitutive, only: & - constitutive_collectDeltaState + integer :: & e, & !< element index in element loop i, & !< integration point index in ip loop @@ -2566,27 +2320,6 @@ end subroutine update_deltaState !> returns true, if state jump was successfull or not needed. false indicates NaN in delta state !-------------------------------------------------------------------------------------------------- logical function stateJump(ipc,ip,el) - use, intrinsic :: & - IEEE_arithmetic - use prec, only: & - dNeq0 -#ifdef DEBUG - use debug, only: & - debug_e, & - debug_i, & - debug_g, & - debug_level, & - debug_crystallite, & - debug_levelExtensive, & - debug_levelSelective -#endif - use material, only: & - plasticState, & - sourceState, & - phase_Nsources, & - phaseAt, phasememberAt - use constitutive, only: & - constitutive_collectDeltaState integer, intent(in):: & el, & ! element index diff --git a/src/lattice.f90 b/src/lattice.f90 index 1a7508984..43fc25530 100644 --- a/src/lattice.f90 +++ b/src/lattice.f90 @@ -7,8 +7,10 @@ ! and cleavage as well as interaction among the various systems !-------------------------------------------------------------------------------------------------- module lattice - use prec, only: & - pReal + use prec + use IO + use config + use math use future implicit none @@ -28,25 +30,25 @@ module lattice !-------------------------------------------------------------------------------------------------- ! face centered cubic - integer, dimension(2), parameter, private :: & + integer, dimension(2), parameter :: & LATTICE_FCC_NSLIPSYSTEM = [12, 6] !< # of slip systems per family for fcc - integer, dimension(1), parameter, private :: & + integer, dimension(1), parameter :: & LATTICE_FCC_NTWINSYSTEM = [12] !< # of twin systems per family for fcc - integer, dimension(1), parameter, private :: & + integer, dimension(1), parameter :: & LATTICE_FCC_NTRANSSYSTEM = [12] !< # of transformation systems per family for fcc - integer, dimension(2), parameter, private :: & + integer, dimension(2), parameter :: & LATTICE_FCC_NCLEAVAGESYSTEM = [3, 4] !< # of cleavage systems per family for fcc - integer, parameter, private :: & + integer, parameter :: & LATTICE_FCC_NSLIP = sum(LATTICE_FCC_NSLIPSYSTEM), & !< total # of slip systems for fcc LATTICE_FCC_NTWIN = sum(LATTICE_FCC_NTWINSYSTEM), & !< total # of twin systems for fcc LATTICE_FCC_NTRANS = sum(LATTICE_FCC_NTRANSSYSTEM), & !< total # of transformation systems for fcc LATTICE_FCC_NCLEAVAGE = sum(LATTICE_FCC_NCLEAVAGESYSTEM) !< total # of cleavage systems for fcc - real(pReal), dimension(3+3,LATTICE_FCC_NSLIP), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_FCC_NSLIP), parameter :: & LATTICE_FCC_SYSTEMSLIP = reshape(real([& ! Slip direction Plane normal ! SCHMID-BOAS notation 0, 1,-1, 1, 1, 1, & ! B2 @@ -70,11 +72,11 @@ module lattice 0, 1,-1, 0, 1, 1 & ],pReal),shape(LATTICE_FCC_SYSTEMSLIP)) !< Slip system <110>{111} directions. Sorted according to Eisenlohr & Hantcherli - character(len=*), dimension(2), parameter, private :: LATTICE_FCC_SLIPFAMILY_NAME = & + character(len=*), dimension(2), parameter :: LATTICE_FCC_SLIPFAMILY_NAME = & ['<0 1 -1>{1 1 1}', & '<0 1 -1>{0 1 1}'] - real(pReal), dimension(3+3,LATTICE_FCC_NTWIN), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_FCC_NTWIN), parameter :: & LATTICE_FCC_SYSTEMTWIN = reshape(real( [& -2, 1, 1, 1, 1, 1, & 1,-2, 1, 1, 1, 1, & @@ -90,7 +92,7 @@ module lattice -1, 1, 2, -1, 1,-1 & ],pReal),shape(LATTICE_FCC_SYSTEMTWIN)) !< Twin system <112>{111} directions. Sorted according to Eisenlohr & Hantcherli - character(len=*), dimension(1), parameter, private :: LATTICE_FCC_TWINFAMILY_NAME = & + character(len=*), dimension(1), parameter :: LATTICE_FCC_TWINFAMILY_NAME = & ['<-2 1 1>{1 1 1}'] @@ -110,7 +112,7 @@ module lattice 10,11 & ],shape(LATTICE_FCC_TWINNUCLEATIONSLIPPAIR)) - real(pReal), dimension(3+3,LATTICE_FCC_NCLEAVAGE), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_FCC_NCLEAVAGE), parameter :: & LATTICE_FCC_SYSTEMCLEAVAGE = reshape(real([& ! Cleavage direction Plane normal 0, 1, 0, 1, 0, 0, & @@ -124,21 +126,21 @@ module lattice !-------------------------------------------------------------------------------------------------- ! body centered cubic - integer, dimension(2), parameter, private :: & + integer, dimension(2), parameter :: & LATTICE_BCC_NSLIPSYSTEM = [12, 12] !< # of slip systems per family for bcc - integer, dimension(1), parameter, private :: & + integer, dimension(1), parameter :: & LATTICE_BCC_NTWINSYSTEM = [12] !< # of twin systems per family for bcc - integer, dimension(2), parameter, private :: & + integer, dimension(2), parameter :: & LATTICE_BCC_NCLEAVAGESYSTEM = [3, 6] !< # of cleavage systems per family for bcc - integer, parameter, private :: & + integer, parameter :: & LATTICE_BCC_NSLIP = sum(LATTICE_BCC_NSLIPSYSTEM), & !< total # of slip systems for bcc LATTICE_BCC_NTWIN = sum(LATTICE_BCC_NTWINSYSTEM), & !< total # of twin systems for bcc LATTICE_BCC_NCLEAVAGE = sum(LATTICE_BCC_NCLEAVAGESYSTEM) !< total # of cleavage systems for bcc - real(pReal), dimension(3+3,LATTICE_BCC_NSLIP), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_BCC_NSLIP), parameter :: & LATTICE_BCC_SYSTEMSLIP = reshape(real([& ! Slip direction Plane normal ! Slip system <111>{110} @@ -169,11 +171,11 @@ module lattice 1, 1, 1, 1, 1,-2 & ],pReal),shape(LATTICE_BCC_SYSTEMSLIP)) - character(len=*), dimension(2), parameter, private :: LATTICE_BCC_SLIPFAMILY_NAME = & + character(len=*), dimension(2), parameter :: LATTICE_BCC_SLIPFAMILY_NAME = & ['<1 -1 1>{0 1 1}', & '<1 -1 1>{2 1 1}'] - real(pReal), dimension(3+3,LATTICE_BCC_NTWIN), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_BCC_NTWIN), parameter :: & LATTICE_BCC_SYSTEMTWIN = reshape(real([& ! Twin system <111>{112} -1, 1, 1, 2, 1, 1, & @@ -190,10 +192,10 @@ module lattice 1, 1, 1, 1, 1,-2 & ],pReal),shape(LATTICE_BCC_SYSTEMTWIN)) - character(len=*), dimension(1), parameter, private :: LATTICE_BCC_TWINFAMILY_NAME = & + character(len=*), dimension(1), parameter :: LATTICE_BCC_TWINFAMILY_NAME = & ['<1 1 1>{2 1 1}'] - real(pReal), dimension(3+3,LATTICE_BCC_NCLEAVAGE), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_BCC_NCLEAVAGE), parameter :: & LATTICE_BCC_SYSTEMCLEAVAGE = reshape(real([& ! Cleavage direction Plane normal 0, 1, 0, 1, 0, 0, & @@ -209,21 +211,21 @@ module lattice !-------------------------------------------------------------------------------------------------- ! hexagonal - integer, dimension(6), parameter, private :: & + integer, dimension(6), parameter :: & LATTICE_HEX_NSLIPSYSTEM = [3, 3, 3, 6, 12, 6] !< # of slip systems per family for hex - integer, dimension(4), parameter, private :: & + integer, dimension(4), parameter :: & LATTICE_HEX_NTWINSYSTEM = [6, 6, 6, 6] !< # of slip systems per family for hex - integer, dimension(1), parameter, private :: & + integer, dimension(1), parameter :: & LATTICE_HEX_NCLEAVAGESYSTEM = [3] !< # of cleavage systems per family for hex - integer, parameter, private :: & + integer, parameter :: & LATTICE_HEX_NSLIP = sum(LATTICE_HEX_NSLIPSYSTEM), & !< total # of slip systems for hex LATTICE_HEX_NTWIN = sum(LATTICE_HEX_NTWINSYSTEM), & !< total # of twin systems for hex LATTICE_HEX_NCLEAVAGE = sum(LATTICE_HEX_NCLEAVAGESYSTEM) !< total # of cleavage systems for hex - real(pReal), dimension(4+4,LATTICE_HEX_NSLIP), parameter, private :: & + real(pReal), dimension(4+4,LATTICE_HEX_NSLIP), parameter :: & LATTICE_HEX_SYSTEMSLIP = reshape(real([& ! Slip direction Plane normal ! Basal systems <11.0>{00.1} (independent of c/a-ratio, Bravais notation (4 coordinate base)) @@ -267,7 +269,7 @@ module lattice 1, 1, -2, 3, -1, -1, 2, 2 & ],pReal),shape(LATTICE_HEX_SYSTEMSLIP)) !< slip systems for hex sorted by A. Alankar & P. Eisenlohr - character(len=*), dimension(6), parameter, private :: LATTICE_HEX_SLIPFAMILY_NAME = & + character(len=*), dimension(6), parameter :: LATTICE_HEX_SLIPFAMILY_NAME = & ['<1 1 . 1>{0 0 . 1} ', & '<1 1 . 1>{1 0 . 0} ', & '<1 0 . 0>{1 1 . 0} ', & @@ -275,7 +277,7 @@ module lattice '<1 1 . 3>{-1 0 . 1} ', & '<1 1 . 3>{-1 -1 . 2}'] - real(pReal), dimension(4+4,LATTICE_HEX_NTWIN), parameter, private :: & + real(pReal), dimension(4+4,LATTICE_HEX_NTWIN), parameter :: & LATTICE_HEX_SYSTEMTWIN = reshape(real([& ! Compression or Tension =f(twinning shear=f(c/a)) for each metal ! (according to Yoo 1981) 1, -1, 0, 1, -1, 1, 0, 2, & ! <-10.1>{10.2} shear = (3-(c/a)^2)/(sqrt(3) c/a) @@ -307,13 +309,13 @@ module lattice 1, 1, -2, -3, 1, 1, -2, 2 & ],pReal),shape(LATTICE_HEX_SYSTEMTWIN)) !< twin systems for hex, order follows Prof. Tom Bieler's scheme - character(len=*), dimension(4), parameter, private :: LATTICE_HEX_TWINFAMILY_NAME = & + character(len=*), dimension(4), parameter :: LATTICE_HEX_TWINFAMILY_NAME = & ['<-1 0 . 1>{1 0 . 2} ', & '<1 1 . 6>{-1 -1 . 1}', & '<1 0 . -2>{1 0 . 1} ', & '<1 1 . -3>{1 1 . 2} '] - real(pReal), dimension(4+4,LATTICE_HEX_NCLEAVAGE), parameter, private :: & + real(pReal), dimension(4+4,LATTICE_HEX_NCLEAVAGE), parameter :: & LATTICE_HEX_SYSTEMCLEAVAGE = reshape(real([& ! Cleavage direction Plane normal 2,-1,-1, 0, 0, 0, 0, 1, & @@ -324,13 +326,13 @@ module lattice !-------------------------------------------------------------------------------------------------- ! body centered tetragonal - integer, dimension(13), parameter, private :: & + integer, dimension(13), parameter :: & LATTICE_BCT_NSLIPSYSTEM = [2, 2, 2, 4, 2, 4, 2, 2, 4, 8, 4, 8, 8 ] !< # of slip systems per family for bct (Sn) Bieler J. Electr Mater 2009 - integer, parameter, private :: & + integer, parameter :: & LATTICE_BCT_NSLIP = sum(LATTICE_BCT_NSLIPSYSTEM) !< total # of slip systems for bct - real(pReal), dimension(3+3,LATTICE_BCT_NSLIP), parameter, private :: & + real(pReal), dimension(3+3,LATTICE_BCT_NSLIP), parameter :: & LATTICE_BCT_SYSTEMSLIP = reshape(real([& ! Slip direction Plane normal ! Slip family 1 {100)<001] (Bravais notation {hkl) @brief Module initialization !-------------------------------------------------------------------------------------------------- subroutine lattice_init - use IO, only: & - IO_error - use config, only: & - config_phase integer :: Nphases character(len=65536) :: & @@ -654,15 +652,7 @@ end subroutine lattice_init !> @brief !!!!!!!DEPRECTATED!!!!!! !-------------------------------------------------------------------------------------------------- subroutine lattice_initializeStructure(myPhase,CoverA) - use prec, only: & - tol_math_check - use math, only: & - math_sym3333to66, & - math_Voigt66to3333, & - math_cross - use IO, only: & - IO_error - + integer, intent(in) :: myPhase real(pReal), intent(in) :: & CoverA @@ -690,9 +680,10 @@ subroutine lattice_initializeStructure(myPhase,CoverA) call IO_error(135,el=i,ip=myPhase,ext_msg='matrix diagonal "el"ement of phase "ip"') enddo - forall (i = 1:3) & + do i = 1,3 lattice_thermalExpansion33 (1:3,1:3,i,myPhase) = lattice_symmetrize33(lattice_structure(myPhase),& lattice_thermalExpansion33 (1:3,1:3,i,myPhase)) + enddo lattice_thermalConductivity33 (1:3,1:3,myPhase) = lattice_symmetrize33(lattice_structure(myPhase),& lattice_thermalConductivity33 (1:3,1:3,myPhase)) @@ -763,17 +754,17 @@ pure function lattice_symmetrizeC66(struct,C66) select case(struct) case (LATTICE_iso_ID) - forall(k=1:3) + do k=1,3 forall(j=1:3) lattice_symmetrizeC66(k,j) = C66(1,2) lattice_symmetrizeC66(k,k) = C66(1,1) lattice_symmetrizeC66(k+3,k+3) = 0.5_pReal*(C66(1,1)-C66(1,2)) - end forall + enddo case (LATTICE_fcc_ID,LATTICE_bcc_ID) - forall(k=1:3) + do k=1,3 forall(j=1:3) lattice_symmetrizeC66(k,j) = C66(1,2) lattice_symmetrizeC66(k,k) = C66(1,1) lattice_symmetrizeC66(k+3,k+3) = C66(4,4) - end forall + enddo case (LATTICE_hex_ID) lattice_symmetrizeC66(1,1) = C66(1,1) lattice_symmetrizeC66(2,2) = C66(1,1) @@ -834,7 +825,9 @@ pure function lattice_symmetrize33(struct,T33) select case(struct) case (LATTICE_iso_ID,LATTICE_fcc_ID,LATTICE_bcc_ID) - forall(k=1:3) lattice_symmetrize33(k,k) = T33(1,1) + do k=1,3 + lattice_symmetrize33(k,k) = T33(1,1) + enddo case (LATTICE_hex_ID) lattice_symmetrize33(1,1) = T33(1,1) lattice_symmetrize33(2,2) = T33(1,1) @@ -854,10 +847,6 @@ end function lattice_symmetrize33 !> @brief figures whether unit quat falls into stereographic standard triangle !-------------------------------------------------------------------------------------------------- logical pure function lattice_qInSST(Q, struct) - use, intrinsic :: & - IEEE_arithmetic - use math, only: & - math_qToRodrig real(pReal), dimension(4), intent(in) :: Q ! orientation integer(kind(LATTICE_undefined_ID)), intent(in) :: struct ! lattice structure @@ -888,11 +877,6 @@ end function lattice_qInSST !> @brief calculates the disorientation for 2 unit quaternions !-------------------------------------------------------------------------------------------------- pure function lattice_qDisorientation(Q1, Q2, struct) - use prec, only: & - tol_math_check - use math, only: & - math_qMul, & - math_qConj real(pReal), dimension(4) :: lattice_qDisorientation real(pReal), dimension(4), intent(in) :: & @@ -998,8 +982,6 @@ end function lattice_qDisorientation !> @brief Characteristic shear for twinning !-------------------------------------------------------------------------------------------------- function lattice_characteristicShear_Twin(Ntwin,structure,CoverA) result(characteristicShear) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Ntwin !< number of active twin systems per family character(len=*), intent(in) :: structure !< lattice structure @@ -1077,14 +1059,6 @@ end function lattice_characteristicShear_Twin !> @brief Rotated elasticity matrices for twinning in 66-vector notation !-------------------------------------------------------------------------------------------------- function lattice_C66_twin(Ntwin,C66,structure,CoverA) - use IO, only: & - IO_error - use math, only: & - PI, & - math_axisAngleToR, & - math_sym3333to66, & - math_66toSym3333, & - math_rotate_forward3333 integer, dimension(:), intent(in) :: Ntwin !< number of active twin systems per family character(len=*), intent(in) :: structure !< lattice structure @@ -1125,17 +1099,6 @@ end function lattice_C66_twin !-------------------------------------------------------------------------------------------------- function lattice_C66_trans(Ntrans,C_parent66,structure_target, & CoverA_trans,a_bcc,a_fcc) - use prec, only: & - tol_math_check - use IO, only: & - IO_error - use math, only: & - INRAD, & - MATH_I3, & - math_axisAngleToR, & - math_sym3333to66, & - math_66toSym3333, & - math_rotate_forward3333 integer, dimension(:), intent(in) :: Ntrans !< number of active twin systems per family character(len=*), intent(in) :: structure_target !< lattice structure @@ -1196,13 +1159,6 @@ function lattice_C66_trans(Ntrans,C_parent66,structure_target, & ! Gröger et al. 2008, Acta Materialia 56 (2008) 5412–5425, table 1 !-------------------------------------------------------------------------------------------------- function lattice_nonSchmidMatrix(Nslip,nonSchmidCoefficients,sense) result(nonSchmidMatrix) - use IO, only: & - IO_error - use math, only: & - INRAD, & - math_outer, & - math_cross, & - math_axisAngleToR integer, dimension(:), intent(in) :: Nslip !< number of active slip systems per family real(pReal), dimension(:), intent(in) :: nonSchmidCoefficients !< non-Schmid coefficients for projections @@ -1246,9 +1202,7 @@ end function lattice_nonSchmidMatrix !> details only active slip systems are considered !-------------------------------------------------------------------------------------------------- function lattice_interaction_SlipBySlip(Nslip,interactionValues,structure) result(interactionMatrix) - use IO, only: & - IO_error - + integer, dimension(:), intent(in) :: Nslip !< number of active slip systems per family real(pReal), dimension(:), intent(in) :: interactionValues !< values for slip-slip interaction character(len=*), intent(in) :: structure !< lattice structure @@ -1468,8 +1422,6 @@ end function lattice_interaction_SlipBySlip !> details only active twin systems are considered !-------------------------------------------------------------------------------------------------- function lattice_interaction_TwinByTwin(Ntwin,interactionValues,structure) result(interactionMatrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Ntwin !< number of active twin systems per family real(pReal), dimension(:), intent(in) :: interactionValues !< values for twin-twin interaction @@ -1571,8 +1523,6 @@ end function lattice_interaction_TwinByTwin !> details only active trans systems are considered !-------------------------------------------------------------------------------------------------- function lattice_interaction_TransByTrans(Ntrans,interactionValues,structure) result(interactionMatrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Ntrans !< number of active trans systems per family real(pReal), dimension(:), intent(in) :: interactionValues !< values for trans-trans interaction @@ -1618,8 +1568,6 @@ end function lattice_interaction_TransByTrans !> details only active slip and twin systems are considered !-------------------------------------------------------------------------------------------------- function lattice_interaction_SlipByTwin(Nslip,Ntwin,interactionValues,structure) result(interactionMatrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Nslip, & !< number of active slip systems per family Ntwin !< number of active twin systems per family @@ -1760,8 +1708,6 @@ end function lattice_interaction_SlipByTwin !> details only active slip and trans systems are considered !-------------------------------------------------------------------------------------------------- function lattice_interaction_SlipByTrans(Nslip,Ntrans,interactionValues,structure) result(interactionMatrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Nslip, & !< number of active slip systems per family Ntrans !< number of active trans systems per family @@ -1818,8 +1764,6 @@ function lattice_interaction_SlipByTrans(Nslip,Ntrans,interactionValues,structur !> details only active twin and slip systems are considered !-------------------------------------------------------------------------------------------------- function lattice_interaction_TwinBySlip(Ntwin,Nslip,interactionValues,structure) result(interactionMatrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Ntwin, & !< number of active twin systems per family Nslip !< number of active slip systems per family @@ -1898,13 +1842,6 @@ end function lattice_interaction_TwinBySlip !> details only active slip systems are considered !-------------------------------------------------------------------------------------------------- function lattice_SchmidMatrix_slip(Nslip,structure,cOverA) result(SchmidMatrix) - use prec, only: & - tol_math_check - use IO, only: & - IO_error - use math, only: & - math_trace33, & - math_outer integer, dimension(:), intent(in) :: Nslip !< number of active slip systems per family character(len=*), intent(in) :: structure !< lattice structure @@ -1957,13 +1894,6 @@ end function lattice_SchmidMatrix_slip !> details only active twin systems are considered !-------------------------------------------------------------------------------------------------- function lattice_SchmidMatrix_twin(Ntwin,structure,cOverA) result(SchmidMatrix) - use prec, only: & - tol_math_check - use IO, only: & - IO_error - use math, only: & - math_trace33, & - math_outer integer, dimension(:), intent(in) :: Ntwin !< number of active twin systems per family character(len=*), intent(in) :: structure !< lattice structure @@ -2013,8 +1943,6 @@ function lattice_SchmidMatrix_twin(Ntwin,structure,cOverA) result(SchmidMatrix) !> details only active twin systems are considered !-------------------------------------------------------------------------------------------------- function lattice_SchmidMatrix_trans(Ntrans,structure_target,cOverA,a_bcc,a_fcc) result(SchmidMatrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: Ntrans !< number of active twin systems per family real(pReal), intent(in) :: cOverA !< c/a ratio @@ -2041,11 +1969,7 @@ end function lattice_SchmidMatrix_trans !> details only active cleavage systems are considered !-------------------------------------------------------------------------------------------------- function lattice_SchmidMatrix_cleavage(Ncleavage,structure,cOverA) result(SchmidMatrix) - use math, only: & - math_outer - use IO, only: & - IO_error - + integer, dimension(:), intent(in) :: Ncleavage !< number of active cleavage systems per family character(len=*), intent(in) :: structure !< lattice structure real(pReal), intent(in) :: cOverA !< c/a ratio @@ -2154,8 +2078,6 @@ end function lattice_slip_transverse !> @details: This projection is used to calculate forest hardening for edge dislocations !-------------------------------------------------------------------------------------------------- function slipProjection_transverse(Nslip,structure,cOverA) result(projection) - use math, only: & - math_inner integer, dimension(:), intent(in) :: Nslip !< number of active slip systems per family character(len=*), intent(in) :: structure !< lattice structure @@ -2179,8 +2101,6 @@ end function slipProjection_transverse !> @details: This projection is used to calculate forest hardening for screw dislocations !-------------------------------------------------------------------------------------------------- function slipProjection_direction(Nslip,structure,cOverA) result(projection) - use math, only: & - math_inner integer, dimension(:), intent(in) :: Nslip !< number of active slip systems per family character(len=*), intent(in) :: structure !< lattice structure @@ -2204,9 +2124,7 @@ end function slipProjection_direction !> @details Order: Direction, plane (normal), and common perpendicular !-------------------------------------------------------------------------------------------------- function coordinateSystem_slip(Nslip,structure,cOverA) result(coordinateSystem) - use IO, only: & - IO_error - + integer, dimension(:), intent(in) :: Nslip !< number of active slip systems per family character(len=*), intent(in) :: structure !< lattice structure real(pReal), intent(in) :: cOverA !< c/a ratio @@ -2249,8 +2167,6 @@ end function coordinateSystem_slip !> @brief Populates reduced interaction matrix !-------------------------------------------------------------------------------------------------- function buildInteraction(reacting_used,acting_used,reacting_max,acting_max,values,matrix) - use IO, only: & - IO_error integer, dimension(:), intent(in) :: & reacting_used, & !< # of reacting systems per family as specified in material.config @@ -2295,10 +2211,6 @@ end function buildInteraction !> @details Order: Direction, plane (normal), and common perpendicular !-------------------------------------------------------------------------------------------------- function buildCoordinateSystem(active,complete,system,structure,cOverA) - use IO, only: & - IO_error - use math, only: & - math_cross integer, dimension(:), intent(in) :: & active, & @@ -2370,16 +2282,6 @@ end function buildCoordinateSystem ! set a_bcc = 0.0 for fcc -> hex transformation !-------------------------------------------------------------------------------------------------- subroutine buildTransformationSystem(Q,S,Ntrans,cOverA,a_fcc,a_bcc) - use prec, only: & - dEq0 - use math, only: & - math_cross, & - math_outer, & - math_axisAngleToR, & - INRAD, & - MATH_I3 - use IO, only: & - IO_error integer, dimension(:), intent(in) :: & Ntrans diff --git a/src/plastic_dislotwin.f90 b/src/plastic_dislotwin.f90 index 7db1f5f7f..fd5d8b787 100644 --- a/src/plastic_dislotwin.f90 +++ b/src/plastic_dislotwin.f90 @@ -8,17 +8,26 @@ !> @details to be done !-------------------------------------------------------------------------------------------------- module plastic_dislotwin - use prec, only: & - pReal + use prec + use debug + use math + use IO + use material + use config + use lattice +#if defined(PETSc) || defined(DAMASK_HDF5) + use results +#endif implicit none private + integer, dimension(:,:), allocatable, target, public :: & plastic_dislotwin_sizePostResult !< size of each post result output character(len=64), dimension(:,:), allocatable, target, public :: & plastic_dislotwin_output !< name of each post result output - real(pReal), parameter, private :: & + real(pReal), parameter :: & kB = 1.38e-23_pReal !< Boltzmann constant in J/Kelvin enum, bind(c) @@ -39,7 +48,7 @@ module plastic_dislotwin f_tr_ID end enum - type, private :: tParameters + type :: tParameters real(pReal) :: & mu, & nu, & @@ -119,7 +128,7 @@ module plastic_dislotwin dipoleFormation !< flag indicating consideration of dipole formation end type !< container type for internal constitutive parameters - type, private :: tDislotwinState + type :: tDislotwinState real(pReal), dimension(:,:), pointer :: & rho_mob, & rho_dip, & @@ -128,7 +137,7 @@ module plastic_dislotwin f_tr end type tDislotwinState - type, private :: tDislotwinMicrostructure + type :: tDislotwinMicrostructure real(pReal), dimension(:,:), allocatable :: & Lambda_sl, & !* mean free path between 2 obstacles seen by a moving dislocation Lambda_tw, & !* mean free path between 2 obstacles seen by a growing twin @@ -144,11 +153,11 @@ module plastic_dislotwin !-------------------------------------------------------------------------------------------------- ! containers for parameters and state - type(tParameters), allocatable, dimension(:), private :: param - type(tDislotwinState), allocatable, dimension(:), private :: & + type(tParameters), allocatable, dimension(:) :: param + type(tDislotwinState), allocatable, dimension(:) :: & dotState, & state - type(tDislotwinMicrostructure), allocatable, dimension(:), private :: dependentState + type(tDislotwinMicrostructure), allocatable, dimension(:) :: dependentState public :: & plastic_dislotwin_init, & @@ -158,10 +167,6 @@ module plastic_dislotwin plastic_dislotwin_dotState, & plastic_dislotwin_postResults, & plastic_dislotwin_results - private :: & - kinetics_slip, & - kinetics_twin, & - kinetics_trans contains @@ -171,24 +176,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine plastic_dislotwin_init - use prec, only: & - pStringLen, & - dEq0, & - dNeq0, & - dNeq - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use math, only: & - math_expand,& - PI - use IO, only: & - IO_error - use material - use config, only: & - config_phase - use lattice integer :: & Ninstance, & @@ -591,10 +578,6 @@ end subroutine plastic_dislotwin_init !> @brief returns the homogenized elasticity matrix !-------------------------------------------------------------------------------------------------- function plastic_dislotwin_homogenizedC(ipc,ip,el) result(homogenizedC) - use material, only: & - material_phase, & - phase_plasticityInstance, & - phasememberAt real(pReal), dimension(6,6) :: & homogenizedC @@ -634,14 +617,6 @@ end function plastic_dislotwin_homogenizedC !> @brief calculates plastic velocity gradient and its tangent !-------------------------------------------------------------------------------------------------- subroutine plastic_dislotwin_LpAndItsTangent(Lp,dLp_dMp,Mp,T,instance,of) - use prec, only: & - tol_math_check, & - dNeq0 - use math, only: & - math_eigenValuesVectorsSym, & - math_outer, & - math_symmetric33, & - math_mul33xx33 real(pReal), dimension(3,3), intent(out) :: Lp real(pReal), dimension(3,3,3,3), intent(out) :: dLp_dMp @@ -757,13 +732,6 @@ end subroutine plastic_dislotwin_LpAndItsTangent !> @brief calculates the rate of change of microstructure !-------------------------------------------------------------------------------------------------- subroutine plastic_dislotwin_dotState(Mp,T,instance,of) - use prec, only: & - tol_math_check, & - dEq0 - use math, only: & - math_clip, & - math_mul33xx33, & - PI real(pReal), dimension(3,3), intent(in):: & Mp !< Mandel stress @@ -854,8 +822,6 @@ end subroutine plastic_dislotwin_dotState !> @brief calculates derived quantities from state !-------------------------------------------------------------------------------------------------- subroutine plastic_dislotwin_dependentState(T,instance,of) - use math, only: & - PI integer, intent(in) :: & instance, & @@ -868,13 +834,13 @@ subroutine plastic_dislotwin_dependentState(T,instance,of) real(pReal) :: & sumf_twin,SFE,sumf_trans real(pReal), dimension(param(instance)%sum_N_sl) :: & - inv_lambda_sl_sl, & !* 1/mean free distance between 2 forest dislocations seen by a moving dislocation - inv_lambda_sl_tw, & !* 1/mean free distance between 2 twin stacks from different systems seen by a moving dislocation - inv_lambda_sl_tr !* 1/mean free distance between 2 martensite lamellar from different systems seen by a moving dislocation + inv_lambda_sl_sl, & !< 1/mean free distance between 2 forest dislocations seen by a moving dislocation + inv_lambda_sl_tw, & !< 1/mean free distance between 2 twin stacks from different systems seen by a moving dislocation + inv_lambda_sl_tr !< 1/mean free distance between 2 martensite lamellar from different systems seen by a moving dislocation real(pReal), dimension(param(instance)%sum_N_tw) :: & - inv_lambda_tw_tw !* 1/mean free distance between 2 twin stacks from different systems seen by a growing twin + inv_lambda_tw_tw !< 1/mean free distance between 2 twin stacks from different systems seen by a growing twin real(pReal), dimension(param(instance)%sum_N_tr) :: & - inv_lambda_tr_tr !* 1/mean free distance between 2 martensite stacks from different systems seen by a growing martensite (1/lambda_trans) + inv_lambda_tr_tr !< 1/mean free distance between 2 martensite stacks from different systems seen by a growing martensite real(pReal), dimension(:), allocatable :: & x0, & @@ -967,12 +933,6 @@ end subroutine plastic_dislotwin_dependentState !> @brief return array of constitutive results !-------------------------------------------------------------------------------------------------- function plastic_dislotwin_postResults(Mp,T,instance,of) result(postResults) - use prec, only: & - tol_math_check, & - dEq0 - use math, only: & - PI, & - math_mul33xx33 real(pReal), dimension(3,3),intent(in) :: & Mp !< 2nd Piola Kirchhoff stress tensor in Mandel notation @@ -1050,8 +1010,6 @@ end function plastic_dislotwin_postResults !-------------------------------------------------------------------------------------------------- subroutine plastic_dislotwin_results(instance,group) #if defined(PETSc) || defined(DAMASK_HDF5) - use results, only: & - results_writeDataset integer, intent(in) :: instance character(len=*) :: group @@ -1112,11 +1070,6 @@ end subroutine plastic_dislotwin_results !-------------------------------------------------------------------------------------------------- pure subroutine kinetics_slip(Mp,T,instance,of, & dot_gamma_sl,ddot_gamma_dtau_slip,tau_slip) - use prec, only: & - tol_math_check, & - dNeq0 - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -1190,11 +1143,6 @@ end subroutine kinetics_slip !-------------------------------------------------------------------------------------------------- pure subroutine kinetics_twin(Mp,T,dot_gamma_sl,instance,of,& dot_gamma_twin,ddot_gamma_dtau_twin) - use prec, only: & - tol_math_check, & - dNeq0 - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -1261,11 +1209,6 @@ end subroutine kinetics_twin !-------------------------------------------------------------------------------------------------- pure subroutine kinetics_trans(Mp,T,dot_gamma_sl,instance,of,& dot_gamma_tr,ddot_gamma_dtau_trans) - use prec, only: & - tol_math_check, & - dNeq0 - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress diff --git a/src/plastic_isotropic.f90 b/src/plastic_isotropic.f90 index c572f0ded..46d0905dc 100644 --- a/src/plastic_isotropic.f90 +++ b/src/plastic_isotropic.f90 @@ -8,11 +8,19 @@ !! untextured polycrystal !-------------------------------------------------------------------------------------------------- module plastic_isotropic - use prec, only: & - pReal + use prec + use debug + use math + use IO + use material + use config +#if defined(PETSc) || defined(DAMASK_HDF5) + use results +#endif implicit none private + integer, dimension(:,:), allocatable, target, public :: & plastic_isotropic_sizePostResult !< size of each post result output character(len=64), dimension(:,:), allocatable, target, public :: & @@ -25,7 +33,7 @@ module plastic_isotropic dot_gamma_ID end enum - type, private :: tParameters + type :: tParameters real(pReal) :: & M, & !< Taylor factor xi_0, & !< initial critical stress @@ -49,7 +57,7 @@ module plastic_isotropic dilatation end type tParameters - type, private :: tIsotropicState + type :: tIsotropicState real(pReal), pointer, dimension(:) :: & xi, & gamma @@ -57,8 +65,8 @@ module plastic_isotropic !-------------------------------------------------------------------------------------------------- ! containers for parameters and state - type(tParameters), allocatable, dimension(:), private :: param - type(tIsotropicState), allocatable, dimension(:), private :: & + type(tParameters), allocatable, dimension(:) :: param + type(tIsotropicState), allocatable, dimension(:) :: & dotState, & state @@ -77,25 +85,7 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine plastic_isotropic_init - use prec, only: & - pStringLen - use debug, only: & -#ifdef DEBUG - debug_e, & - debug_i, & - debug_g, & - debug_levelExtensive, & -#endif - debug_level, & - debug_constitutive, & - debug_levelBasic - use IO, only: & - IO_error - use material - use config, only: & - config_phase - use lattice - + integer :: & Ninstance, & p, i, & @@ -235,16 +225,6 @@ end subroutine plastic_isotropic_init !> @brief calculates plastic velocity gradient and its tangent !-------------------------------------------------------------------------------------------------- subroutine plastic_isotropic_LpAndItsTangent(Lp,dLp_dMp,Mp,instance,of) -#ifdef DEBUG - use debug, only: & - debug_level, & - debug_constitutive,& - debug_levelExtensive, & - debug_levelSelective -#endif - use math, only: & - math_deviatoric33, & - math_mul33xx33 real(pReal), dimension(3,3), intent(out) :: & Lp !< plastic velocity gradient @@ -307,10 +287,6 @@ end subroutine plastic_isotropic_LpAndItsTangent ! ToDo: Rename Tstar to Mi? !-------------------------------------------------------------------------------------------------- subroutine plastic_isotropic_LiAndItsTangent(Li,dLi_dTstar,Tstar,instance,of) - use math, only: & - math_I3, & - math_spherical33, & - math_mul33xx33 real(pReal), dimension(3,3), intent(out) :: & Li !< inleastic velocity gradient @@ -362,11 +338,6 @@ subroutine plastic_isotropic_LiAndItsTangent(Li,dLi_dTstar,Tstar,instance,of) !> @brief calculates the rate of change of microstructure !-------------------------------------------------------------------------------------------------- subroutine plastic_isotropic_dotState(Mp,instance,of) - use prec, only: & - dEq0 - use math, only: & - math_mul33xx33, & - math_deviatoric33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -416,9 +387,6 @@ end subroutine plastic_isotropic_dotState !> @brief return array of constitutive results !-------------------------------------------------------------------------------------------------- function plastic_isotropic_postResults(Mp,instance,of) result(postResults) - use math, only: & - math_mul33xx33, & - math_deviatoric33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -468,7 +436,6 @@ end function plastic_isotropic_postResults !-------------------------------------------------------------------------------------------------- subroutine plastic_isotropic_results(instance,group) #if defined(PETSc) || defined(DAMASKHDF5) - use results integer, intent(in) :: instance character(len=*), intent(in) :: group diff --git a/src/plastic_kinematichardening.f90 b/src/plastic_kinematichardening.f90 index 861b98da3..ab68eb176 100644 --- a/src/plastic_kinematichardening.f90 +++ b/src/plastic_kinematichardening.f90 @@ -6,11 +6,20 @@ !! and a Voce-type kinematic hardening rule !-------------------------------------------------------------------------------------------------- module plastic_kinehardening - use prec, only: & - pReal + use prec + use debug + use math + use IO + use material + use config + use lattice +#if defined(PETSc) || defined(DAMASK_HDF5) + use results +#endif implicit none private + integer, dimension(:,:), allocatable, target, public :: & plastic_kinehardening_sizePostResult !< size of each post result output character(len=64), dimension(:,:), allocatable, target, public :: & @@ -29,7 +38,7 @@ module plastic_kinehardening resolvedstress_ID end enum - type, private :: tParameters + type :: tParameters real(pReal) :: & gdot0, & !< reference shear strain rate for slip n, & !< stress exponent for slip @@ -59,7 +68,7 @@ module plastic_kinehardening outputID !< ID of each post result output end type tParameters - type, private :: tKinehardeningState + type :: tKinehardeningState real(pReal), pointer, dimension(:,:) :: & !< vectors along NipcMyInstance crss, & !< critical resolved stress crss_back, & !< critical resolved back stress @@ -71,8 +80,8 @@ module plastic_kinehardening !-------------------------------------------------------------------------------------------------- ! containers for parameters and state - type(tParameters), allocatable, dimension(:), private :: param - type(tKinehardeningState), allocatable, dimension(:), private :: & + type(tParameters), allocatable, dimension(:) :: param + type(tKinehardeningState), allocatable, dimension(:) :: & dotState, & deltaState, & state @@ -84,8 +93,6 @@ module plastic_kinehardening plastic_kinehardening_deltaState, & plastic_kinehardening_postResults, & plastic_kinehardening_results - private :: & - kinetics contains @@ -95,27 +102,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine plastic_kinehardening_init - use prec, only: & - dEq0, & - pStringLen - use debug, only: & -#ifdef DEBUG - debug_e, & - debug_i, & - debug_g, & - debug_levelExtensive, & -#endif - debug_level, & - debug_constitutive,& - debug_levelBasic - use math, only: & - math_expand - use IO, only: & - IO_error - use material - use config, only: & - config_phase - use lattice integer :: & Ninstance, & @@ -417,16 +403,6 @@ end subroutine plastic_kinehardening_dotState !> @brief calculates (instantaneous) incremental change of microstructure !-------------------------------------------------------------------------------------------------- subroutine plastic_kinehardening_deltaState(Mp,instance,of) - use prec, only: & - dNeq, & - dEq0 -#ifdef DEBUG - use debug, only: & - debug_level, & - debug_constitutive,& - debug_levelExtensive, & - debug_levelSelective -#endif real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -475,8 +451,6 @@ end subroutine plastic_kinehardening_deltaState !> @brief return array of constitutive results !-------------------------------------------------------------------------------------------------- function plastic_kinehardening_postResults(Mp,instance,of) result(postResults) - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -535,8 +509,6 @@ end function plastic_kinehardening_postResults !-------------------------------------------------------------------------------------------------- subroutine plastic_kinehardening_results(instance,group) #if defined(PETSc) || defined(DAMASK_HDF5) - use results, only: & - results_writeDataset integer, intent(in) :: instance character(len=*) :: group @@ -585,10 +557,6 @@ end subroutine plastic_kinehardening_results !-------------------------------------------------------------------------------------------------- pure subroutine kinetics(Mp,instance,of, & gdot_pos,gdot_neg,dgdot_dtau_pos,dgdot_dtau_neg) - use prec, only: & - dNeq0 - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress diff --git a/src/plastic_none.f90 b/src/plastic_none.f90 index 4b14266f1..894cc9a40 100644 --- a/src/plastic_none.f90 +++ b/src/plastic_none.f90 @@ -5,6 +5,8 @@ !> @brief Dummy plasticity for purely elastic material !-------------------------------------------------------------------------------------------------- module plastic_none + use material + use debug implicit none private @@ -19,11 +21,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine plastic_none_init - use debug, only: & - debug_level, & - debug_constitutive, & - debug_levelBasic - use material integer :: & Ninstance, & diff --git a/src/plastic_phenopowerlaw.f90 b/src/plastic_phenopowerlaw.f90 index 196129f64..a31891573 100644 --- a/src/plastic_phenopowerlaw.f90 +++ b/src/plastic_phenopowerlaw.f90 @@ -5,11 +5,20 @@ !> @brief phenomenological crystal plasticity formulation using a powerlaw fitting !-------------------------------------------------------------------------------------------------- module plastic_phenopowerlaw - use prec, only: & - pReal + use prec + use debug + use math + use IO + use material + use config + use lattice +#if defined(PETSc) || defined(DAMASK_HDF5) + use results +#endif implicit none private + integer, dimension(:,:), allocatable, target, public :: & plastic_phenopowerlaw_sizePostResult !< size of each post result output character(len=64), dimension(:,:), allocatable, target, public :: & @@ -28,7 +37,7 @@ module plastic_phenopowerlaw resolvedstress_twin_ID end enum - type, private :: tParameters + type :: tParameters real(pReal) :: & gdot0_slip, & !< reference shear strain rate for slip gdot0_twin, & !< reference shear strain rate for twin @@ -73,7 +82,7 @@ module plastic_phenopowerlaw outputID !< ID of each post result output end type tParameters - type, private :: tPhenopowerlawState + type :: tPhenopowerlawState real(pReal), pointer, dimension(:,:) :: & xi_slip, & xi_twin, & @@ -83,8 +92,8 @@ module plastic_phenopowerlaw !-------------------------------------------------------------------------------------------------- ! containers for parameters and state - type(tParameters), allocatable, dimension(:), private :: param - type(tPhenopowerlawState), allocatable, dimension(:), private :: & + type(tParameters), allocatable, dimension(:) :: param + type(tPhenopowerlawState), allocatable, dimension(:) :: & dotState, & state @@ -94,9 +103,6 @@ module plastic_phenopowerlaw plastic_phenopowerlaw_dotState, & plastic_phenopowerlaw_postResults, & plastic_phenopowerlaw_results - private :: & - kinetics_slip, & - kinetics_twin contains @@ -106,20 +112,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine plastic_phenopowerlaw_init - use prec, only: & - pStringLen - use debug, only: & - debug_level, & - debug_constitutive,& - debug_levelBasic - use math, only: & - math_expand - use IO, only: & - IO_error - use material - use config, only: & - config_phase - use lattice integer :: & Ninstance, & @@ -484,8 +476,6 @@ end subroutine plastic_phenopowerlaw_dotState !> @brief return array of constitutive results !-------------------------------------------------------------------------------------------------- function plastic_phenopowerlaw_postResults(Mp,instance,of) result(postResults) - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -552,8 +542,6 @@ end function plastic_phenopowerlaw_postResults !-------------------------------------------------------------------------------------------------- subroutine plastic_phenopowerlaw_results(instance,group) #if defined(PETSc) || defined(DAMASK_HDF5) - use results, only: & - results_writeDataset integer, intent(in) :: instance character(len=*), intent(in) :: group @@ -598,10 +586,6 @@ end subroutine plastic_phenopowerlaw_results !-------------------------------------------------------------------------------------------------- pure subroutine kinetics_slip(Mp,instance,of, & gdot_slip_pos,gdot_slip_neg,dgdot_dtau_slip_pos,dgdot_dtau_slip_neg) - use prec, only: & - dNeq0 - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress @@ -674,10 +658,6 @@ end subroutine kinetics_slip !-------------------------------------------------------------------------------------------------- pure subroutine kinetics_twin(Mp,instance,of,& gdot_twin,dgdot_dtau_twin) - use prec, only: & - dNeq0 - use math, only: & - math_mul33xx33 real(pReal), dimension(3,3), intent(in) :: & Mp !< Mandel stress diff --git a/src/quaternions.f90 b/src/quaternions.f90 index fa9c13f38..47490daba 100644 --- a/src/quaternions.f90 +++ b/src/quaternions.f90 @@ -34,8 +34,7 @@ !> @details w is the real part, (x, y, z) are the imaginary parts. !--------------------------------------------------------------------------------------------------- module quaternions - use prec, only: & - pReal + use prec use future implicit none @@ -286,8 +285,6 @@ end function div_scal__ !> equality of two quaternions !--------------------------------------------------------------------------------------------------- logical elemental function eq__(self,other) - use prec, only: & - dEq class(quaternion), intent(in) :: self,other diff --git a/src/rotations.f90 b/src/rotations.f90 index 69529ed24..3a64f27b9 100644 --- a/src/rotations.f90 +++ b/src/rotations.f90 @@ -46,12 +46,15 @@ !--------------------------------------------------------------------------------------------------- module rotations - use prec, only: & - pReal + use prec + use IO + use math + use Lambert use quaternions implicit none private + type, public :: rotation type(quaternion), private :: q contains @@ -148,8 +151,6 @@ end subroutine !> @details: rotation is based on unit quaternion or rotation matrix (fallback) !--------------------------------------------------------------------------------------------------- function rotVector(self,v,active) - use prec, only: & - dEq real(pReal), dimension(3) :: rotVector class(rotation), intent(in) :: self @@ -260,10 +261,6 @@ end function qu2om !> @brief convert unit quaternion to Euler angles !--------------------------------------------------------------------------------------------------- pure function qu2eu(qu) result(eu) - use prec, only: & - dEq0 - use math, only: & - PI type(quaternion), intent(in) :: qu real(pReal), dimension(3) :: eu @@ -294,12 +291,6 @@ end function qu2eu !> @brief convert unit quaternion to axis angle pair !--------------------------------------------------------------------------------------------------- pure function qu2ax(qu) result(ax) - use prec, only: & - dEq0, & - dNeq0 - use math, only: & - PI, & - math_clip type(quaternion), intent(in) :: qu real(pReal), dimension(4) :: ax @@ -324,13 +315,6 @@ end function qu2ax !> @brief convert unit quaternion to Rodrigues vector !--------------------------------------------------------------------------------------------------- pure function qu2ro(qu) result(ro) - use, intrinsic :: IEEE_ARITHMETIC, only: & - IEEE_value, & - IEEE_positive_inf - use prec, only: & - dEq0 - use math, only: & - math_clip type(quaternion), intent(in) :: qu real(pReal), dimension(4) :: ro @@ -358,10 +342,6 @@ end function qu2ro !> @brief convert unit quaternion to homochoric !--------------------------------------------------------------------------------------------------- pure function qu2ho(qu) result(ho) - use prec, only: & - dEq0 - use math, only: & - math_clip type(quaternion), intent(in) :: qu real(pReal), dimension(3) :: ho @@ -415,8 +395,6 @@ end function om2qu !> @brief orientation matrix to Euler angles !--------------------------------------------------------------------------------------------------- pure function om2eu(om) result(eu) - use math, only: & - PI real(pReal), intent(in), dimension(3,3) :: om real(pReal), dimension(3) :: eu @@ -441,15 +419,6 @@ end function om2eu !> @brief convert orientation matrix to axis angle pair !--------------------------------------------------------------------------------------------------- function om2ax(om) result(ax) - use prec, only: & - dEq0, & - cEq, & - dNeq0 - use IO, only: & - IO_error - use math, only: & - math_clip, & - math_trace33 real(pReal), intent(in) :: om(3,3) real(pReal) :: ax(4) @@ -560,8 +529,6 @@ end function eu2qu !> @brief Euler angles to orientation matrix !--------------------------------------------------------------------------------------------------- pure function eu2om(eu) result(om) - use prec, only: & - dEq0 real(pReal), intent(in), dimension(3) :: eu real(pReal), dimension(3,3) :: om @@ -591,11 +558,6 @@ end function eu2om !> @brief convert euler to axis angle !--------------------------------------------------------------------------------------------------- pure function eu2ax(eu) result(ax) - use prec, only: & - dEq0, & - dEq - use math, only: & - PI real(pReal), intent(in), dimension(3) :: eu real(pReal), dimension(4) :: ax @@ -625,13 +587,6 @@ end function eu2ax !> @brief Euler angles to Rodrigues vector !--------------------------------------------------------------------------------------------------- pure function eu2ro(eu) result(ro) - use prec, only: & - dEq0 - use, intrinsic :: IEEE_ARITHMETIC, only: & - IEEE_value, & - IEEE_positive_inf - use math, only: & - PI real(pReal), intent(in), dimension(3) :: eu real(pReal), dimension(4) :: ro @@ -681,8 +636,6 @@ end function eu2cu !> @brief convert axis angle pair to quaternion !--------------------------------------------------------------------------------------------------- pure function ax2qu(ax) result(qu) - use prec, only: & - dEq0 real(pReal), intent(in), dimension(4) :: ax type(quaternion) :: qu @@ -755,13 +708,6 @@ end function ax2eu !> @brief convert axis angle pair to Rodrigues vector !--------------------------------------------------------------------------------------------------- pure function ax2ro(ax) result(ro) - use, intrinsic :: IEEE_ARITHMETIC, only: & - IEEE_value, & - IEEE_positive_inf - use prec, only: & - dEq0 - use math, only: & - PI real(pReal), intent(in), dimension(4) :: ax real(pReal), dimension(4) :: ro @@ -858,12 +804,6 @@ end function ro2eu !> @brief convert Rodrigues vector to axis angle pair !--------------------------------------------------------------------------------------------------- pure function ro2ax(ro) result(ax) - use, intrinsic :: IEEE_ARITHMETIC, only: & - IEEE_is_finite - use prec, only: & - dEq0 - use math, only: & - PI real(pReal), intent(in), dimension(4) :: ro real(pReal), dimension(4) :: ax @@ -890,12 +830,6 @@ end function ro2ax !> @brief convert Rodrigues vector to homochoric !--------------------------------------------------------------------------------------------------- pure function ro2ho(ro) result(ho) - use, intrinsic :: IEEE_ARITHMETIC, only: & - IEEE_is_finite - use prec, only: & - dEq0 - use math, only: & - PI real(pReal), intent(in), dimension(4) :: ro real(pReal), dimension(3) :: ho @@ -973,8 +907,6 @@ end function ho2eu !> @brief convert homochoric to axis angle pair !--------------------------------------------------------------------------------------------------- pure function ho2ax(ho) result(ax) - use prec, only: & - dEq0 real(pReal), intent(in), dimension(3) :: ho real(pReal), dimension(4) :: ax @@ -1029,13 +961,11 @@ end function ho2ro !> @brief convert homochoric to cubochoric !--------------------------------------------------------------------------------------------------- function ho2cu(ho) result(cu) - use Lambert, only: & - LambertBallToCube real(pReal), intent(in), dimension(3) :: ho real(pReal), dimension(3) :: cu - cu = LambertBallToCube(ho) + cu = Lambert_BallToCube(ho) end function ho2cu @@ -1115,13 +1045,11 @@ end function cu2ro !> @brief convert cubochoric to homochoric !--------------------------------------------------------------------------------------------------- function cu2ho(cu) result(ho) - use Lambert, only: & - LambertCubeToBall real(pReal), intent(in), dimension(3) :: cu real(pReal), dimension(3) :: ho - ho = LambertCubeToBall(cu) + ho = Lambert_CubeToBall(cu) end function cu2ho From 3df9a8d58c7741851517289ca158c0dcf9f3b245 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Thu, 16 May 2019 23:14:47 +0200 Subject: [PATCH 19/36] focus on the physics --- src/damage_local.f90 | 55 ++++----------------- src/damage_none.f90 | 16 ++----- src/damage_nonlocal.f90 | 71 ++++++---------------------- src/kinematics_cleavage_opening.f90 | 51 +++++++------------- src/kinematics_slipplane_opening.f90 | 42 +++++----------- src/kinematics_thermal_expansion.f90 | 50 +++++++------------- src/source_damage_anisoBrittle.f90 | 2 +- src/source_damage_isoBrittle.f90 | 2 +- 8 files changed, 76 insertions(+), 213 deletions(-) diff --git a/src/damage_local.f90 b/src/damage_local.f90 index 2db8cccc1..bd71ae95b 100644 --- a/src/damage_local.f90 +++ b/src/damage_local.f90 @@ -4,9 +4,13 @@ !-------------------------------------------------------------------------------------------------- module damage_local use prec + use material + use numerics + use config implicit none private + integer, dimension(:,:), allocatable, target, public :: & damage_local_sizePostResult !< size of each post result output @@ -20,23 +24,22 @@ module damage_local enumerator :: undefined_ID, & damage_ID end enum - integer(kind(undefined_ID)), dimension(:,:), allocatable, private :: & + integer(kind(undefined_ID)), dimension(:,:), allocatable :: & damage_local_outputID !< ID of each post result output - type, private :: tParameters + type :: tParameters integer(kind(undefined_ID)), dimension(:), allocatable :: & outputID end type tParameters - type(tparameters), dimension(:), allocatable, private :: & + type(tparameters), dimension(:), allocatable :: & param public :: & damage_local_init, & damage_local_updateState, & damage_local_postResults - private :: & - damage_local_getSourceAndItsTangent + contains @@ -45,21 +48,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine damage_local_init - use material, only: & - damage_type, & - damage_typeInstance, & - homogenization_Noutput, & - DAMAGE_local_label, & - DAMAGE_local_ID, & - material_homogenizationAt, & - mappingHomogenization, & - damageState, & - damageMapping, & - damage, & - damage_initialPhi - use config, only: & - config_homogenization - integer :: maxNinstance,homog,instance,i integer :: sizeState @@ -72,7 +60,7 @@ subroutine damage_local_init write(6,'(/,a)') ' <<<+- damage_'//DAMAGE_local_label//' init -+>>>' - maxNinstance = int(count(damage_type == DAMAGE_local_ID),pInt) + maxNinstance = count(damage_type == DAMAGE_local_ID) if (maxNinstance == 0) return allocate(damage_local_sizePostResult (maxval(homogenization_Noutput),maxNinstance),source=0) @@ -135,14 +123,6 @@ end subroutine damage_local_init !> @brief calculates local change in damage field !-------------------------------------------------------------------------------------------------- function damage_local_updateState(subdt, ip, el) - use numerics, only: & - residualStiffness, & - err_damage_tolAbs, & - err_damage_tolRel - use material, only: & - material_homogenizationAt, & - mappingHomogenization, & - damageState integer, intent(in) :: & ip, & !< integration point number @@ -177,17 +157,6 @@ end function damage_local_updateState !> @brief calculates homogenized local damage driving forces !-------------------------------------------------------------------------------------------------- subroutine damage_local_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el) - use material, only: & - homogenization_Ngrains, & - material_homogenizationAt, & - phaseAt, & - phasememberAt, & - phase_source, & - phase_Nsources, & - SOURCE_damage_isoBrittle_ID, & - SOURCE_damage_isoDuctile_ID, & - SOURCE_damage_anisoBrittle_ID, & - SOURCE_damage_anisoDuctile_ID use source_damage_isoBrittle, only: & source_damage_isobrittle_getRateAndItsTangent use source_damage_isoDuctile, only: & @@ -244,15 +213,11 @@ subroutine damage_local_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el end subroutine damage_local_getSourceAndItsTangent + !-------------------------------------------------------------------------------------------------- !> @brief return array of damage results !-------------------------------------------------------------------------------------------------- function damage_local_postResults(ip,el) - use material, only: & - material_homogenizationAt, & - damage_typeInstance, & - damageMapping, & - damage integer, intent(in) :: & ip, & !< integration point diff --git a/src/damage_none.f90 b/src/damage_none.f90 index aa2995ef5..5ffdba030 100644 --- a/src/damage_none.f90 +++ b/src/damage_none.f90 @@ -3,6 +3,8 @@ !> @brief material subroutine for constant damage field !-------------------------------------------------------------------------------------------------- module damage_none + use config + use material implicit none private @@ -15,18 +17,8 @@ contains !-------------------------------------------------------------------------------------------------- !> @brief allocates all neccessary fields, reads information from material configuration file !-------------------------------------------------------------------------------------------------- -subroutine damage_none_init() - use config, only: & - config_homogenization - use material, only: & - damage_initialPhi, & - damage, & - damage_type, & - material_homogenizationAt, & - damageState, & - DAMAGE_NONE_LABEL, & - DAMAGE_NONE_ID - +subroutine damage_none_init + integer :: & homog, & NofMyHomog diff --git a/src/damage_nonlocal.f90 b/src/damage_nonlocal.f90 index 9398b328a..81117e0eb 100644 --- a/src/damage_nonlocal.f90 +++ b/src/damage_nonlocal.f90 @@ -5,9 +5,16 @@ !-------------------------------------------------------------------------------------------------- module damage_nonlocal use prec + use material + use numerics + use config + use crystallite + use lattice + use mesh implicit none private + integer, dimension(:,:), allocatable, target, public :: & damage_nonlocal_sizePostResult !< size of each post result output @@ -22,12 +29,12 @@ module damage_nonlocal damage_ID end enum - type, private :: tParameters + type :: tParameters integer(kind(undefined_ID)), dimension(:), allocatable :: & outputID end type tParameters - type(tparameters), dimension(:), allocatable, private :: & + type(tparameters), dimension(:), allocatable :: & param public :: & @@ -45,21 +52,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine damage_nonlocal_init - use material, only: & - damage_type, & - damage_typeInstance, & - homogenization_Noutput, & - DAMAGE_nonlocal_label, & - DAMAGE_nonlocal_ID, & - material_homogenizationAt, & - mappingHomogenization, & - damageState, & - damageMapping, & - damage, & - damage_initialPhi - use config, only: & - config_homogenization - integer :: maxNinstance,homog,instance,o,i integer :: sizeState @@ -72,7 +64,7 @@ subroutine damage_nonlocal_init write(6,'(/,a)') ' <<<+- damage_'//DAMAGE_nonlocal_label//' init -+>>>' - maxNinstance = int(count(damage_type == DAMAGE_nonlocal_ID)) + maxNinstance = count(damage_type == DAMAGE_nonlocal_ID) if (maxNinstance == 0) return allocate(damage_nonlocal_sizePostResult (maxval(homogenization_Noutput),maxNinstance),source=0) @@ -131,17 +123,6 @@ end subroutine damage_nonlocal_init !> @brief calculates homogenized damage driving forces !-------------------------------------------------------------------------------------------------- subroutine damage_nonlocal_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el) - use material, only: & - homogenization_Ngrains, & - material_homogenizationAt, & - phaseAt, & - phasememberAt, & - phase_source, & - phase_Nsources, & - SOURCE_damage_isoBrittle_ID, & - SOURCE_damage_isoDuctile_ID, & - SOURCE_damage_anisoBrittle_ID, & - SOURCE_damage_anisoDuctile_ID use source_damage_isoBrittle, only: & source_damage_isobrittle_getRateAndItsTangent use source_damage_isoDuctile, only: & @@ -198,20 +179,11 @@ subroutine damage_nonlocal_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, end subroutine damage_nonlocal_getSourceAndItsTangent + !-------------------------------------------------------------------------------------------------- !> @brief returns homogenized non local damage diffusion tensor in reference configuration !-------------------------------------------------------------------------------------------------- function damage_nonlocal_getDiffusion33(ip,el) - use numerics, only: & - charLength - use lattice, only: & - lattice_DamageDiffusion33 - use material, only: & - homogenization_Ngrains, & - material_phase, & - material_homogenizationAt - use crystallite, only: & - crystallite_push33ToRef integer, intent(in) :: & ip, & !< integration point number @@ -234,17 +206,11 @@ function damage_nonlocal_getDiffusion33(ip,el) end function damage_nonlocal_getDiffusion33 + !-------------------------------------------------------------------------------------------------- !> @brief Returns homogenized nonlocal damage mobility !-------------------------------------------------------------------------------------------------- real(pReal) function damage_nonlocal_getMobility(ip,el) - use mesh, only: & - mesh_element - use lattice, only: & - lattice_damageMobility - use material, only: & - material_phase, & - homogenization_Ngrains integer, intent(in) :: & ip, & !< integration point number @@ -263,14 +229,11 @@ real(pReal) function damage_nonlocal_getMobility(ip,el) end function damage_nonlocal_getMobility + !-------------------------------------------------------------------------------------------------- !> @brief updated nonlocal damage field with solution from damage phase field PDE !-------------------------------------------------------------------------------------------------- subroutine damage_nonlocal_putNonLocalDamage(phi,ip,el) - use material, only: & - material_homogenizationAt, & - damageMapping, & - damage integer, intent(in) :: & ip, & !< integration point number @@ -286,16 +249,12 @@ subroutine damage_nonlocal_putNonLocalDamage(phi,ip,el) damage(homog)%p(offset) = phi end subroutine damage_nonlocal_putNonLocalDamage - + + !-------------------------------------------------------------------------------------------------- !> @brief return array of damage results !-------------------------------------------------------------------------------------------------- function damage_nonlocal_postResults(ip,el) - use material, only: & - material_homogenizationAt, & - damage_typeInstance, & - damageMapping, & - damage integer, intent(in) :: & ip, & !< integration point diff --git a/src/kinematics_cleavage_opening.f90 b/src/kinematics_cleavage_opening.f90 index a79dc4042..60d9cb500 100644 --- a/src/kinematics_cleavage_opening.f90 +++ b/src/kinematics_cleavage_opening.f90 @@ -5,13 +5,20 @@ !> @details to be done !-------------------------------------------------------------------------------------------------- module kinematics_cleavage_opening - use prec + use prec + use IO + use config + use debug + use math + use lattice + use material implicit none private - integer, dimension(:), allocatable, private :: kinematics_cleavage_opening_instance - type, private :: tParameters !< container type for internal constitutive parameters + integer, dimension(:), allocatable :: kinematics_cleavage_opening_instance + + type :: tParameters !< container type for internal constitutive parameters integer :: & totalNcleavage integer, dimension(:), allocatable :: & @@ -25,17 +32,17 @@ module kinematics_cleavage_opening end type ! Begin Deprecated - integer, dimension(:), allocatable, private :: & + integer, dimension(:), allocatable :: & kinematics_cleavage_opening_totalNcleavage !< total number of cleavage systems - integer, dimension(:,:), allocatable, private :: & + integer, dimension(:,:), allocatable :: & kinematics_cleavage_opening_Ncleavage !< number of cleavage systems per family - real(pReal), dimension(:), allocatable, private :: & + real(pReal), dimension(:), allocatable :: & kinematics_cleavage_opening_sdot_0, & kinematics_cleavage_opening_N - real(pReal), dimension(:,:), allocatable, private :: & + real(pReal), dimension(:,:), allocatable :: & kinematics_cleavage_opening_critDisp, & kinematics_cleavage_opening_critLoad ! End Deprecated @@ -51,22 +58,7 @@ contains !> @brief module initialization !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- -subroutine kinematics_cleavage_opening_init() - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use config, only: & - config_phase - use IO, only: & - IO_error - use material, only: & - phase_kinematics, & - KINEMATICS_cleavage_opening_label, & - KINEMATICS_cleavage_opening_ID - use lattice, only: & - lattice_maxNcleavageFamily, & - lattice_NcleavageSystem +subroutine kinematics_cleavage_opening_init integer, allocatable, dimension(:) :: tempInt real(pReal), allocatable, dimension(:) :: tempFloat @@ -75,7 +67,7 @@ subroutine kinematics_cleavage_opening_init() write(6,'(/,a)') ' <<<+- kinematics_'//KINEMATICS_cleavage_opening_LABEL//' init -+>>>' - maxNinstance = int(count(phase_kinematics == KINEMATICS_cleavage_opening_ID)) + maxNinstance = count(phase_kinematics == KINEMATICS_cleavage_opening_ID) if (maxNinstance == 0) return if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & @@ -127,17 +119,6 @@ end subroutine kinematics_cleavage_opening_init !> @brief contains the constitutive equation for calculating the velocity gradient !-------------------------------------------------------------------------------------------------- subroutine kinematics_cleavage_opening_LiAndItsTangent(Ld, dLd_dTstar, S, ipc, ip, el) - use math, only: & - math_mul33xx33 - use material, only: & - material_phase, & - material_homogenizationAt, & - damage, & - damageMapping - use lattice, only: & - lattice_Scleavage, & - lattice_maxNcleavageFamily, & - lattice_NcleavageSystem integer, intent(in) :: & ipc, & !< grain number diff --git a/src/kinematics_slipplane_opening.f90 b/src/kinematics_slipplane_opening.f90 index f29c0e252..3e37e4c0d 100644 --- a/src/kinematics_slipplane_opening.f90 +++ b/src/kinematics_slipplane_opening.f90 @@ -6,12 +6,19 @@ !-------------------------------------------------------------------------------------------------- module kinematics_slipplane_opening use prec + use config + use IO + use debug + use math + use lattice + use material implicit none private - integer, dimension(:), allocatable, private :: kinematics_slipplane_opening_instance + + integer, dimension(:), allocatable :: kinematics_slipplane_opening_instance - type, private :: tParameters !< container type for internal constitutive parameters + type :: tParameters !< container type for internal constitutive parameters integer :: & totalNslip integer, dimension(:), allocatable :: & @@ -19,7 +26,7 @@ module kinematics_slipplane_opening real(pReal) :: & sdot0, & n - real(pReal), dimension(:), allocatable :: & + real(pReal), dimension(:), allocatable :: & critLoad real(pReal), dimension(:,:), allocatable :: & slip_direction, & @@ -27,7 +34,8 @@ module kinematics_slipplane_opening slip_transverse end type tParameters - type(tParameters), dimension(:), allocatable, private :: param !< containers of constitutive parameters (len Ninstance) + type(tParameters), dimension(:), allocatable :: param !< containers of constitutive parameters (len Ninstance) + public :: & kinematics_slipplane_opening_init, & kinematics_slipplane_opening_LiAndItsTangent @@ -39,23 +47,7 @@ contains !> @brief module initialization !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- -subroutine kinematics_slipplane_opening_init() - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use config, only: & - config_phase - use IO, only: & - IO_error - use math, only: & - math_expand - use material, only: & - phase_kinematics, & - KINEMATICS_slipplane_opening_label, & - KINEMATICS_slipplane_opening_ID - use lattice - +subroutine kinematics_slipplane_opening_init integer :: maxNinstance,p,instance @@ -111,14 +103,6 @@ end subroutine kinematics_slipplane_opening_init !> @brief contains the constitutive equation for calculating the velocity gradient !-------------------------------------------------------------------------------------------------- subroutine kinematics_slipplane_opening_LiAndItsTangent(Ld, dLd_dTstar, S, ipc, ip, el) - use math, only: & - math_mul33xx33, & - math_outer - use material, only: & - material_phase, & - material_homogenizationAt, & - damage, & - damageMapping integer, intent(in) :: & ipc, & !< grain number diff --git a/src/kinematics_thermal_expansion.f90 b/src/kinematics_thermal_expansion.f90 index 86932ea69..b4f23dfa7 100644 --- a/src/kinematics_thermal_expansion.f90 +++ b/src/kinematics_thermal_expansion.f90 @@ -5,11 +5,17 @@ !-------------------------------------------------------------------------------------------------- module kinematics_thermal_expansion use prec - + use IO + use config + use debug + use math + use lattice + use material + implicit none private - type, private :: tParameters + type :: tParameters real(pReal), allocatable, dimension(:,:,:) :: & expansion end type tParameters @@ -28,19 +34,9 @@ contains !> @brief module initialization !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- -subroutine kinematics_thermal_expansion_init() - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use material, only: & - phase_kinematics, & - KINEMATICS_thermal_expansion_label, & - KINEMATICS_thermal_expansion_ID - use config, only: & - config_phase +subroutine kinematics_thermal_expansion_init - integer(pInt) :: & + integer :: & Ninstance, & p, i real(pReal), dimension(:), allocatable :: & @@ -48,14 +44,14 @@ subroutine kinematics_thermal_expansion_init() write(6,'(/,a)') ' <<<+- kinematics_'//KINEMATICS_thermal_expansion_LABEL//' init -+>>>' - Ninstance = int(count(phase_kinematics == KINEMATICS_thermal_expansion_ID),pInt) + Ninstance = count(phase_kinematics == KINEMATICS_thermal_expansion_ID) - if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0_pInt) & + if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & write(6,'(a16,1x,i5,/)') '# instances:',Ninstance allocate(param(Ninstance)) - do p = 1_pInt, size(phase_kinematics) + do p = 1, size(phase_kinematics) if (all(phase_kinematics(:,p) /= KINEMATICS_thermal_expansion_ID)) cycle ! ToDo: Here we need to decide how to extend the concept of instances to @@ -78,13 +74,8 @@ end subroutine kinematics_thermal_expansion_init !> @brief report initial thermal strain based on current temperature deviation from reference !-------------------------------------------------------------------------------------------------- pure function kinematics_thermal_expansion_initialStrain(homog,phase,offset) - use material, only: & - temperature - use lattice, only: & - lattice_thermalExpansion33, & - lattice_referenceTemperature - integer(pInt), intent(in) :: & + integer, intent(in) :: & phase, & homog, offset real(pReal), dimension(3,3) :: & @@ -106,17 +97,8 @@ end function kinematics_thermal_expansion_initialStrain !> @brief contains the constitutive equation for calculating the velocity gradient !-------------------------------------------------------------------------------------------------- subroutine kinematics_thermal_expansion_LiAndItsTangent(Li, dLi_dTstar, ipc, ip, el) - use material, only: & - material_phase, & - material_homogenizationAt, & - temperature, & - temperatureRate, & - thermalMapping - use lattice, only: & - lattice_thermalExpansion33, & - lattice_referenceTemperature - integer(pInt), intent(in) :: & + integer, intent(in) :: & ipc, & !< grain number ip, & !< integration point number el !< element number @@ -124,7 +106,7 @@ subroutine kinematics_thermal_expansion_LiAndItsTangent(Li, dLi_dTstar, ipc, ip, Li !< thermal velocity gradient real(pReal), intent(out), dimension(3,3,3,3) :: & dLi_dTstar !< derivative of Li with respect to Tstar (4th-order tensor defined to be zero) - integer(pInt) :: & + integer :: & phase, & homog, offset real(pReal) :: & diff --git a/src/source_damage_anisoBrittle.f90 b/src/source_damage_anisoBrittle.f90 index 494bbc6f0..2f5fc119f 100644 --- a/src/source_damage_anisoBrittle.f90 +++ b/src/source_damage_anisoBrittle.f90 @@ -101,7 +101,7 @@ subroutine source_damage_anisoBrittle_init write(6,'(/,a)') ' <<<+- source_'//SOURCE_DAMAGE_ANISOBRITTLE_LABEL//' init -+>>>' - Ninstance = int(count(phase_source == SOURCE_damage_anisoBrittle_ID)) + Ninstance = count(phase_source == SOURCE_damage_anisoBrittle_ID) if (Ninstance == 0) return if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & diff --git a/src/source_damage_isoBrittle.f90 b/src/source_damage_isoBrittle.f90 index 90aa5089f..3e0e94f82 100644 --- a/src/source_damage_isoBrittle.f90 +++ b/src/source_damage_isoBrittle.f90 @@ -84,7 +84,7 @@ subroutine source_damage_isoBrittle_init write(6,'(/,a)') ' <<<+- source_'//SOURCE_DAMAGE_ISOBRITTLE_LABEL//' init -+>>>' - Ninstance = int(count(phase_source == SOURCE_damage_isoBrittle_ID)) + Ninstance = count(phase_source == SOURCE_damage_isoBrittle_ID) if (Ninstance == 0) return if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & From 7b620e3ce92f5c2d9ba322069e5205eb4cc11904 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Fri, 17 May 2019 06:49:25 +0200 Subject: [PATCH 20/36] [skip ci] consistent with rest of the module --- src/math.f90 | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/math.f90 b/src/math.f90 index 1740ebdb7..f2c0303da 100644 --- a/src/math.f90 +++ b/src/math.f90 @@ -274,6 +274,7 @@ pure function math_identity2nd(dimen) end function math_identity2nd + !-------------------------------------------------------------------------------------------------- !> @brief symmetric fourth rank identity tensor of specified dimension ! from http://en.wikipedia.org/wiki/Tensor_derivative_(continuum_mechanics)#Derivative_of_a_second-order_tensor_with_respect_to_itself @@ -626,6 +627,7 @@ pure function math_skew33(m) end function math_skew33 + !-------------------------------------------------------------------------------------------------- !> @brief hydrostatic part of a 33 matrix !-------------------------------------------------------------------------------------------------- From 68d2d1dd5e23f765dae80269634ed343256378f4 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Fri, 17 May 2019 05:12:01 +0000 Subject: [PATCH 21/36] less complaints from the Intel compiler --- cmake/Compiler-Intel.cmake | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cmake/Compiler-Intel.cmake b/cmake/Compiler-Intel.cmake index 998f60326..60ed46cbc 100644 --- a/cmake/Compiler-Intel.cmake +++ b/cmake/Compiler-Intel.cmake @@ -32,6 +32,8 @@ # disables warnings ... set (COMPILE_FLAGS "${COMPILE_FLAGS} 5268") # ... the text exceeds right hand column allowed on the line (we have only comments there) + set (COMPILE_FLAGS "${COMPILE_FLAGS},7624") + # ... about deprecated forall (has nice syntax and most likely a performance advantage) set (COMPILE_FLAGS "${COMPILE_FLAGS} -warn") # enables warnings ... From 7ac0013271e31a3267ec60417e1beef4c2f30a91 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Fri, 17 May 2019 05:24:01 +0000 Subject: [PATCH 22/36] more consistent private/public declarations --- src/Lambert.f90 | 1 + src/math.f90 | 27 ++++++++++++++++++--------- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/src/Lambert.f90 b/src/Lambert.f90 index 601cf9984..a528ea8b0 100644 --- a/src/Lambert.f90 +++ b/src/Lambert.f90 @@ -38,6 +38,7 @@ !> Modeling and Simulations in Materials Science and Engineering 22, 075013 (2014). !-------------------------------------------------------------------------- module Lambert + use prec use math implicit none diff --git a/src/math.f90 b/src/math.f90 index f2c0303da..4a32be274 100644 --- a/src/math.f90 +++ b/src/math.f90 @@ -10,12 +10,20 @@ module math use future implicit none - real(pReal), parameter, public :: PI = acos(-1.0_pReal) !< ratio of a circle's circumference to its diameter - real(pReal), parameter, public :: INDEG = 180.0_pReal/PI !< conversion from radian into degree - real(pReal), parameter, public :: INRAD = PI/180.0_pReal !< conversion from degree into radian - complex(pReal), parameter, public :: TWOPIIMG = cmplx(0.0_pReal,2.0_pReal*PI) !< Re(0.0), Im(2xPi) + public +#if __INTEL_COMPILER >= 1900 + ! do not make use associated entities available to other modules + private :: & + prec, & + future +#endif - real(pReal), dimension(3,3), parameter, public :: & + real(pReal), parameter :: PI = acos(-1.0_pReal) !< ratio of a circle's circumference to its diameter + real(pReal), parameter :: INDEG = 180.0_pReal/PI !< conversion from radian into degree + real(pReal), parameter :: INRAD = PI/180.0_pReal !< conversion from degree into radian + complex(pReal), parameter :: TWOPIIMG = cmplx(0.0_pReal,2.0_pReal*PI) !< Re(0.0), Im(2xPi) + + real(pReal), dimension(3,3), parameter :: & MATH_I3 = reshape([& 1.0_pReal,0.0_pReal,0.0_pReal, & 0.0_pReal,1.0_pReal,0.0_pReal, & @@ -75,7 +83,7 @@ module math !--------------------------------------------------------------------------------------------------- private :: & - math_check + unitTest contains @@ -116,14 +124,15 @@ subroutine math_init write(6,'(a,4(/,26x,f17.14),/)') ' start of random sequence: ', randTest call random_seed(put = randInit) - call math_check + call unitTest end subroutine math_init + !-------------------------------------------------------------------------------------------------- !> @brief check correctness of (some) math functions !-------------------------------------------------------------------------------------------------- -subroutine math_check +subroutine unitTest use IO, only: IO_error character(len=64) :: error_msg @@ -145,7 +154,7 @@ subroutine math_check call IO_error(401,ext_msg=error_msg) endif -end subroutine math_check +end subroutine unitTest !-------------------------------------------------------------------------------------------------- From 0fe43c50abcee7a76982a07e7815b22192c23a51 Mon Sep 17 00:00:00 2001 From: Test User Date: Fri, 17 May 2019 09:06:28 +0200 Subject: [PATCH 23/36] [skip ci] updated version information after successful test of v2.0.3-304-g7b14263c --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 69faed072..2d8c83361 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-301-g789420c9 +v2.0.3-304-g7b14263c From e6cec6ecbe32d601f03579eabee202531f87d4c0 Mon Sep 17 00:00:00 2001 From: Philip Eisenlohr Date: Thu, 23 May 2019 12:03:54 -0400 Subject: [PATCH 24/36] added option to reverse inside/outside of primitive body --- processing/pre/geom_addPrimitive.py | 43 +++++++++++++++++------------ 1 file changed, 26 insertions(+), 17 deletions(-) diff --git a/processing/pre/geom_addPrimitive.py b/processing/pre/geom_addPrimitive.py index 7fcfdbc5c..0dfd06732 100755 --- a/processing/pre/geom_addPrimitive.py +++ b/processing/pre/geom_addPrimitive.py @@ -43,7 +43,7 @@ parser.add_option('-e', '--exponent', dest='exponent', 1 gives a sphere (|x|^(2^1) + |y|^(2^1) + |z|^(2^1) < 1), \ large values produce boxes, negative turns concave.') parser.add_option('-f', '--fill', dest='fill', - type='int', metavar = 'int', + type='float', metavar = 'float', help='grain index to fill primitive. "0" selects maximum microstructure index + 1 [%default]') parser.add_option('-q', '--quaternion', dest='quaternion', type='float', nargs = 4, metavar=' '.join(['float']*4), @@ -60,15 +60,24 @@ parser.add_option( '--nonperiodic', dest='periodic', parser.add_option( '--realspace', dest='realspace', action='store_true', help = '-c and -d span [origin,origin+size] instead of [0,grid] coordinates') +parser.add_option( '--invert', dest='inside', + action='store_false', + help = 'invert the volume filled by the primitive (inside/outside)') +parser.add_option('--float', dest = 'float', + action = 'store_true', + help = 'use float input') parser.set_defaults(center = (.0,.0,.0), - fill = 0, + fill = 0.0, degrees = False, exponent = (20,20,20), # box shape by default periodic = True, realspace = False, + inside = True, + float = False, ) (options, filenames) = parser.parse_args() + if options.dimension is None: parser.error('no dimension specified.') if options.angleaxis is not None: @@ -78,6 +87,8 @@ elif options.quaternion is not None: else: rotation = damask.Rotation() +datatype = 'f' if options.float else 'i' + options.center = np.array(options.center) options.dimension = np.array(options.dimension) # undo logarithmic sense of exponent and generate ellipsoids for negative dimensions (backward compatibility) @@ -97,13 +108,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -115,7 +120,7 @@ for name in filenames: #--- read data ------------------------------------------------------------------------------------ - microstructure = table.microstructure_read(info['grid']) # read microstructure + microstructure = table.microstructure_read(info['grid'],datatype) # read microstructure # --- do work ------------------------------------------------------------------------------------ @@ -123,7 +128,7 @@ for name in filenames: 'microstructures': 0, } - options.fill = microstructure.max()+1 if options.fill == 0 else options.fill + options.fill = np.nanmax(microstructure)+1 if options.fill == 0 else options.fill microstructure = microstructure.reshape(info['grid'],order='F') @@ -193,19 +198,23 @@ for name in filenames: grid[1] * j : grid[1] * (j+1), grid[2] * k : grid[2] * (k+1)])**options.exponent[2] <= 1.0) - microstructure = np.where(inside, options.fill, microstructure) + microstructure = np.where(inside, + options.fill if options.inside else microstructure, + microstructure if options.inside else options.fill) else: # nonperiodic, much lighter on resources microstructure = np.where(np.abs(X)**options.exponent[0] + np.abs(Y)**options.exponent[1] + - np.abs(Z)**options.exponent[2] <= 1.0, options.fill, microstructure) + np.abs(Z)**options.exponent[2] <= 1.0, + options.fill if options.inside else microstructure, + microstructure if options.inside else options.fill) np.seterr(**old_settings) # Reset warnings to old state - newInfo['microstructures'] = microstructure.max() + newInfo['microstructures'] = len(np.unique(microstructure)) # --- report --------------------------------------------------------------------------------------- if (newInfo['microstructures'] != info['microstructures']): - damask.util.croak('--> microstructures: %i'%newInfo['microstructures']) + damask.util.croak('--> microstructures: {}'.format(newInfo['microstructures'])) #--- write header --------------------------------------------------------------------------------- @@ -225,9 +234,9 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + format = '%g' if options.float else '%{}i'.format(int(math.floor(math.log10(np.nanmax(microstructure))+1))) table.data = microstructure.reshape((info['grid'][0],info['grid'][1]*info['grid'][2]),order='F').transpose() - table.data_writeArray('%%%ii'%(formatwidth),delimiter = ' ') + table.data_writeArray(format,delimiter = ' ') #--- output finalization -------------------------------------------------------------------------- From eb13fbc0cee296b9448a8f2eca5ec8c87bda3c9f Mon Sep 17 00:00:00 2001 From: Philip Eisenlohr Date: Thu, 23 May 2019 13:03:24 -0400 Subject: [PATCH 25/36] streamlined geom-info reporting; added --float option to some scripts; hardened against NaN; "microstructures" now reports uniques not max --- processing/pre/geom_canvas.py | 14 ++++----- processing/pre/geom_clean.py | 14 +++------ processing/pre/geom_fromMinimalSurface.py | 7 +---- processing/pre/geom_fromTable.py | 9 ++---- processing/pre/geom_grainGrowth.py | 13 ++------- processing/pre/geom_mirror.py | 26 ++++++++++------- processing/pre/geom_pack.py | 10 ++----- processing/pre/geom_renumber.py | 10 ++----- processing/pre/geom_rescale.py | 26 +++++++++-------- processing/pre/geom_rotate.py | 35 ++++++++++++----------- processing/pre/geom_toTable.py | 14 +++------ processing/pre/geom_translate.py | 22 ++++++-------- processing/pre/geom_unpack.py | 8 +----- processing/pre/geom_vicinityOffset.py | 14 +++------ 14 files changed, 85 insertions(+), 137 deletions(-) diff --git a/processing/pre/geom_canvas.py b/processing/pre/geom_canvas.py index d7fd1614a..01682deb8 100755 --- a/processing/pre/geom_canvas.py +++ b/processing/pre/geom_canvas.py @@ -35,7 +35,7 @@ parser.add_option('-f', type = 'float', metavar = 'float', help = '(background) canvas grain index. "0" selects maximum microstructure index + 1 [%default]') parser.add_option('--float', - dest = 'real', + dest = 'float', action = 'store_true', help = 'use float input') parser.add_option('--blank', @@ -45,13 +45,13 @@ parser.add_option('--blank', parser.set_defaults(grid = ['0','0','0'], offset = (0,0,0), - fill = 0, - real = False, + fill = 0.0, + float = False, ) (options, filenames) = parser.parse_args() -datatype = 'f' if options.real else 'i' +datatype = 'f' if options.float else 'i' options.grid = ['1','1','1'] if options.blank and options.grid == ['0','0','0'] else options.grid options.fill = 1 if options.blank and options.fill == 0 else options.fill @@ -107,7 +107,7 @@ for name in filenames: newInfo['grid'] = np.where(newInfo['grid'] > 0, newInfo['grid'],info['grid']) microstructure_cropped = np.zeros(newInfo['grid'],datatype) - microstructure_cropped.fill(options.fill if options.real or options.fill > 0 else microstructure.max()+1) + microstructure_cropped.fill(options.fill if options.float or options.fill > 0 else np.nanmax(microstructure)+1) if not options.blank: xindex = np.arange(max(options.offset[0],0),min(options.offset[0]+newInfo['grid'][0],info['grid'][0])) @@ -130,7 +130,7 @@ for name in filenames: newInfo['size'] = info['size']/info['grid']*newInfo['grid'] if np.all(info['grid'] > 0) else newInfo['grid'] newInfo['origin'] = info['origin']+(info['size']/info['grid'] if np.all(info['grid'] > 0) \ else newInfo['size']/newInfo['grid'])*options.offset - newInfo['microstructures'] = microstructure_cropped.max() + newInfo['microstructures'] = len(np.unique(microstructure_cropped)) # --- report --------------------------------------------------------------------------------------- @@ -172,7 +172,7 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - format = '%g' if options.real else '%{}i'.format(int(math.floor(math.log10(microstructure_cropped.max())+1))) + format = '%g' if options.float else '%{}i'.format(int(math.floor(math.log10(np.nanmax(microstructure_cropped))+1))) table.data = microstructure_cropped.reshape((newInfo['grid'][0],newInfo['grid'][1]*newInfo['grid'][2]),order='F').transpose() table.data_writeArray(format,delimiter=' ') diff --git a/processing/pre/geom_clean.py b/processing/pre/geom_clean.py index 907431146..1d0769ab3 100755 --- a/processing/pre/geom_clean.py +++ b/processing/pre/geom_clean.py @@ -50,13 +50,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: {}'.format(' x '.join(map(str,info['grid']))), - 'size x y z: {}'.format(' x '.join(map(str,info['size']))), - 'origin x y z: {}'.format(' : '.join(map(str,info['origin']))), - 'homogenization: {}'.format(info['homogenization']), - 'microstructures: {}'.format(info['microstructures']), - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -73,7 +67,7 @@ for name in filenames: # --- do work ------------------------------------------------------------------------------------ microstructure = ndimage.filters.generic_filter(microstructure,mostFrequent,size=(options.stencil,)*3).astype('int_') - newInfo = {'microstructures': microstructure.max()} + newInfo = {'microstructures': len(np.unique(microstructure))} # --- report --------------------------------------------------------------------------------------- if ( newInfo['microstructures'] != info['microstructures']): @@ -91,9 +85,9 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + formatwidth = int(math.floor(math.log10(np.nanmax(microstructure))+1)) table.data = microstructure.reshape((info['grid'][0],np.prod(info['grid'][1:])),order='F').transpose() - table.data_writeArray('%%%ii'%(formatwidth),delimiter = ' ') + table.data_writeArray('%{}i'.format(formatwidth),delimiter = ' ') # --- output finalization -------------------------------------------------------------------------- diff --git a/processing/pre/geom_fromMinimalSurface.py b/processing/pre/geom_fromMinimalSurface.py index 002b4800b..e0023e7ec 100755 --- a/processing/pre/geom_fromMinimalSurface.py +++ b/processing/pre/geom_fromMinimalSurface.py @@ -90,12 +90,7 @@ for name in filenames: #--- report --------------------------------------------------------------------------------------- - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') diff --git a/processing/pre/geom_fromTable.py b/processing/pre/geom_fromTable.py index 8eb1ed8bf..7a905cd26 100755 --- a/processing/pre/geom_fromTable.py +++ b/processing/pre/geom_fromTable.py @@ -192,12 +192,7 @@ for name in filenames: 'homogenization': options.homogenization, } - damask.util.croak(['grid a b c: {}'.format(' x '.join(map(str,info['grid']))), - 'size x y z: {}'.format(' x '.join(map(str,info['size']))), - 'origin x y z: {}'.format(' : '.join(map(str,info['origin']))), - 'homogenization: {}'.format(info['homogenization']), - 'microstructures: {}'.format(info['microstructures']), - ]) + damask.util.report_geom(info) # --- write header --------------------------------------------------------------------------------- @@ -230,7 +225,7 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ table.data = grain.reshape(info['grid'][1]*info['grid'][2],info['grid'][0]) - table.data_writeArray('%%%ii'%(formatwidth),delimiter=' ') + table.data_writeArray('%{}i'.format(formatwidth),delimiter=' ') #--- output finalization -------------------------------------------------------------------------- diff --git a/processing/pre/geom_grainGrowth.py b/processing/pre/geom_grainGrowth.py index 1afb02715..f7c50c2e5 100755 --- a/processing/pre/geom_grainGrowth.py +++ b/processing/pre/geom_grainGrowth.py @@ -69,13 +69,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: {}'.format(' x '.join(list(map(str,info['grid'])))), - 'size x y z: {}'.format(' x '.join(list(map(str,info['size'])))), - 'origin x y z: {}'.format(' : '.join(list(map(str,info['origin'])))), - 'homogenization: {}'.format(info['homogenization']), - 'microstructures: {}'.format(info['microstructures']), - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -200,8 +194,7 @@ for name in filenames: newID += 1 microstructure = np.where(microstructure == microstructureID, newID, microstructure) - newInfo = {'microstructures': 0,} - newInfo['microstructures'] = microstructure.max() + newInfo = {'microstructures': len(np.unique(microstructure)),} # --- report -------------------------------------------------------------------------------------- @@ -226,7 +219,7 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + formatwidth = int(math.floor(math.log10(np.nanmax(microstructure))+1)) table.data = microstructure[::1 if info['grid'][0]>1 else 2, ::1 if info['grid'][1]>1 else 2, ::1 if info['grid'][2]>1 else 2,].\ diff --git a/processing/pre/geom_mirror.py b/processing/pre/geom_mirror.py index 951fb0842..853b99632 100755 --- a/processing/pre/geom_mirror.py +++ b/processing/pre/geom_mirror.py @@ -23,6 +23,13 @@ parser.add_option('-d','--direction', dest = 'directions', action = 'extend', metavar = '', help = "directions in which to mirror {'x','y','z'}") +parser.add_option('--float', + dest = 'float', + action = 'store_true', + help = 'use float input') + +parser.set_defaults(float = False, + ) (options, filenames) = parser.parse_args() @@ -32,6 +39,8 @@ if not set(options.directions).issubset(validDirections): invalidDirections = [str(e) for e in set(options.directions).difference(validDirections)] parser.error('invalid directions {}. '.format(*invalidDirections)) +datatype = 'f' if options.float else 'i' + # --- loop over input files ------------------------------------------------------------------------- if filenames == []: filenames = [None] @@ -39,7 +48,8 @@ if filenames == []: filenames = [None] for name in filenames: try: table = damask.ASCIItable(name = name, - buffered = False, labeled = False) + buffered = False, + labeled = False) except: continue damask.util.report(scriptName,name) @@ -47,13 +57,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -65,7 +69,7 @@ for name in filenames: # --- read data ------------------------------------------------------------------------------------ - microstructure = table.microstructure_read(info['grid']).reshape(info['grid'],order='F') # read microstructure + microstructure = table.microstructure_read(info['grid'],datatype).reshape(info['grid'],order='F') # read microstructure if 'z' in options.directions: microstructure = np.concatenate([microstructure,microstructure[:,:,::-1]],2) @@ -107,9 +111,9 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + formatwidth = int(math.floor(math.log10(np.nanmax(microstructure))+1)) table.data = microstructure.reshape((newInfo['grid'][0],np.prod(newInfo['grid'][1:])),order='F').transpose() - table.data_writeArray('%%%ii'%(formatwidth),delimiter = ' ') + table.data_writeArray('%{}i'.format(formatwidth),delimiter = ' ') # --- output finalization -------------------------------------------------------------------------- diff --git a/processing/pre/geom_pack.py b/processing/pre/geom_pack.py index 0d864bbf5..2e6080a6b 100755 --- a/processing/pre/geom_pack.py +++ b/processing/pre/geom_pack.py @@ -35,14 +35,8 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: {}'.format(' x '.join(map(str,info['grid']))), - 'size x y z: {}'.format(' x '.join(map(str,info['size']))), - 'origin x y z: {}'.format(' : '.join(map(str,info['origin']))), - 'homogenization: {}'.format(info['homogenization']), - 'microstructures: {}'.format(info['microstructures']), - ]) - + damask.util.report_geom(info) + errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') if np.any(info['size'] <= 0.0): errors.append('invalid size x y z.') diff --git a/processing/pre/geom_renumber.py b/processing/pre/geom_renumber.py index 033b4a566..3faa7f449 100755 --- a/processing/pre/geom_renumber.py +++ b/processing/pre/geom_renumber.py @@ -35,13 +35,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -93,7 +87,7 @@ for name in filenames: # --- write microstructure information ----------------------------------------------------------- - format = '%{}i'.format(int(math.floor(math.log10(newInfo['microstructures'])+1))) + format = '%{}i'.format(int(math.floor(math.log10(np.nanmax(renumbered))+1))) table.data = renumbered.reshape((info['grid'][0],info['grid'][1]*info['grid'][2]),order='F').transpose() table.data_writeArray(format,delimiter = ' ') diff --git a/processing/pre/geom_rescale.py b/processing/pre/geom_rescale.py index b3716bd62..4a14c0050 100755 --- a/processing/pre/geom_rescale.py +++ b/processing/pre/geom_rescale.py @@ -31,14 +31,21 @@ parser.add_option('-r', '--renumber', dest = 'renumber', action = 'store_true', help = 'renumber microstructure indices from 1..N [%default]') +parser.add_option('--float', + dest = 'float', + action = 'store_true', + help = 'use float input') parser.set_defaults(renumber = False, grid = ['0','0','0'], size = ['0.0','0.0','0.0'], + float = False, ) (options, filenames) = parser.parse_args() +datatype = 'f' if options.float else 'i' + # --- loop over input files ------------------------------------------------------------------------- if filenames == []: filenames = [None] @@ -46,7 +53,8 @@ if filenames == []: filenames = [None] for name in filenames: try: table = damask.ASCIItable(name = name, - buffered = False, labeled = False) + buffered = False, + labeled = False) except: continue damask.util.report(scriptName,name) @@ -54,13 +62,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -72,7 +74,7 @@ for name in filenames: # --- read data ------------------------------------------------------------------------------------ - microstructure = table.microstructure_read(info['grid']) # read microstructure + microstructure = table.microstructure_read(info['grid'],datatype) # read microstructure # --- do work ------------------------------------------------------------------------------------ @@ -113,7 +115,7 @@ for name in filenames: newID += 1 microstructure = np.where(microstructure == microstructureID, newID,microstructure).reshape(microstructure.shape) - newInfo['microstructures'] = microstructure.max() + newInfo['microstructures'] = len(np.unique(microstructure)) # --- report --------------------------------------------------------------------------------------- @@ -152,9 +154,9 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + format = '%g' if options.float else '%{}i'.format(int(math.floor(math.log10(np.nanmax(microstructure))+1))) table.data = microstructure.reshape((newInfo['grid'][0],newInfo['grid'][1]*newInfo['grid'][2]),order='F').transpose() - table.data_writeArray('%%%ii'%(formatwidth),delimiter = ' ') + table.data_writeArray(format,delimiter=' ') # --- output finalization -------------------------------------------------------------------------- diff --git a/processing/pre/geom_rotate.py b/processing/pre/geom_rotate.py index 4da59cddf..7cce5800d 100755 --- a/processing/pre/geom_rotate.py +++ b/processing/pre/geom_rotate.py @@ -43,9 +43,15 @@ parser.add_option('-f', '--fill', dest = 'fill', type = 'int', metavar = 'int', help = 'background grain index. "0" selects maximum microstructure index + 1 [%default]') +parser.add_option('--float', + dest = 'float', + action = 'store_true', + help = 'use float input') parser.set_defaults(degrees = False, - fill = 0) + fill = 0, + float = False, + ) (options, filenames) = parser.parse_args() @@ -61,6 +67,8 @@ if options.matrix is not None: if options.eulers is not None: eulers = damask.Rotation.fromEulers(np.array(options.eulers),degrees=True).asEulers(degrees=True) +datatype = 'f' if options.float else 'i' + # --- loop over input files ------------------------------------------------------------------------- if filenames == []: filenames = [None] @@ -77,13 +85,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: {}'.format(' x '.join(map(str,info['grid']))), - 'size x y z: {}'.format(' x '.join(map(str,info['size']))), - 'origin x y z: {}'.format(' : '.join(map(str,info['origin']))), - 'homogenization: {}'.format(info['homogenization']), - 'microstructures: {}'.format(info['microstructures']), - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -95,9 +97,9 @@ for name in filenames: # --- read data ------------------------------------------------------------------------------------ - microstructure = table.microstructure_read(info['grid']).reshape(info['grid'],order='F') # read microstructure + microstructure = table.microstructure_read(info['grid'],datatype).reshape(info['grid'],order='F') # read microstructure - newGrainID = options.fill if options.fill != 0 else microstructure.max()+1 + newGrainID = options.fill if options.fill != 0 else np.nanmax(microstructure)+1 microstructure = ndimage.rotate(microstructure,eulers[2],(0,1),order=0,prefilter=False,output=int,cval=newGrainID) # rotation around Z microstructure = ndimage.rotate(microstructure,eulers[1],(1,2),order=0,prefilter=False,output=int,cval=newGrainID) # rotation around X microstructure = ndimage.rotate(microstructure,eulers[0],(0,1),order=0,prefilter=False,output=int,cval=newGrainID) # rotation around Z @@ -107,19 +109,18 @@ for name in filenames: newInfo = { 'size': microstructure.shape*info['size']/info['grid'], 'grid': microstructure.shape, - 'microstructures': microstructure.max(), + 'microstructures': len(np.unique(microstructure)), } - # --- report --------------------------------------------------------------------------------------- remarks = [] if (any(newInfo['grid'] != info['grid'])): - remarks.append('--> grid a b c: %s'%(' x '.join(map(str,newInfo['grid'])))) + remarks.append('--> grid a b c: {}'.format(' x '.join(map(str,newInfo['grid'])))) if (any(newInfo['size'] != info['size'])): - remarks.append('--> size x y z: %s'%(' x '.join(map(str,newInfo['size'])))) + remarks.append('--> size x y z: {}'.format(' x '.join(map(str,newInfo['size'])))) if ( newInfo['microstructures'] != info['microstructures']): - remarks.append('--> microstructures: %i'%newInfo['microstructures']) + remarks.append('--> microstructures: {}'.format(newInfo['microstructures'])) if remarks != []: damask.util.croak(remarks) # --- write header --------------------------------------------------------------------------------- @@ -138,9 +139,9 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + format = '%g' if options.float else '%{}i'.format(int(math.floor(math.log10(np.nanmax(microstructure))+1))) table.data = microstructure.reshape((newInfo['grid'][0],np.prod(newInfo['grid'][1:])),order='F').transpose() - table.data_writeArray('%%%ii'%(formatwidth),delimiter = ' ') + table.data_writeArray(format,delimiter=' ') # --- output finalization -------------------------------------------------------------------------- diff --git a/processing/pre/geom_toTable.py b/processing/pre/geom_toTable.py index 73e4888d1..0a71b335e 100755 --- a/processing/pre/geom_toTable.py +++ b/processing/pre/geom_toTable.py @@ -20,15 +20,15 @@ Translate geom description into ASCIItable containing position and microstructur """, version = scriptID) parser.add_option('--float', - dest = 'real', + dest = 'float', action = 'store_true', help = 'use float input') -parser.set_defaults(real = False, +parser.set_defaults(float = False, ) (options, filenames) = parser.parse_args() -datatype = 'f' if options.real else 'i' +datatype = 'f' if options.float else 'i' # --- loop over input files ------------------------------------------------------------------------- @@ -47,13 +47,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: {}'.format(' x '.join(list(map(str,info['grid'])))), - 'size x y z: {}'.format(' x '.join(list(map(str,info['size'])))), - 'origin x y z: {}'.format(' : '.join(list(map(str,info['origin'])))), - 'homogenization: {}'.format(info['homogenization']), - 'microstructures: {}'.format(info['microstructures']), - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') diff --git a/processing/pre/geom_translate.py b/processing/pre/geom_translate.py index 59aaac5d5..072c270ea 100755 --- a/processing/pre/geom_translate.py +++ b/processing/pre/geom_translate.py @@ -31,19 +31,19 @@ parser.add_option('-s', '--substitute', action = 'extend', metavar = '', help = 'substitutions of microstructure indices from,to,from,to,...') parser.add_option('--float', - dest = 'real', + dest = 'float', action = 'store_true', help = 'use float input') parser.set_defaults(origin = (0.0,0.0,0.0), microstructure = 0, substitute = [], - real = False, + float = False, ) (options, filenames) = parser.parse_args() -datatype = 'f' if options.real else 'i' +datatype = 'f' if options.float else 'i' sub = {} for i in range(len(options.substitute)//2): # split substitution list into "from" -> "to" @@ -64,13 +64,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -92,7 +86,7 @@ for name in filenames: } substituted = np.copy(microstructure) - for k, v in sub.items(): substituted[microstructure==k] = v # substitute microstructure indices + for k, v in sub.items(): substituted[microstructure==k] = v # substitute microstructure indices substituted += options.microstructure # shift microstructure indices @@ -103,9 +97,9 @@ for name in filenames: remarks = [] if (any(newInfo['origin'] != info['origin'])): - remarks.append('--> origin x y z: %s'%(' : '.join(map(str,newInfo['origin'])))) + remarks.append('--> origin x y z: {}'.format(' : '.join(map(str,newInfo['origin'])))) if ( newInfo['microstructures'] != info['microstructures']): - remarks.append('--> microstructures: %i'%newInfo['microstructures']) + remarks.append('--> microstructures: {}'.format(newInfo['microstructures'])) if remarks != []: damask.util.croak(remarks) # --- write header ------------------------------------------------------------------------------- @@ -124,7 +118,7 @@ for name in filenames: # --- write microstructure information ----------------------------------------------------------- - format = '%g' if options.real else '%{}i'.format(int(math.floor(math.log10(microstructure.max())+1))) + format = '%g' if options.float else '%{}i'.format(int(math.floor(math.log10(np.nanmax(substituted))+1))) table.data = substituted.reshape((info['grid'][0],info['grid'][1]*info['grid'][2]),order='F').transpose() table.data_writeArray(format,delimiter = ' ') diff --git a/processing/pre/geom_unpack.py b/processing/pre/geom_unpack.py index 726e4ef04..4cac76c5f 100755 --- a/processing/pre/geom_unpack.py +++ b/processing/pre/geom_unpack.py @@ -43,13 +43,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') diff --git a/processing/pre/geom_vicinityOffset.py b/processing/pre/geom_vicinityOffset.py index 9fce7201a..733276d01 100755 --- a/processing/pre/geom_vicinityOffset.py +++ b/processing/pre/geom_vicinityOffset.py @@ -73,13 +73,7 @@ for name in filenames: table.head_read() info,extra_header = table.head_getGeom() - - damask.util.croak(['grid a b c: %s'%(' x '.join(map(str,info['grid']))), - 'size x y z: %s'%(' x '.join(map(str,info['size']))), - 'origin x y z: %s'%(' : '.join(map(str,info['origin']))), - 'homogenization: %i'%info['homogenization'], - 'microstructures: %i'%info['microstructures'], - ]) + damask.util.report_geom(info) errors = [] if np.any(info['grid'] < 1): errors.append('invalid grid a b c.') @@ -108,7 +102,7 @@ for name in filenames: extra_keywords={"trigger":options.trigger,"size":1+2*options.vicinity}), microstructure + options.offset,microstructure) - newInfo['microstructures'] = microstructure.max() + newInfo['microstructures'] = len(np.unique(microstructure)) # --- report --------------------------------------------------------------------------------------- @@ -131,9 +125,9 @@ for name in filenames: # --- write microstructure information ------------------------------------------------------------ - formatwidth = int(math.floor(math.log10(microstructure.max())+1)) + formatwidth = int(math.floor(math.log10(np.nanmax(microstructure))+1)) table.data = microstructure.reshape((info['grid'][0],info['grid'][1]*info['grid'][2]),order='F').transpose() - table.data_writeArray('%%%ii'%(formatwidth),delimiter = ' ') + table.data_writeArray('%{}i'.format(formatwidth),delimiter = ' ') # --- output finalization -------------------------------------------------------------------------- From e743a55ff2254a0b870ed65d60bbba0e6bba9f0c Mon Sep 17 00:00:00 2001 From: Test User Date: Thu, 23 May 2019 23:01:28 +0200 Subject: [PATCH 26/36] [skip ci] updated version information after successful test of v2.0.3-307-geb13fbc0 --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 2d8c83361..98f27ab76 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-304-g7b14263c +v2.0.3-307-geb13fbc0 From 144361295d362a7179adfaf76184f74b176e2208 Mon Sep 17 00:00:00 2001 From: Test User Date: Mon, 27 May 2019 15:39:37 +0200 Subject: [PATCH 27/36] [skip ci] updated version information after successful test of v2.0.3-332-g5abcca50 --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 98f27ab76..d961b0f73 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-307-geb13fbc0 +v2.0.3-332-g5abcca50 From 0db42642652fc047895aa6fa4d9c71e7560634b6 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 28 May 2019 09:27:52 +0200 Subject: [PATCH 28/36] cleaning --- src/config.f90 | 2 +- src/quaternions.f90 | 334 ++++++++++++++++++++++---------------------- 2 files changed, 168 insertions(+), 168 deletions(-) diff --git a/src/config.f90 b/src/config.f90 index 8729014ce..cd67c4641 100644 --- a/src/config.f90 +++ b/src/config.f90 @@ -15,7 +15,7 @@ module config implicit none private - type(tPartitionedStringList), public, protected, allocatable, dimension(:) :: & + type(tPartitionedStringList), public, protected, allocatable, dimension(:) :: & config_phase, & config_microstructure, & config_homogenization, & diff --git a/src/quaternions.f90 b/src/quaternions.f90 index 47490daba..dc894bdfa 100644 --- a/src/quaternions.f90 +++ b/src/quaternions.f90 @@ -3,27 +3,27 @@ ! Modified 2017-2019, Martin Diehl/Max-Planck-Institut für Eisenforschung GmbH ! All rights reserved. ! -! Redistribution and use in source and binary forms, with or without modification, are +! Redistribution and use in source and binary forms, with or without modification, are ! permitted provided that the following conditions are met: ! -! - Redistributions of source code must retain the above copyright notice, this list +! - Redistributions of source code must retain the above copyright notice, this list ! of conditions and the following disclaimer. -! - Redistributions in binary form must reproduce the above copyright notice, this -! list of conditions and the following disclaimer in the documentation and/or +! - Redistributions in binary form must reproduce the above copyright notice, this +! list of conditions and the following disclaimer in the documentation and/or ! other materials provided with the distribution. -! - Neither the names of Marc De Graef, Carnegie Mellon University nor the names -! of its contributors may be used to endorse or promote products derived from +! - Neither the names of Marc De Graef, Carnegie Mellon University nor the names +! of its contributors may be used to endorse or promote products derived from ! this software without specific prior written permission. ! -! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -! AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -! IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -! ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -! LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -! DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -! SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -! OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +! AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +! IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +! ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +! LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +! DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +! SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +! OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE ! USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ! ################################################################### @@ -34,57 +34,57 @@ !> @details w is the real part, (x, y, z) are the imaginary parts. !--------------------------------------------------------------------------------------------------- module quaternions - use prec - use future + use prec + use future - implicit none - public - - real(pReal), parameter, public :: P = -1.0_pReal !< parameter for orientation conversion. - - type, public :: quaternion - real(pReal) :: w = 0.0_pReal - real(pReal) :: x = 0.0_pReal - real(pReal) :: y = 0.0_pReal - real(pReal) :: z = 0.0_pReal - + implicit none + public - contains - procedure, private :: add__ - procedure, private :: pos__ - generic, public :: operator(+) => add__,pos__ + real(pReal), parameter, public :: P = -1.0_pReal !< parameter for orientation conversion. - procedure, private :: sub__ - procedure, private :: neg__ - generic, public :: operator(-) => sub__,neg__ + type, public :: quaternion + real(pReal) :: w = 0.0_pReal + real(pReal) :: x = 0.0_pReal + real(pReal) :: y = 0.0_pReal + real(pReal) :: z = 0.0_pReal - procedure, private :: mul_quat__ - procedure, private :: mul_scal__ - generic, public :: operator(*) => mul_quat__, mul_scal__ - procedure, private :: div_quat__ - procedure, private :: div_scal__ - generic, public :: operator(/) => div_quat__, div_scal__ + contains + procedure, private :: add__ + procedure, private :: pos__ + generic, public :: operator(+) => add__,pos__ - procedure, private :: eq__ - generic, public :: operator(==) => eq__ + procedure, private :: sub__ + procedure, private :: neg__ + generic, public :: operator(-) => sub__,neg__ - procedure, private :: neq__ - generic, public :: operator(/=) => neq__ + procedure, private :: mul_quat__ + procedure, private :: mul_scal__ + generic, public :: operator(*) => mul_quat__, mul_scal__ - procedure, private :: pow_quat__ - procedure, private :: pow_scal__ - generic, public :: operator(**) => pow_quat__, pow_scal__ + procedure, private :: div_quat__ + procedure, private :: div_scal__ + generic, public :: operator(/) => div_quat__, div_scal__ - procedure, public :: abs__ - procedure, public :: dot_product__ - procedure, public :: conjg__ - procedure, public :: exp__ - procedure, public :: log__ + procedure, private :: eq__ + generic, public :: operator(==) => eq__ - procedure, public :: homomorphed => quat_homomorphed + procedure, private :: neq__ + generic, public :: operator(/=) => neq__ - end type + procedure, private :: pow_quat__ + procedure, private :: pow_scal__ + generic, public :: operator(**) => pow_quat__, pow_scal__ + + procedure, public :: abs__ + procedure, public :: dot_product__ + procedure, public :: conjg__ + procedure, public :: exp__ + procedure, public :: log__ + + procedure, public :: homomorphed => quat_homomorphed + + end type interface assignment (=) module procedure assign_quat__ @@ -123,12 +123,12 @@ contains !--------------------------------------------------------------------------------------------------- type(quaternion) pure function init__(array) - real(pReal), intent(in), dimension(4) :: array - - init__%w=array(1) - init__%x=array(2) - init__%y=array(3) - init__%z=array(4) + real(pReal), intent(in), dimension(4) :: array + + init__%w=array(1) + init__%x=array(2) + init__%y=array(3) + init__%z=array(4) end function init__ @@ -138,14 +138,14 @@ end function init__ !--------------------------------------------------------------------------------------------------- elemental subroutine assign_quat__(self,other) - type(quaternion), intent(out) :: self - type(quaternion), intent(in) :: other - - self%w = other%w - self%x = other%x - self%y = other%y - self%z = other%z - + type(quaternion), intent(out) :: self + type(quaternion), intent(in) :: other + + self%w = other%w + self%x = other%x + self%y = other%y + self%z = other%z + end subroutine assign_quat__ @@ -154,14 +154,14 @@ end subroutine assign_quat__ !--------------------------------------------------------------------------------------------------- pure subroutine assign_vec__(self,other) - type(quaternion), intent(out) :: self - real(pReal), intent(in), dimension(4) :: other - - self%w = other(1) - self%x = other(2) - self%y = other(3) - self%z = other(4) - + type(quaternion), intent(out) :: self + real(pReal), intent(in), dimension(4) :: other + + self%w = other(1) + self%x = other(2) + self%y = other(3) + self%z = other(4) + end subroutine assign_vec__ @@ -170,13 +170,13 @@ end subroutine assign_vec__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function add__(self,other) - class(quaternion), intent(in) :: self,other - - add__%w = self%w + other%w - add__%x = self%x + other%x - add__%y = self%y + other%y - add__%z = self%z + other%z - + class(quaternion), intent(in) :: self,other + + add__%w = self%w + other%w + add__%x = self%x + other%x + add__%y = self%y + other%y + add__%z = self%z + other%z + end function add__ @@ -185,13 +185,13 @@ end function add__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function pos__(self) - class(quaternion), intent(in) :: self - - pos__%w = self%w - pos__%x = self%x - pos__%y = self%y - pos__%z = self%z - + class(quaternion), intent(in) :: self + + pos__%w = self%w + pos__%x = self%x + pos__%y = self%y + pos__%z = self%z + end function pos__ @@ -200,13 +200,13 @@ end function pos__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function sub__(self,other) - class(quaternion), intent(in) :: self,other - - sub__%w = self%w - other%w - sub__%x = self%x - other%x - sub__%y = self%y - other%y - sub__%z = self%z - other%z - + class(quaternion), intent(in) :: self,other + + sub__%w = self%w - other%w + sub__%x = self%x - other%x + sub__%y = self%y - other%y + sub__%z = self%z - other%z + end function sub__ @@ -215,13 +215,13 @@ end function sub__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function neg__(self) - class(quaternion), intent(in) :: self - - neg__%w = -self%w - neg__%x = -self%x - neg__%y = -self%y - neg__%z = -self%z - + class(quaternion), intent(in) :: self + + neg__%w = -self%w + neg__%x = -self%x + neg__%y = -self%y + neg__%z = -self%z + end function neg__ @@ -230,13 +230,13 @@ end function neg__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function mul_quat__(self,other) - class(quaternion), intent(in) :: self, other + class(quaternion), intent(in) :: self, other + + mul_quat__%w = self%w*other%w - self%x*other%x - self%y*other%y - self%z*other%z + mul_quat__%x = self%w*other%x + self%x*other%w + P * (self%y*other%z - self%z*other%y) + mul_quat__%y = self%w*other%y + self%y*other%w + P * (self%z*other%x - self%x*other%z) + mul_quat__%z = self%w*other%z + self%z*other%w + P * (self%x*other%y - self%y*other%x) - mul_quat__%w = self%w*other%w - self%x*other%x - self%y*other%y - self%z*other%z - mul_quat__%x = self%w*other%x + self%x*other%w + P * (self%y*other%z - self%z*other%y) - mul_quat__%y = self%w*other%y + self%y*other%w + P * (self%z*other%x - self%x*other%z) - mul_quat__%z = self%w*other%z + self%z*other%w + P * (self%x*other%y - self%y*other%x) - end function mul_quat__ @@ -245,14 +245,14 @@ end function mul_quat__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function mul_scal__(self,scal) - class(quaternion), intent(in) :: self - real(pReal), intent(in) :: scal + class(quaternion), intent(in) :: self + real(pReal), intent(in) :: scal + + mul_scal__%w = self%w*scal + mul_scal__%x = self%x*scal + mul_scal__%y = self%y*scal + mul_scal__%z = self%z*scal - mul_scal__%w = self%w*scal - mul_scal__%x = self%x*scal - mul_scal__%y = self%y*scal - mul_scal__%z = self%z*scal - end function mul_scal__ @@ -261,9 +261,9 @@ end function mul_scal__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function div_quat__(self,other) - class(quaternion), intent(in) :: self, other + class(quaternion), intent(in) :: self, other - div_quat__ = self * (conjg(other)/(abs(other)**2.0_pReal)) + div_quat__ = self * (conjg(other)/(abs(other)**2.0_pReal)) end function div_quat__ @@ -273,10 +273,10 @@ end function div_quat__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function div_scal__(self,scal) - class(quaternion), intent(in) :: self - real(pReal), intent(in) :: scal + class(quaternion), intent(in) :: self + real(pReal), intent(in) :: scal - div_scal__ = [self%w,self%x,self%y,self%z]/scal + div_scal__ = [self%w,self%x,self%y,self%z]/scal end function div_scal__ @@ -286,11 +286,11 @@ end function div_scal__ !--------------------------------------------------------------------------------------------------- logical elemental function eq__(self,other) - class(quaternion), intent(in) :: self,other + class(quaternion), intent(in) :: self,other + + eq__ = all(dEq([ self%w, self%x, self%y, self%z], & + [other%w,other%x,other%y,other%z])) - eq__ = all(dEq([ self%w, self%x, self%y, self%z], & - [other%w,other%x,other%y,other%z])) - end function eq__ @@ -299,10 +299,10 @@ end function eq__ !--------------------------------------------------------------------------------------------------- logical elemental function neq__(self,other) - class(quaternion), intent(in) :: self,other + class(quaternion), intent(in) :: self,other + + neq__ = .not. self%eq__(other) - neq__ = .not. self%eq__(other) - end function neq__ @@ -311,11 +311,11 @@ end function neq__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function pow_scal__(self,expon) - class(quaternion), intent(in) :: self - real(pReal), intent(in) :: expon - - pow_scal__ = exp(log(self)*expon) - + class(quaternion), intent(in) :: self + real(pReal), intent(in) :: expon + + pow_scal__ = exp(log(self)*expon) + end function pow_scal__ @@ -324,11 +324,11 @@ end function pow_scal__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function pow_quat__(self,expon) - class(quaternion), intent(in) :: self - type(quaternion), intent(in) :: expon - - pow_quat__ = exp(log(self)*expon) - + class(quaternion), intent(in) :: self + type(quaternion), intent(in) :: expon + + pow_quat__ = exp(log(self)*expon) + end function pow_quat__ @@ -338,15 +338,15 @@ end function pow_quat__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function exp__(self) - class(quaternion), intent(in) :: self - real(pReal) :: absImag + class(quaternion), intent(in) :: self + real(pReal) :: absImag - absImag = norm2([self%x, self%y, self%z]) + absImag = norm2([self%x, self%y, self%z]) - exp__ = exp(self%w) * [ cos(absImag), & - self%x/absImag * sin(absImag), & - self%y/absImag * sin(absImag), & - self%z/absImag * sin(absImag)] + exp__ = exp(self%w) * [ cos(absImag), & + self%x/absImag * sin(absImag), & + self%y/absImag * sin(absImag), & + self%z/absImag * sin(absImag)] end function exp__ @@ -357,16 +357,16 @@ end function exp__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function log__(self) - class(quaternion), intent(in) :: self - real(pReal) :: absImag + class(quaternion), intent(in) :: self + real(pReal) :: absImag - absImag = norm2([self%x, self%y, self%z]) + absImag = norm2([self%x, self%y, self%z]) + + log__ = [log(abs(self)), & + self%x/absImag * acos(self%w/abs(self)), & + self%y/absImag * acos(self%w/abs(self)), & + self%z/absImag * acos(self%w/abs(self))] - log__ = [log(abs(self)), & - self%x/absImag * acos(self%w/abs(self)), & - self%y/absImag * acos(self%w/abs(self)), & - self%z/absImag * acos(self%w/abs(self))] - end function log__ @@ -375,10 +375,10 @@ end function log__ !--------------------------------------------------------------------------------------------------- real(pReal) elemental function abs__(a) - class(quaternion), intent(in) :: a + class(quaternion), intent(in) :: a + + abs__ = norm2([a%w,a%x,a%y,a%z]) - abs__ = norm2([a%w,a%x,a%y,a%z]) - end function abs__ @@ -387,10 +387,10 @@ end function abs__ !--------------------------------------------------------------------------------------------------- real(pReal) elemental function dot_product__(a,b) - class(quaternion), intent(in) :: a,b + class(quaternion), intent(in) :: a,b + + dot_product__ = a%w*b%w + a%x*b%x + a%y*b%y + a%z*b%z - dot_product__ = a%w*b%w + a%x*b%x + a%y*b%y + a%z*b%z - end function dot_product__ @@ -399,10 +399,10 @@ end function dot_product__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function conjg__(a) - class(quaternion), intent(in) :: a + class(quaternion), intent(in) :: a + + conjg__ = quaternion([a%w, -a%x, -a%y, -a%z]) - conjg__ = quaternion([a%w, -a%x, -a%y, -a%z]) - end function conjg__ @@ -411,10 +411,10 @@ end function conjg__ !--------------------------------------------------------------------------------------------------- type(quaternion) elemental function quat_homomorphed(a) - class(quaternion), intent(in) :: a + class(quaternion), intent(in) :: a + + quat_homomorphed = quaternion(-[a%w,a%x,a%y,a%z]) - quat_homomorphed = quaternion(-[a%w,a%x,a%y,a%z]) - end function quat_homomorphed end module quaternions From a5c6e4b17c21337dde6966ecf4dc2e1d5d176bc0 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 28 May 2019 12:06:21 +0200 Subject: [PATCH 29/36] do not clutter the code with use statements --- src/DAMASK_interface.f90 | 7 +- src/HDF5_utilities.f90 | 10 +- src/damage_nonlocal.f90 | 399 ++++++++++++------------ src/homogenization.f90 | 24 +- src/kinematics_cleavage_opening.f90 | 298 +++++++++--------- src/list.f90 | 34 +- src/results.f90 | 16 +- src/source_damage_anisoBrittle.f90 | 465 +++++++++++++--------------- src/source_thermal_dissipation.f90 | 34 +- src/source_thermal_externalheat.f90 | 31 +- src/thermal_adiabatic.f90 | 77 +---- 11 files changed, 614 insertions(+), 781 deletions(-) diff --git a/src/DAMASK_interface.f90 b/src/DAMASK_interface.f90 index b76813fe6..cb13bfaea 100644 --- a/src/DAMASK_interface.f90 +++ b/src/DAMASK_interface.f90 @@ -14,7 +14,11 @@ #define PETSC_MAJOR 3 #define PETSC_MINOR_MIN 10 #define PETSC_MINOR_MAX 11 + module DAMASK_interface + use, intrinsic :: iso_fortran_env + use PETScSys + use prec use system_routines @@ -50,9 +54,6 @@ contains !! information on computation to screen !-------------------------------------------------------------------------------------------------- subroutine DAMASK_interface_init - use, intrinsic :: iso_fortran_env - use PETScSys - #include #if defined(__GFORTRAN__) && __GNUC__ @details to be done !-------------------------------------------------------------------------------------------------- module damage_nonlocal - use prec - use material - use numerics - use config - use crystallite - use lattice - use mesh + use prec + use material + use numerics + use config + use crystallite + use lattice + use mesh + use source_damage_isoBrittle + use source_damage_isoDuctile + use source_damage_anisoBrittle + use source_damage_anisoDuctile - implicit none - private - - integer, dimension(:,:), allocatable, target, public :: & - damage_nonlocal_sizePostResult !< size of each post result output + implicit none + private + + integer, dimension(:,:), allocatable, target, public :: & + damage_nonlocal_sizePostResult !< size of each post result output - character(len=64), dimension(:,:), allocatable, target, public :: & - damage_nonlocal_output !< name of each post result output - - integer, dimension(:), allocatable, target, public :: & - damage_nonlocal_Noutput !< number of outputs per instance of this damage + character(len=64), dimension(:,:), allocatable, target, public :: & + damage_nonlocal_output !< name of each post result output + + integer, dimension(:), allocatable, target, public :: & + damage_nonlocal_Noutput !< number of outputs per instance of this damage - enum, bind(c) - enumerator :: undefined_ID, & - damage_ID - end enum + enum, bind(c) + enumerator :: undefined_ID, & + damage_ID + end enum - type :: tParameters - integer(kind(undefined_ID)), dimension(:), allocatable :: & - outputID - end type tParameters - - type(tparameters), dimension(:), allocatable :: & - param + type :: tParameters + integer(kind(undefined_ID)), dimension(:), allocatable :: & + outputID + end type tParameters + + type(tparameters), dimension(:), allocatable :: & + param - public :: & - damage_nonlocal_init, & - damage_nonlocal_getSourceAndItsTangent, & - damage_nonlocal_getDiffusion33, & - damage_nonlocal_getMobility, & - damage_nonlocal_putNonLocalDamage, & - damage_nonlocal_postResults + public :: & + damage_nonlocal_init, & + damage_nonlocal_getSourceAndItsTangent, & + damage_nonlocal_getDiffusion33, & + damage_nonlocal_getMobility, & + damage_nonlocal_putNonLocalDamage, & + damage_nonlocal_postResults contains @@ -53,129 +57,122 @@ contains !-------------------------------------------------------------------------------------------------- subroutine damage_nonlocal_init - integer :: maxNinstance,homog,instance,o,i - integer :: sizeState - integer :: NofMyHomog, h - integer(kind(undefined_ID)) :: & - outputID - character(len=65536), dimension(0), parameter :: emptyStringArray = [character(len=65536)::] - character(len=65536), dimension(:), allocatable :: & - outputs + integer :: maxNinstance,homog,instance,o,i + integer :: sizeState + integer :: NofMyHomog, h + integer(kind(undefined_ID)) :: & + outputID + character(len=65536), dimension(0), parameter :: emptyStringArray = [character(len=65536)::] + character(len=65536), dimension(:), allocatable :: & + outputs - write(6,'(/,a)') ' <<<+- damage_'//DAMAGE_nonlocal_label//' init -+>>>' - - maxNinstance = count(damage_type == DAMAGE_nonlocal_ID) - if (maxNinstance == 0) return - - allocate(damage_nonlocal_sizePostResult (maxval(homogenization_Noutput),maxNinstance),source=0) - allocate(damage_nonlocal_output (maxval(homogenization_Noutput),maxNinstance)) - damage_nonlocal_output = '' - allocate(damage_nonlocal_Noutput (maxNinstance), source=0) - - allocate(param(maxNinstance)) + write(6,'(/,a)') ' <<<+- damage_'//DAMAGE_nonlocal_label//' init -+>>>' - do h = 1, size(damage_type) - if (damage_type(h) /= DAMAGE_NONLOCAL_ID) cycle - associate(prm => param(damage_typeInstance(h)), & - config => config_homogenization(h)) - - instance = damage_typeInstance(h) - outputs = config%getStrings('(output)',defaultVal=emptyStringArray) - allocate(prm%outputID(0)) + maxNinstance = count(damage_type == DAMAGE_nonlocal_ID) + if (maxNinstance == 0) return + + allocate(damage_nonlocal_sizePostResult (maxval(homogenization_Noutput),maxNinstance),source=0) + allocate(damage_nonlocal_output (maxval(homogenization_Noutput),maxNinstance)) + damage_nonlocal_output = '' + allocate(damage_nonlocal_Noutput (maxNinstance), source=0) + + allocate(param(maxNinstance)) - do i=1, size(outputs) - outputID = undefined_ID - select case(outputs(i)) - - case ('damage') - damage_nonlocal_output(i,damage_typeInstance(h)) = outputs(i) - damage_nonlocal_Noutput(instance) = damage_nonlocal_Noutput(instance) + 1 - damage_nonlocal_sizePostResult(i,damage_typeInstance(h)) = 1 - prm%outputID = [prm%outputID , damage_ID] - end select - - enddo + do h = 1, size(damage_type) + if (damage_type(h) /= DAMAGE_NONLOCAL_ID) cycle + associate(prm => param(damage_typeInstance(h)), & + config => config_homogenization(h)) + + instance = damage_typeInstance(h) + outputs = config%getStrings('(output)',defaultVal=emptyStringArray) + allocate(prm%outputID(0)) + + do i=1, size(outputs) + outputID = undefined_ID + select case(outputs(i)) + + case ('damage') + damage_nonlocal_output(i,damage_typeInstance(h)) = outputs(i) + damage_nonlocal_Noutput(instance) = damage_nonlocal_Noutput(instance) + 1 + damage_nonlocal_sizePostResult(i,damage_typeInstance(h)) = 1 + prm%outputID = [prm%outputID , damage_ID] + end select + + enddo - homog = h + homog = h - NofMyHomog = count(material_homogenizationAt == homog) - instance = damage_typeInstance(homog) + NofMyHomog = count(material_homogenizationAt == homog) + instance = damage_typeInstance(homog) -! allocate state arrays - sizeState = 1 - damageState(homog)%sizeState = sizeState - damageState(homog)%sizePostResults = sum(damage_nonlocal_sizePostResult(:,instance)) - allocate(damageState(homog)%state0 (sizeState,NofMyHomog), source=damage_initialPhi(homog)) - allocate(damageState(homog)%subState0(sizeState,NofMyHomog), source=damage_initialPhi(homog)) - allocate(damageState(homog)%state (sizeState,NofMyHomog), source=damage_initialPhi(homog)) +! allocate state arrays + sizeState = 1 + damageState(homog)%sizeState = sizeState + damageState(homog)%sizePostResults = sum(damage_nonlocal_sizePostResult(:,instance)) + allocate(damageState(homog)%state0 (sizeState,NofMyHomog), source=damage_initialPhi(homog)) + allocate(damageState(homog)%subState0(sizeState,NofMyHomog), source=damage_initialPhi(homog)) + allocate(damageState(homog)%state (sizeState,NofMyHomog), source=damage_initialPhi(homog)) - nullify(damageMapping(homog)%p) - damageMapping(homog)%p => mappingHomogenization(1,:,:) - deallocate(damage(homog)%p) - damage(homog)%p => damageState(homog)%state(1,:) - - end associate - enddo + nullify(damageMapping(homog)%p) + damageMapping(homog)%p => mappingHomogenization(1,:,:) + deallocate(damage(homog)%p) + damage(homog)%p => damageState(homog)%state(1,:) + + end associate + enddo end subroutine damage_nonlocal_init + !-------------------------------------------------------------------------------------------------- !> @brief calculates homogenized damage driving forces !-------------------------------------------------------------------------------------------------- subroutine damage_nonlocal_getSourceAndItsTangent(phiDot, dPhiDot_dPhi, phi, ip, el) - use source_damage_isoBrittle, only: & - source_damage_isobrittle_getRateAndItsTangent - use source_damage_isoDuctile, only: & - source_damage_isoductile_getRateAndItsTangent - use source_damage_anisoBrittle, only: & - source_damage_anisobrittle_getRateAndItsTangent - use source_damage_anisoDuctile, only: & - source_damage_anisoductile_getRateAndItsTangent - integer, intent(in) :: & - ip, & !< integration point number - el !< element number - real(pReal), intent(in) :: & - phi - integer :: & - phase, & - grain, & - source, & - constituent - real(pReal) :: & - phiDot, dPhiDot_dPhi, localphiDot, dLocalphiDot_dPhi + integer, intent(in) :: & + ip, & !< integration point number + el !< element number + real(pReal), intent(in) :: & + phi + integer :: & + phase, & + grain, & + source, & + constituent + real(pReal) :: & + phiDot, dPhiDot_dPhi, localphiDot, dLocalphiDot_dPhi - phiDot = 0.0_pReal - dPhiDot_dPhi = 0.0_pReal - do grain = 1, homogenization_Ngrains(material_homogenizationAt(el)) - phase = phaseAt(grain,ip,el) - constituent = phasememberAt(grain,ip,el) - do source = 1, phase_Nsources(phase) - select case(phase_source(source,phase)) - case (SOURCE_damage_isoBrittle_ID) - call source_damage_isobrittle_getRateAndItsTangent (localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) + phiDot = 0.0_pReal + dPhiDot_dPhi = 0.0_pReal + do grain = 1, homogenization_Ngrains(material_homogenizationAt(el)) + phase = phaseAt(grain,ip,el) + constituent = phasememberAt(grain,ip,el) + do source = 1, phase_Nsources(phase) + select case(phase_source(source,phase)) + case (SOURCE_damage_isoBrittle_ID) + call source_damage_isobrittle_getRateAndItsTangent (localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) - case (SOURCE_damage_isoDuctile_ID) - call source_damage_isoductile_getRateAndItsTangent (localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) + case (SOURCE_damage_isoDuctile_ID) + call source_damage_isoductile_getRateAndItsTangent (localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) - case (SOURCE_damage_anisoBrittle_ID) - call source_damage_anisobrittle_getRateAndItsTangent(localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) + case (SOURCE_damage_anisoBrittle_ID) + call source_damage_anisobrittle_getRateAndItsTangent(localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) - case (SOURCE_damage_anisoDuctile_ID) - call source_damage_anisoductile_getRateAndItsTangent(localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) + case (SOURCE_damage_anisoDuctile_ID) + call source_damage_anisoductile_getRateAndItsTangent(localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) - case default - localphiDot = 0.0_pReal - dLocalphiDot_dPhi = 0.0_pReal + case default + localphiDot = 0.0_pReal + dLocalphiDot_dPhi = 0.0_pReal - end select - phiDot = phiDot + localphiDot - dPhiDot_dPhi = dPhiDot_dPhi + dLocalphiDot_dPhi - enddo - enddo - - phiDot = phiDot/real(homogenization_Ngrains(material_homogenizationAt(el)),pReal) - dPhiDot_dPhi = dPhiDot_dPhi/real(homogenization_Ngrains(material_homogenizationAt(el)),pReal) + end select + phiDot = phiDot + localphiDot + dPhiDot_dPhi = dPhiDot_dPhi + dLocalphiDot_dPhi + enddo + enddo + + phiDot = phiDot/real(homogenization_Ngrains(material_homogenizationAt(el)),pReal) + dPhiDot_dPhi = dPhiDot_dPhi/real(homogenization_Ngrains(material_homogenizationAt(el)),pReal) end subroutine damage_nonlocal_getSourceAndItsTangent @@ -185,24 +182,24 @@ end subroutine damage_nonlocal_getSourceAndItsTangent !-------------------------------------------------------------------------------------------------- function damage_nonlocal_getDiffusion33(ip,el) - integer, intent(in) :: & - ip, & !< integration point number - el !< element number - real(pReal), dimension(3,3) :: & - damage_nonlocal_getDiffusion33 - integer :: & - homog, & - grain - - homog = material_homogenizationAt(el) - damage_nonlocal_getDiffusion33 = 0.0_pReal - do grain = 1, homogenization_Ngrains(homog) - damage_nonlocal_getDiffusion33 = damage_nonlocal_getDiffusion33 + & - crystallite_push33ToRef(grain,ip,el,lattice_DamageDiffusion33(1:3,1:3,material_phase(grain,ip,el))) - enddo + integer, intent(in) :: & + ip, & !< integration point number + el !< element number + real(pReal), dimension(3,3) :: & + damage_nonlocal_getDiffusion33 + integer :: & + homog, & + grain + + homog = material_homogenizationAt(el) + damage_nonlocal_getDiffusion33 = 0.0_pReal + do grain = 1, homogenization_Ngrains(homog) + damage_nonlocal_getDiffusion33 = damage_nonlocal_getDiffusion33 + & + crystallite_push33ToRef(grain,ip,el,lattice_DamageDiffusion33(1:3,1:3,material_phase(grain,ip,el))) + enddo - damage_nonlocal_getDiffusion33 = & - charLength**2*damage_nonlocal_getDiffusion33/real(homogenization_Ngrains(homog),pReal) + damage_nonlocal_getDiffusion33 = & + charLength**2*damage_nonlocal_getDiffusion33/real(homogenization_Ngrains(homog),pReal) end function damage_nonlocal_getDiffusion33 @@ -212,20 +209,20 @@ end function damage_nonlocal_getDiffusion33 !-------------------------------------------------------------------------------------------------- real(pReal) function damage_nonlocal_getMobility(ip,el) - integer, intent(in) :: & - ip, & !< integration point number - el !< element number - integer :: & - ipc - - damage_nonlocal_getMobility = 0.0_pReal - - do ipc = 1, homogenization_Ngrains(mesh_element(3,el)) - damage_nonlocal_getMobility = damage_nonlocal_getMobility + lattice_DamageMobility(material_phase(ipc,ip,el)) - enddo + integer, intent(in) :: & + ip, & !< integration point number + el !< element number + integer :: & + ipc + + damage_nonlocal_getMobility = 0.0_pReal + + do ipc = 1, homogenization_Ngrains(mesh_element(3,el)) + damage_nonlocal_getMobility = damage_nonlocal_getMobility + lattice_DamageMobility(material_phase(ipc,ip,el)) + enddo - damage_nonlocal_getMobility = damage_nonlocal_getMobility/& - real(homogenization_Ngrains(mesh_element(3,el)),pReal) + damage_nonlocal_getMobility = damage_nonlocal_getMobility/& + real(homogenization_Ngrains(mesh_element(3,el)),pReal) end function damage_nonlocal_getMobility @@ -235,18 +232,18 @@ end function damage_nonlocal_getMobility !-------------------------------------------------------------------------------------------------- subroutine damage_nonlocal_putNonLocalDamage(phi,ip,el) - integer, intent(in) :: & - ip, & !< integration point number - el !< element number - real(pReal), intent(in) :: & - phi - integer :: & - homog, & - offset - - homog = material_homogenizationAt(el) - offset = damageMapping(homog)%p(ip,el) - damage(homog)%p(offset) = phi + integer, intent(in) :: & + ip, & !< integration point number + el !< element number + real(pReal), intent(in) :: & + phi + integer :: & + homog, & + offset + + homog = material_homogenizationAt(el) + offset = damageMapping(homog)%p(ip,el) + damage(homog)%p(offset) = phi end subroutine damage_nonlocal_putNonLocalDamage @@ -256,31 +253,31 @@ end subroutine damage_nonlocal_putNonLocalDamage !-------------------------------------------------------------------------------------------------- function damage_nonlocal_postResults(ip,el) - integer, intent(in) :: & - ip, & !< integration point - el !< element - real(pReal), dimension(sum(damage_nonlocal_sizePostResult(:,damage_typeInstance(material_homogenizationAt(el))))) :: & - damage_nonlocal_postResults + integer, intent(in) :: & + ip, & !< integration point + el !< element + real(pReal), dimension(sum(damage_nonlocal_sizePostResult(:,damage_typeInstance(material_homogenizationAt(el))))) :: & + damage_nonlocal_postResults - integer :: & - instance, homog, offset, o, c - - homog = material_homogenizationAt(el) - offset = damageMapping(homog)%p(ip,el) - instance = damage_typeInstance(homog) - associate(prm => param(instance)) - c = 0 + integer :: & + instance, homog, offset, o, c + + homog = material_homogenizationAt(el) + offset = damageMapping(homog)%p(ip,el) + instance = damage_typeInstance(homog) + associate(prm => param(instance)) + c = 0 - outputsLoop: do o = 1,size(prm%outputID) - select case(prm%outputID(o)) - - case (damage_ID) - damage_nonlocal_postResults(c+1) = damage(homog)%p(offset) - c = c + 1 - end select - enddo outputsLoop + outputsLoop: do o = 1,size(prm%outputID) + select case(prm%outputID(o)) + + case (damage_ID) + damage_nonlocal_postResults(c+1) = damage(homog)%p(offset) + c = c + 1 + end select + enddo outputsLoop - end associate + end associate end function damage_nonlocal_postResults end module damage_nonlocal diff --git a/src/homogenization.f90 b/src/homogenization.f90 index 3210f02d4..9287cc4bf 100644 --- a/src/homogenization.f90 +++ b/src/homogenization.f90 @@ -16,6 +16,12 @@ module homogenization use crystallite use mesh use FEsolving + use thermal_isothermal + use thermal_adiabatic + use thermal_conduction + use damage_none + use damage_local + use damage_nonlocal #if defined(PETSc) || defined(DAMASK_HDF5) use results use HDF5_utilities @@ -131,12 +137,6 @@ contains !> @brief module initialization !-------------------------------------------------------------------------------------------------- subroutine homogenization_init - use thermal_isothermal - use thermal_adiabatic - use thermal_conduction - use damage_none - use damage_local - use damage_nonlocal integer, parameter :: FILEUNIT = 200 integer :: e,i,p @@ -668,10 +668,6 @@ end subroutine partitionDeformation !> "happy" with result !-------------------------------------------------------------------------------------------------- function updateState(ip,el) - use thermal_adiabatic, only: & - thermal_adiabatic_updateState - use damage_local, only: & - damage_local_updateState integer, intent(in) :: & ip, & !< integration point @@ -753,14 +749,6 @@ end subroutine averageStressAndItsTangent !> if homogenization_sizePostResults(i,e) > 0 !! !-------------------------------------------------------------------------------------------------- function postResults(ip,el) - use thermal_adiabatic, only: & - thermal_adiabatic_postResults - use thermal_conduction, only: & - thermal_conduction_postResults - use damage_local, only: & - damage_local_postResults - use damage_nonlocal, only: & - damage_nonlocal_postResults integer, intent(in) :: & ip, & !< integration point diff --git a/src/kinematics_cleavage_opening.f90 b/src/kinematics_cleavage_opening.f90 index 60d9cb500..39bfbf340 100644 --- a/src/kinematics_cleavage_opening.f90 +++ b/src/kinematics_cleavage_opening.f90 @@ -13,43 +13,43 @@ module kinematics_cleavage_opening use lattice use material - implicit none - private + implicit none + private - integer, dimension(:), allocatable :: kinematics_cleavage_opening_instance + integer, dimension(:), allocatable :: kinematics_cleavage_opening_instance - type :: tParameters !< container type for internal constitutive parameters - integer :: & - totalNcleavage - integer, dimension(:), allocatable :: & - Ncleavage !< active number of cleavage systems per family - real(pReal) :: & - sdot0, & - n - real(pReal), dimension(:), allocatable :: & - critDisp, & - critLoad - end type + type :: tParameters !< container type for internal constitutive parameters + integer :: & + totalNcleavage + integer, dimension(:), allocatable :: & + Ncleavage !< active number of cleavage systems per family + real(pReal) :: & + sdot0, & + n + real(pReal), dimension(:), allocatable :: & + critDisp, & + critLoad + end type ! Begin Deprecated - integer, dimension(:), allocatable :: & - kinematics_cleavage_opening_totalNcleavage !< total number of cleavage systems - - integer, dimension(:,:), allocatable :: & - kinematics_cleavage_opening_Ncleavage !< number of cleavage systems per family - - real(pReal), dimension(:), allocatable :: & - kinematics_cleavage_opening_sdot_0, & - kinematics_cleavage_opening_N + integer, dimension(:), allocatable :: & + kinematics_cleavage_opening_totalNcleavage !< total number of cleavage systems + + integer, dimension(:,:), allocatable :: & + kinematics_cleavage_opening_Ncleavage !< number of cleavage systems per family + + real(pReal), dimension(:), allocatable :: & + kinematics_cleavage_opening_sdot_0, & + kinematics_cleavage_opening_N - real(pReal), dimension(:,:), allocatable :: & - kinematics_cleavage_opening_critDisp, & - kinematics_cleavage_opening_critLoad + real(pReal), dimension(:,:), allocatable :: & + kinematics_cleavage_opening_critDisp, & + kinematics_cleavage_opening_critLoad ! End Deprecated - public :: & - kinematics_cleavage_opening_init, & - kinematics_cleavage_opening_LiAndItsTangent + public :: & + kinematics_cleavage_opening_init, & + kinematics_cleavage_opening_LiAndItsTangent contains @@ -60,142 +60,142 @@ contains !-------------------------------------------------------------------------------------------------- subroutine kinematics_cleavage_opening_init - integer, allocatable, dimension(:) :: tempInt - real(pReal), allocatable, dimension(:) :: tempFloat + integer, allocatable, dimension(:) :: tempInt + real(pReal), allocatable, dimension(:) :: tempFloat - integer :: maxNinstance,p,instance + integer :: maxNinstance,p,instance - write(6,'(/,a)') ' <<<+- kinematics_'//KINEMATICS_cleavage_opening_LABEL//' init -+>>>' + write(6,'(/,a)') ' <<<+- kinematics_'//KINEMATICS_cleavage_opening_LABEL//' init -+>>>' - maxNinstance = count(phase_kinematics == KINEMATICS_cleavage_opening_ID) - if (maxNinstance == 0) return - - if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & - write(6,'(a16,1x,i5,/)') '# instances:',maxNinstance - - allocate(kinematics_cleavage_opening_instance(size(config_phase)), source=0) - do p = 1, size(config_phase) - kinematics_cleavage_opening_instance(p) = count(phase_kinematics(:,1:p) == kinematics_cleavage_opening_ID) ! ToDo: count correct? - enddo - - allocate(kinematics_cleavage_opening_critDisp(lattice_maxNcleavageFamily,maxNinstance), source=0.0_pReal) - allocate(kinematics_cleavage_opening_critLoad(lattice_maxNcleavageFamily,maxNinstance), source=0.0_pReal) - allocate(kinematics_cleavage_opening_Ncleavage(lattice_maxNcleavageFamily,maxNinstance), source=0) - allocate(kinematics_cleavage_opening_totalNcleavage(maxNinstance), source=0) - allocate(kinematics_cleavage_opening_sdot_0(maxNinstance), source=0.0_pReal) - allocate(kinematics_cleavage_opening_N(maxNinstance), source=0.0_pReal) + maxNinstance = count(phase_kinematics == KINEMATICS_cleavage_opening_ID) + if (maxNinstance == 0) return + + if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & + write(6,'(a16,1x,i5,/)') '# instances:',maxNinstance + + allocate(kinematics_cleavage_opening_instance(size(config_phase)), source=0) + do p = 1, size(config_phase) + kinematics_cleavage_opening_instance(p) = count(phase_kinematics(:,1:p) == kinematics_cleavage_opening_ID) ! ToDo: count correct? + enddo + + allocate(kinematics_cleavage_opening_critDisp(lattice_maxNcleavageFamily,maxNinstance), source=0.0_pReal) + allocate(kinematics_cleavage_opening_critLoad(lattice_maxNcleavageFamily,maxNinstance), source=0.0_pReal) + allocate(kinematics_cleavage_opening_Ncleavage(lattice_maxNcleavageFamily,maxNinstance), source=0) + allocate(kinematics_cleavage_opening_totalNcleavage(maxNinstance), source=0) + allocate(kinematics_cleavage_opening_sdot_0(maxNinstance), source=0.0_pReal) + allocate(kinematics_cleavage_opening_N(maxNinstance), source=0.0_pReal) - do p = 1, size(config_phase) - if (all(phase_kinematics(:,p) /= KINEMATICS_cleavage_opening_ID)) cycle - instance = kinematics_cleavage_opening_instance(p) - kinematics_cleavage_opening_sdot_0(instance) = config_phase(p)%getFloat('anisobrittle_sdot0') - kinematics_cleavage_opening_N(instance) = config_phase(p)%getFloat('anisobrittle_ratesensitivity') - tempInt = config_phase(p)%getInts('ncleavage') - kinematics_cleavage_opening_Ncleavage(1:size(tempInt),instance) = tempInt + do p = 1, size(config_phase) + if (all(phase_kinematics(:,p) /= KINEMATICS_cleavage_opening_ID)) cycle + instance = kinematics_cleavage_opening_instance(p) + kinematics_cleavage_opening_sdot_0(instance) = config_phase(p)%getFloat('anisobrittle_sdot0') + kinematics_cleavage_opening_N(instance) = config_phase(p)%getFloat('anisobrittle_ratesensitivity') + tempInt = config_phase(p)%getInts('ncleavage') + kinematics_cleavage_opening_Ncleavage(1:size(tempInt),instance) = tempInt - tempFloat = config_phase(p)%getFloats('anisobrittle_criticaldisplacement',requiredSize=size(tempInt)) - kinematics_cleavage_opening_critDisp(1:size(tempInt),instance) = tempFloat + tempFloat = config_phase(p)%getFloats('anisobrittle_criticaldisplacement',requiredSize=size(tempInt)) + kinematics_cleavage_opening_critDisp(1:size(tempInt),instance) = tempFloat - tempFloat = config_phase(p)%getFloats('anisobrittle_criticalload',requiredSize=size(tempInt)) - kinematics_cleavage_opening_critLoad(1:size(tempInt),instance) = tempFloat + tempFloat = config_phase(p)%getFloats('anisobrittle_criticalload',requiredSize=size(tempInt)) + kinematics_cleavage_opening_critLoad(1:size(tempInt),instance) = tempFloat - kinematics_cleavage_opening_Ncleavage(1:lattice_maxNcleavageFamily,instance) = & - min(lattice_NcleavageSystem(1:lattice_maxNcleavageFamily,p),& ! limit active cleavage systems per family to min of available and requested - kinematics_cleavage_opening_Ncleavage(1:lattice_maxNcleavageFamily,instance)) - kinematics_cleavage_opening_totalNcleavage(instance) = sum(kinematics_cleavage_opening_Ncleavage(:,instance)) ! how many cleavage systems altogether - if (kinematics_cleavage_opening_sdot_0(instance) <= 0.0_pReal) & - call IO_error(211,el=instance,ext_msg='sdot_0 ('//KINEMATICS_cleavage_opening_LABEL//')') - if (any(kinematics_cleavage_opening_critDisp(1:size(tempInt),instance) < 0.0_pReal)) & - call IO_error(211,el=instance,ext_msg='critical_displacement ('//KINEMATICS_cleavage_opening_LABEL//')') - if (any(kinematics_cleavage_opening_critLoad(1:size(tempInt),instance) < 0.0_pReal)) & - call IO_error(211,el=instance,ext_msg='critical_load ('//KINEMATICS_cleavage_opening_LABEL//')') - if (kinematics_cleavage_opening_N(instance) <= 0.0_pReal) & - call IO_error(211,el=instance,ext_msg='rate_sensitivity ('//KINEMATICS_cleavage_opening_LABEL//')') - enddo + kinematics_cleavage_opening_Ncleavage(1:lattice_maxNcleavageFamily,instance) = & + min(lattice_NcleavageSystem(1:lattice_maxNcleavageFamily,p),& ! limit active cleavage systems per family to min of available and requested + kinematics_cleavage_opening_Ncleavage(1:lattice_maxNcleavageFamily,instance)) + kinematics_cleavage_opening_totalNcleavage(instance) = sum(kinematics_cleavage_opening_Ncleavage(:,instance)) ! how many cleavage systems altogether + if (kinematics_cleavage_opening_sdot_0(instance) <= 0.0_pReal) & + call IO_error(211,el=instance,ext_msg='sdot_0 ('//KINEMATICS_cleavage_opening_LABEL//')') + if (any(kinematics_cleavage_opening_critDisp(1:size(tempInt),instance) < 0.0_pReal)) & + call IO_error(211,el=instance,ext_msg='critical_displacement ('//KINEMATICS_cleavage_opening_LABEL//')') + if (any(kinematics_cleavage_opening_critLoad(1:size(tempInt),instance) < 0.0_pReal)) & + call IO_error(211,el=instance,ext_msg='critical_load ('//KINEMATICS_cleavage_opening_LABEL//')') + if (kinematics_cleavage_opening_N(instance) <= 0.0_pReal) & + call IO_error(211,el=instance,ext_msg='rate_sensitivity ('//KINEMATICS_cleavage_opening_LABEL//')') + enddo end subroutine kinematics_cleavage_opening_init - + !-------------------------------------------------------------------------------------------------- !> @brief contains the constitutive equation for calculating the velocity gradient !-------------------------------------------------------------------------------------------------- subroutine kinematics_cleavage_opening_LiAndItsTangent(Ld, dLd_dTstar, S, ipc, ip, el) - integer, intent(in) :: & - ipc, & !< grain number - ip, & !< integration point number - el !< element number - real(pReal), intent(in), dimension(3,3) :: & - S - real(pReal), intent(out), dimension(3,3) :: & - Ld !< damage velocity gradient - real(pReal), intent(out), dimension(3,3,3,3) :: & - dLd_dTstar !< derivative of Ld with respect to Tstar (4th-order tensor) - integer :: & - instance, phase, & - homog, damageOffset, & - f, i, index_myFamily, k, l, m, n - real(pReal) :: & - traction_d, traction_t, traction_n, traction_crit, & - udotd, dudotd_dt, udott, dudott_dt, udotn, dudotn_dt + integer, intent(in) :: & + ipc, & !< grain number + ip, & !< integration point number + el !< element number + real(pReal), intent(in), dimension(3,3) :: & + S + real(pReal), intent(out), dimension(3,3) :: & + Ld !< damage velocity gradient + real(pReal), intent(out), dimension(3,3,3,3) :: & + dLd_dTstar !< derivative of Ld with respect to Tstar (4th-order tensor) + integer :: & + instance, phase, & + homog, damageOffset, & + f, i, index_myFamily, k, l, m, n + real(pReal) :: & + traction_d, traction_t, traction_n, traction_crit, & + udotd, dudotd_dt, udott, dudott_dt, udotn, dudotn_dt - phase = material_phase(ipc,ip,el) - instance = kinematics_cleavage_opening_instance(phase) - homog = material_homogenizationAt(el) - damageOffset = damageMapping(homog)%p(ip,el) - - Ld = 0.0_pReal - dLd_dTstar = 0.0_pReal - do f = 1,lattice_maxNcleavageFamily - index_myFamily = sum(lattice_NcleavageSystem(1:f-1,phase)) ! at which index starts my family - do i = 1,kinematics_cleavage_opening_Ncleavage(f,instance) ! process each (active) cleavage system in family - traction_d = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,1,index_myFamily+i,phase)) - traction_t = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,2,index_myFamily+i,phase)) - traction_n = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,3,index_myFamily+i,phase)) - traction_crit = kinematics_cleavage_opening_critLoad(f,instance)* & - damage(homog)%p(damageOffset)*damage(homog)%p(damageOffset) - udotd = & - sign(1.0_pReal,traction_d)* & - kinematics_cleavage_opening_sdot_0(instance)* & - (max(0.0_pReal, abs(traction_d) - traction_crit)/traction_crit)**kinematics_cleavage_opening_N(instance) - if (abs(udotd) > tol_math_check) then - Ld = Ld + udotd*lattice_Scleavage(1:3,1:3,1,index_myFamily+i,phase) - dudotd_dt = sign(1.0_pReal,traction_d)*udotd*kinematics_cleavage_opening_N(instance)/ & - max(0.0_pReal, abs(traction_d) - traction_crit) - forall (k=1:3,l=1:3,m=1:3,n=1:3) & - dLd_dTstar(k,l,m,n) = dLd_dTstar(k,l,m,n) + & - dudotd_dt*lattice_Scleavage(k,l,1,index_myFamily+i,phase)* & - lattice_Scleavage(m,n,1,index_myFamily+i,phase) - endif + phase = material_phase(ipc,ip,el) + instance = kinematics_cleavage_opening_instance(phase) + homog = material_homogenizationAt(el) + damageOffset = damageMapping(homog)%p(ip,el) + + Ld = 0.0_pReal + dLd_dTstar = 0.0_pReal + do f = 1,lattice_maxNcleavageFamily + index_myFamily = sum(lattice_NcleavageSystem(1:f-1,phase)) ! at which index starts my family + do i = 1,kinematics_cleavage_opening_Ncleavage(f,instance) ! process each (active) cleavage system in family + traction_d = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,1,index_myFamily+i,phase)) + traction_t = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,2,index_myFamily+i,phase)) + traction_n = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,3,index_myFamily+i,phase)) + traction_crit = kinematics_cleavage_opening_critLoad(f,instance)* & + damage(homog)%p(damageOffset)*damage(homog)%p(damageOffset) + udotd = & + sign(1.0_pReal,traction_d)* & + kinematics_cleavage_opening_sdot_0(instance)* & + (max(0.0_pReal, abs(traction_d) - traction_crit)/traction_crit)**kinematics_cleavage_opening_N(instance) + if (abs(udotd) > tol_math_check) then + Ld = Ld + udotd*lattice_Scleavage(1:3,1:3,1,index_myFamily+i,phase) + dudotd_dt = sign(1.0_pReal,traction_d)*udotd*kinematics_cleavage_opening_N(instance)/ & + max(0.0_pReal, abs(traction_d) - traction_crit) + forall (k=1:3,l=1:3,m=1:3,n=1:3) & + dLd_dTstar(k,l,m,n) = dLd_dTstar(k,l,m,n) + & + dudotd_dt*lattice_Scleavage(k,l,1,index_myFamily+i,phase)* & + lattice_Scleavage(m,n,1,index_myFamily+i,phase) + endif - udott = & - sign(1.0_pReal,traction_t)* & - kinematics_cleavage_opening_sdot_0(instance)* & - (max(0.0_pReal, abs(traction_t) - traction_crit)/traction_crit)**kinematics_cleavage_opening_N(instance) - if (abs(udott) > tol_math_check) then - Ld = Ld + udott*lattice_Scleavage(1:3,1:3,2,index_myFamily+i,phase) - dudott_dt = sign(1.0_pReal,traction_t)*udott*kinematics_cleavage_opening_N(instance)/ & - max(0.0_pReal, abs(traction_t) - traction_crit) - forall (k=1:3,l=1:3,m=1:3,n=1:3) & - dLd_dTstar(k,l,m,n) = dLd_dTstar(k,l,m,n) + & - dudott_dt*lattice_Scleavage(k,l,2,index_myFamily+i,phase)* & - lattice_Scleavage(m,n,2,index_myFamily+i,phase) - endif + udott = & + sign(1.0_pReal,traction_t)* & + kinematics_cleavage_opening_sdot_0(instance)* & + (max(0.0_pReal, abs(traction_t) - traction_crit)/traction_crit)**kinematics_cleavage_opening_N(instance) + if (abs(udott) > tol_math_check) then + Ld = Ld + udott*lattice_Scleavage(1:3,1:3,2,index_myFamily+i,phase) + dudott_dt = sign(1.0_pReal,traction_t)*udott*kinematics_cleavage_opening_N(instance)/ & + max(0.0_pReal, abs(traction_t) - traction_crit) + forall (k=1:3,l=1:3,m=1:3,n=1:3) & + dLd_dTstar(k,l,m,n) = dLd_dTstar(k,l,m,n) + & + dudott_dt*lattice_Scleavage(k,l,2,index_myFamily+i,phase)* & + lattice_Scleavage(m,n,2,index_myFamily+i,phase) + endif - udotn = & - sign(1.0_pReal,traction_n)* & - kinematics_cleavage_opening_sdot_0(instance)* & - (max(0.0_pReal, abs(traction_n) - traction_crit)/traction_crit)**kinematics_cleavage_opening_N(instance) - if (abs(udotn) > tol_math_check) then - Ld = Ld + udotn*lattice_Scleavage(1:3,1:3,3,index_myFamily+i,phase) - dudotn_dt = sign(1.0_pReal,traction_n)*udotn*kinematics_cleavage_opening_N(instance)/ & - max(0.0_pReal, abs(traction_n) - traction_crit) - forall (k=1:3,l=1:3,m=1:3,n=1:3) & - dLd_dTstar(k,l,m,n) = dLd_dTstar(k,l,m,n) + & - dudotn_dt*lattice_Scleavage(k,l,3,index_myFamily+i,phase)* & - lattice_Scleavage(m,n,3,index_myFamily+i,phase) - endif - enddo - enddo + udotn = & + sign(1.0_pReal,traction_n)* & + kinematics_cleavage_opening_sdot_0(instance)* & + (max(0.0_pReal, abs(traction_n) - traction_crit)/traction_crit)**kinematics_cleavage_opening_N(instance) + if (abs(udotn) > tol_math_check) then + Ld = Ld + udotn*lattice_Scleavage(1:3,1:3,3,index_myFamily+i,phase) + dudotn_dt = sign(1.0_pReal,traction_n)*udotn*kinematics_cleavage_opening_N(instance)/ & + max(0.0_pReal, abs(traction_n) - traction_crit) + forall (k=1:3,l=1:3,m=1:3,n=1:3) & + dLd_dTstar(k,l,m,n) = dLd_dTstar(k,l,m,n) + & + dudotn_dt*lattice_Scleavage(k,l,3,index_myFamily+i,phase)* & + lattice_Scleavage(m,n,3,index_myFamily+i,phase) + endif + enddo + enddo end subroutine kinematics_cleavage_opening_LiAndItsTangent diff --git a/src/list.f90 b/src/list.f90 index be80b151d..79eafc964 100644 --- a/src/list.f90 +++ b/src/list.f90 @@ -3,8 +3,8 @@ !> @brief linked list !-------------------------------------------------------------------------------------------------- module list - use prec, only: & - pReal + use prec + use IO implicit none private @@ -65,10 +65,6 @@ contains !! to lower case. The data is not stored in the new element but in the current. !-------------------------------------------------------------------------------------------------- subroutine add(this,string) - use IO, only: & - IO_isBlank, & - IO_lc, & - IO_stringPos class(tPartitionedStringList), target, intent(in) :: this character(len=*), intent(in) :: string @@ -157,8 +153,6 @@ end subroutine finalizeArray !> @brief reports wether a given key (string value at first position) exists in the list !-------------------------------------------------------------------------------------------------- logical function keyExists(this,key) - use IO, only: & - IO_stringValue class(tPartitionedStringList), target, intent(in) :: this character(len=*), intent(in) :: key @@ -180,8 +174,6 @@ end function keyExists !> @details traverses list and counts each occurrence of specified key !-------------------------------------------------------------------------------------------------- integer function countKeys(this,key) - use IO, only: & - IO_stringValue class(tPartitionedStringList), target, intent(in) :: this character(len=*), intent(in) :: key @@ -205,10 +197,6 @@ end function countKeys !! error unless default is given !-------------------------------------------------------------------------------------------------- real(pReal) function getFloat(this,key,defaultVal) - use IO, only : & - IO_error, & - IO_stringValue, & - IO_FloatValue class(tPartitionedStringList), target, intent(in) :: this character(len=*), intent(in) :: key @@ -241,10 +229,6 @@ end function getFloat !! error unless default is given !-------------------------------------------------------------------------------------------------- integer function getInt(this,key,defaultVal) - use IO, only: & - IO_error, & - IO_stringValue, & - IO_IntValue class(tPartitionedStringList), target, intent(in) :: this character(len=*), intent(in) :: key @@ -278,9 +262,6 @@ end function getInt !! the individual chunks are returned !-------------------------------------------------------------------------------------------------- character(len=65536) function getString(this,key,defaultVal,raw) - use IO, only: & - IO_error, & - IO_stringValue class(tPartitionedStringList), target, intent(in) :: this character(len=*), intent(in) :: key @@ -327,10 +308,6 @@ end function getString !! values from the last occurrence. If key is not found exits with error unless default is given. !-------------------------------------------------------------------------------------------------- function getFloats(this,key,defaultVal,requiredSize) - use IO, only: & - IO_error, & - IO_stringValue, & - IO_FloatValue real(pReal), dimension(:), allocatable :: getFloats class(tPartitionedStringList), target, intent(in) :: this @@ -376,10 +353,6 @@ end function getFloats !! values from the last occurrence. If key is not found exits with error unless default is given. !-------------------------------------------------------------------------------------------------- function getInts(this,key,defaultVal,requiredSize) - use IO, only: & - IO_error, & - IO_stringValue, & - IO_IntValue integer, dimension(:), allocatable :: getInts class(tPartitionedStringList), target, intent(in) :: this @@ -426,9 +399,6 @@ end function getInts !! If raw is true, the the complete string is returned, otherwise the individual chunks are returned !-------------------------------------------------------------------------------------------------- function getStrings(this,key,defaultVal,raw) - use IO, only: & - IO_error, & - IO_StringValue character(len=65536),dimension(:), allocatable :: getStrings class(tPartitionedStringList),target, intent(in) :: this diff --git a/src/results.f90 b/src/results.f90 index 05db831f7..cee86c7da 100644 --- a/src/results.f90 +++ b/src/results.f90 @@ -5,6 +5,9 @@ !> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH !-------------------------------------------------------------------------------------------------- module results + use DAMASK_interface + use rotations + use numerics use HDF5_utilities #ifdef PETSc use PETSC @@ -55,8 +58,6 @@ module results contains subroutine results_init - use DAMASK_interface, only: & - getSolverJobName character(len=pStringLen) :: commandLine @@ -83,9 +84,6 @@ end subroutine results_init !> @brief opens the results file to append data !-------------------------------------------------------------------------------------------------- subroutine results_openJobFile - use DAMASK_interface, only: & - getSolverJobName - resultsFile = HDF5_openFile(trim(getSolverJobName())//'.hdf5','a',.true.) @@ -396,8 +394,6 @@ end subroutine results_writeTensorDataset_int !> @brief stores a scalar dataset in a group !-------------------------------------------------------------------------------------------------- subroutine results_writeScalarDataset_rotation(group,dataset,label,description,lattice_structure) - use rotations, only: & - rotation character(len=*), intent(in) :: label,group,description character(len=*), intent(in), optional :: lattice_structure @@ -428,9 +424,6 @@ end subroutine results_writeScalarDataset_rotation !> @brief adds the unique mapping from spatial position and constituent ID to results !-------------------------------------------------------------------------------------------------- subroutine results_mapping_constituent(phaseAt,memberAt,label) - use numerics, only: & - worldrank, & - worldsize integer, dimension(:,:), intent(in) :: phaseAt !< phase section at (constituent,element) integer, dimension(:,:,:), intent(in) :: memberAt !< phase member at (constituent,IP,element) @@ -566,9 +559,6 @@ end subroutine results_mapping_constituent !> @brief adds the unique mapping from spatial position and constituent ID to results !-------------------------------------------------------------------------------------------------- subroutine results_mapping_materialpoint(homogenizationAt,memberAt,label) - use numerics, only: & - worldrank, & - worldsize integer, dimension(:), intent(in) :: homogenizationAt !< homogenization section at (element) integer, dimension(:,:), intent(in) :: memberAt !< homogenization member at (IP,element) diff --git a/src/source_damage_anisoBrittle.f90 b/src/source_damage_anisoBrittle.f90 index 2f5fc119f..ccad7c6b0 100644 --- a/src/source_damage_anisoBrittle.f90 +++ b/src/source_damage_anisoBrittle.f90 @@ -5,55 +5,62 @@ !> @details to be done !-------------------------------------------------------------------------------------------------- module source_damage_anisoBrittle - use prec + use prec + use debug + use IO + use math + use material + use config + use lattice - implicit none - private - integer, dimension(:), allocatable, public, protected :: & - source_damage_anisoBrittle_offset, & !< which source is my current source mechanism? - source_damage_anisoBrittle_instance !< instance of source mechanism + implicit none + private - integer, dimension(:,:), allocatable, target, public :: & - source_damage_anisoBrittle_sizePostResult !< size of each post result output + integer, dimension(:), allocatable, public, protected :: & + source_damage_anisoBrittle_offset, & !< which source is my current source mechanism? + source_damage_anisoBrittle_instance !< instance of source mechanism - character(len=64), dimension(:,:), allocatable, target, public :: & - source_damage_anisoBrittle_output !< name of each post result output - - integer, dimension(:,:), allocatable, private :: & - source_damage_anisoBrittle_Ncleavage !< number of cleavage systems per family + integer, dimension(:,:), allocatable, target, public :: & + source_damage_anisoBrittle_sizePostResult !< size of each post result output - enum, bind(c) - enumerator :: undefined_ID, & - damage_drivingforce_ID - end enum + character(len=64), dimension(:,:), allocatable, target, public :: & + source_damage_anisoBrittle_output !< name of each post result output + + integer, dimension(:,:), allocatable :: & + source_damage_anisoBrittle_Ncleavage !< number of cleavage systems per family + + enum, bind(c) + enumerator :: undefined_ID, & + damage_drivingforce_ID + end enum - type, private :: tParameters !< container type for internal constitutive parameters - real(pReal) :: & - aTol, & - sdot_0, & - N - real(pReal), dimension(:), allocatable :: & - critDisp, & - critLoad - real(pReal), dimension(:,:,:,:), allocatable :: & - cleavage_systems - integer :: & - totalNcleavage - integer, dimension(:), allocatable :: & - Ncleavage - integer(kind(undefined_ID)), allocatable, dimension(:) :: & - outputID !< ID of each post result output - end type tParameters + type :: tParameters !< container type for internal constitutive parameters + real(pReal) :: & + aTol, & + sdot_0, & + N + real(pReal), dimension(:), allocatable :: & + critDisp, & + critLoad + real(pReal), dimension(:,:,:,:), allocatable :: & + cleavage_systems + integer :: & + totalNcleavage + integer, dimension(:), allocatable :: & + Ncleavage + integer(kind(undefined_ID)), allocatable, dimension(:) :: & + outputID !< ID of each post result output + end type tParameters - type(tParameters), dimension(:), allocatable, private :: param !< containers of constitutive parameters (len Ninstance) + type(tParameters), dimension(:), allocatable :: param !< containers of constitutive parameters (len Ninstance) - public :: & - source_damage_anisoBrittle_init, & - source_damage_anisoBrittle_dotState, & - source_damage_anisobrittle_getRateAndItsTangent, & - source_damage_anisoBrittle_postResults + public :: & + source_damage_anisoBrittle_init, & + source_damage_anisoBrittle_dotState, & + source_damage_anisobrittle_getRateAndItsTangent, & + source_damage_anisoBrittle_postResults contains @@ -63,266 +70,230 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine source_damage_anisoBrittle_init - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use IO, only: & - IO_error - use math, only: & - math_expand - use material, only: & - material_allocateSourceState, & - phase_source, & - phase_Nsources, & - phase_Noutput, & - SOURCE_damage_anisoBrittle_label, & - SOURCE_damage_anisoBrittle_ID, & - material_phase, & - sourceState - use config, only: & - config_phase, & - material_Nphase - use lattice, only: & - lattice_SchmidMatrix_cleavage, & - lattice_maxNcleavageFamily - integer :: Ninstance,phase,instance,source,sourceOffset - integer :: NofMyPhase,p ,i - integer, dimension(0), parameter :: emptyIntArray = [integer::] - character(len=65536), dimension(0), parameter :: emptyStringArray = [character(len=65536)::] - integer(kind(undefined_ID)) :: & - outputID + integer :: Ninstance,phase,instance,source,sourceOffset + integer :: NofMyPhase,p ,i + integer, dimension(0), parameter :: emptyIntArray = [integer::] + character(len=65536), dimension(0), parameter :: emptyStringArray = [character(len=65536)::] + integer(kind(undefined_ID)) :: & + outputID - character(len=pStringLen) :: & - extmsg = '' - character(len=65536), dimension(:), allocatable :: & - outputs + character(len=pStringLen) :: & + extmsg = '' + character(len=65536), dimension(:), allocatable :: & + outputs - write(6,'(/,a)') ' <<<+- source_'//SOURCE_DAMAGE_ANISOBRITTLE_LABEL//' init -+>>>' + write(6,'(/,a)') ' <<<+- source_'//SOURCE_DAMAGE_ANISOBRITTLE_LABEL//' init -+>>>' - Ninstance = count(phase_source == SOURCE_damage_anisoBrittle_ID) - if (Ninstance == 0) return - - if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & - write(6,'(a16,1x,i5,/)') '# instances:',Ninstance - - allocate(source_damage_anisoBrittle_offset(material_Nphase), source=0) - allocate(source_damage_anisoBrittle_instance(material_Nphase), source=0) - do phase = 1, material_Nphase - source_damage_anisoBrittle_instance(phase) = count(phase_source(:,1:phase) == source_damage_anisoBrittle_ID) - do source = 1, phase_Nsources(phase) - if (phase_source(source,phase) == source_damage_anisoBrittle_ID) & - source_damage_anisoBrittle_offset(phase) = source - enddo - enddo - - allocate(source_damage_anisoBrittle_sizePostResult(maxval(phase_Noutput),Ninstance), source=0) - allocate(source_damage_anisoBrittle_output(maxval(phase_Noutput),Ninstance)) - source_damage_anisoBrittle_output = '' + Ninstance = count(phase_source == SOURCE_damage_anisoBrittle_ID) + if (Ninstance == 0) return + + if (iand(debug_level(debug_constitutive),debug_levelBasic) /= 0) & + write(6,'(a16,1x,i5,/)') '# instances:',Ninstance + + allocate(source_damage_anisoBrittle_offset(material_Nphase), source=0) + allocate(source_damage_anisoBrittle_instance(material_Nphase), source=0) + do phase = 1, material_Nphase + source_damage_anisoBrittle_instance(phase) = count(phase_source(:,1:phase) == source_damage_anisoBrittle_ID) + do source = 1, phase_Nsources(phase) + if (phase_source(source,phase) == source_damage_anisoBrittle_ID) & + source_damage_anisoBrittle_offset(phase) = source + enddo + enddo + + allocate(source_damage_anisoBrittle_sizePostResult(maxval(phase_Noutput),Ninstance), source=0) + allocate(source_damage_anisoBrittle_output(maxval(phase_Noutput),Ninstance)) + source_damage_anisoBrittle_output = '' - allocate(source_damage_anisoBrittle_Ncleavage(lattice_maxNcleavageFamily,Ninstance), source=0) + allocate(source_damage_anisoBrittle_Ncleavage(lattice_maxNcleavageFamily,Ninstance), source=0) - allocate(param(Ninstance)) - - do p=1, size(config_phase) - if (all(phase_source(:,p) /= SOURCE_DAMAGE_ANISOBRITTLE_ID)) cycle - associate(prm => param(source_damage_anisoBrittle_instance(p)), & - config => config_phase(p)) - - prm%aTol = config%getFloat('anisobrittle_atol',defaultVal = 1.0e-3_pReal) + allocate(param(Ninstance)) + + do p=1, size(config_phase) + if (all(phase_source(:,p) /= SOURCE_DAMAGE_ANISOBRITTLE_ID)) cycle + associate(prm => param(source_damage_anisoBrittle_instance(p)), & + config => config_phase(p)) + + prm%aTol = config%getFloat('anisobrittle_atol',defaultVal = 1.0e-3_pReal) - prm%N = config%getFloat('anisobrittle_ratesensitivity') - prm%sdot_0 = config%getFloat('anisobrittle_sdot0') - - ! sanity checks - if (prm%aTol < 0.0_pReal) extmsg = trim(extmsg)//' anisobrittle_atol' - - if (prm%N <= 0.0_pReal) extmsg = trim(extmsg)//' anisobrittle_ratesensitivity' - if (prm%sdot_0 <= 0.0_pReal) extmsg = trim(extmsg)//' anisobrittle_sdot0' - - prm%Ncleavage = config%getInts('ncleavage',defaultVal=emptyIntArray) + prm%N = config%getFloat('anisobrittle_ratesensitivity') + prm%sdot_0 = config%getFloat('anisobrittle_sdot0') + + ! sanity checks + if (prm%aTol < 0.0_pReal) extmsg = trim(extmsg)//' anisobrittle_atol' + + if (prm%N <= 0.0_pReal) extmsg = trim(extmsg)//' anisobrittle_ratesensitivity' + if (prm%sdot_0 <= 0.0_pReal) extmsg = trim(extmsg)//' anisobrittle_sdot0' + + prm%Ncleavage = config%getInts('ncleavage',defaultVal=emptyIntArray) - prm%critDisp = config%getFloats('anisobrittle_criticaldisplacement',requiredSize=size(prm%Ncleavage)) - prm%critLoad = config%getFloats('anisobrittle_criticalload', requiredSize=size(prm%Ncleavage)) - - prm%cleavage_systems = lattice_SchmidMatrix_cleavage (prm%Ncleavage,config%getString('lattice_structure'),& - config%getFloat('c/a',defaultVal=0.0_pReal)) + prm%critDisp = config%getFloats('anisobrittle_criticaldisplacement',requiredSize=size(prm%Ncleavage)) + prm%critLoad = config%getFloats('anisobrittle_criticalload', requiredSize=size(prm%Ncleavage)) + + prm%cleavage_systems = lattice_SchmidMatrix_cleavage (prm%Ncleavage,config%getString('lattice_structure'),& + config%getFloat('c/a',defaultVal=0.0_pReal)) - ! expand: family => system - prm%critDisp = math_expand(prm%critDisp, prm%Ncleavage) - prm%critLoad = math_expand(prm%critLoad, prm%Ncleavage) - - if (any(prm%critLoad < 0.0_pReal)) extmsg = trim(extmsg)//' anisobrittle_criticalload' - if (any(prm%critDisp < 0.0_pReal)) extmsg = trim(extmsg)//' anisobrittle_criticaldisplacement' + ! expand: family => system + prm%critDisp = math_expand(prm%critDisp, prm%Ncleavage) + prm%critLoad = math_expand(prm%critLoad, prm%Ncleavage) + + if (any(prm%critLoad < 0.0_pReal)) extmsg = trim(extmsg)//' anisobrittle_criticalload' + if (any(prm%critDisp < 0.0_pReal)) extmsg = trim(extmsg)//' anisobrittle_criticaldisplacement' !-------------------------------------------------------------------------------------------------- ! exit if any parameter is out of range - if (extmsg /= '') & - call IO_error(211,ext_msg=trim(extmsg)//'('//SOURCE_DAMAGE_ANISOBRITTLE_LABEL//')') + if (extmsg /= '') & + call IO_error(211,ext_msg=trim(extmsg)//'('//SOURCE_DAMAGE_ANISOBRITTLE_LABEL//')') !-------------------------------------------------------------------------------------------------- ! output pararameters - outputs = config%getStrings('(output)',defaultVal=emptyStringArray) - allocate(prm%outputID(0)) - do i=1, size(outputs) - outputID = undefined_ID - select case(outputs(i)) - - case ('anisobrittle_drivingforce') - source_damage_anisoBrittle_sizePostResult(i,source_damage_anisoBrittle_instance(p)) = 1 - source_damage_anisoBrittle_output(i,source_damage_anisoBrittle_instance(p)) = outputs(i) - prm%outputID = [prm%outputID, damage_drivingforce_ID] + outputs = config%getStrings('(output)',defaultVal=emptyStringArray) + allocate(prm%outputID(0)) + do i=1, size(outputs) + outputID = undefined_ID + select case(outputs(i)) + + case ('anisobrittle_drivingforce') + source_damage_anisoBrittle_sizePostResult(i,source_damage_anisoBrittle_instance(p)) = 1 + source_damage_anisoBrittle_output(i,source_damage_anisoBrittle_instance(p)) = outputs(i) + prm%outputID = [prm%outputID, damage_drivingforce_ID] - end select + end select - enddo + enddo - end associate - - phase = p - NofMyPhase=count(material_phase==phase) - instance = source_damage_anisoBrittle_instance(phase) - sourceOffset = source_damage_anisoBrittle_offset(phase) + end associate + + phase = p + NofMyPhase=count(material_phase==phase) + instance = source_damage_anisoBrittle_instance(phase) + sourceOffset = source_damage_anisoBrittle_offset(phase) - call material_allocateSourceState(phase,sourceOffset,NofMyPhase,1,1,0) - sourceState(phase)%p(sourceOffset)%sizePostResults = sum(source_damage_anisoBrittle_sizePostResult(:,instance)) - sourceState(phase)%p(sourceOffset)%aTolState=param(instance)%aTol + call material_allocateSourceState(phase,sourceOffset,NofMyPhase,1,1,0) + sourceState(phase)%p(sourceOffset)%sizePostResults = sum(source_damage_anisoBrittle_sizePostResult(:,instance)) + sourceState(phase)%p(sourceOffset)%aTolState=param(instance)%aTol - source_damage_anisoBrittle_Ncleavage(1:size(param(instance)%Ncleavage),instance) = param(instance)%Ncleavage - enddo + source_damage_anisoBrittle_Ncleavage(1:size(param(instance)%Ncleavage),instance) = param(instance)%Ncleavage + enddo - end subroutine source_damage_anisoBrittle_init + !-------------------------------------------------------------------------------------------------- !> @brief calculates derived quantities from state !-------------------------------------------------------------------------------------------------- subroutine source_damage_anisoBrittle_dotState(S, ipc, ip, el) - use math, only: & - math_mul33xx33 - use material, only: & - phaseAt, phasememberAt, & - sourceState, & - material_homogenizationAt, & - damage, & - damageMapping - use lattice, only: & - lattice_Scleavage, & - lattice_maxNcleavageFamily, & - lattice_NcleavageSystem - integer, intent(in) :: & - ipc, & !< component-ID of integration point - ip, & !< integration point - el !< element - real(pReal), intent(in), dimension(3,3) :: & - S - integer :: & - phase, & - constituent, & - instance, & - sourceOffset, & - damageOffset, & - homog, & - f, i, index_myFamily, index - real(pReal) :: & - traction_d, traction_t, traction_n, traction_crit + integer, intent(in) :: & + ipc, & !< component-ID of integration point + ip, & !< integration point + el !< element + real(pReal), intent(in), dimension(3,3) :: & + S + integer :: & + phase, & + constituent, & + instance, & + sourceOffset, & + damageOffset, & + homog, & + f, i, index_myFamily, index + real(pReal) :: & + traction_d, traction_t, traction_n, traction_crit - phase = phaseAt(ipc,ip,el) - constituent = phasememberAt(ipc,ip,el) - instance = source_damage_anisoBrittle_instance(phase) - sourceOffset = source_damage_anisoBrittle_offset(phase) - homog = material_homogenizationAt(el) - damageOffset = damageMapping(homog)%p(ip,el) - - sourceState(phase)%p(sourceOffset)%dotState(1,constituent) = 0.0_pReal - - index = 1 - do f = 1,lattice_maxNcleavageFamily - index_myFamily = sum(lattice_NcleavageSystem(1:f-1,phase)) ! at which index starts my family - do i = 1,source_damage_anisoBrittle_Ncleavage(f,instance) ! process each (active) cleavage system in family + phase = phaseAt(ipc,ip,el) + constituent = phasememberAt(ipc,ip,el) + instance = source_damage_anisoBrittle_instance(phase) + sourceOffset = source_damage_anisoBrittle_offset(phase) + homog = material_homogenizationAt(el) + damageOffset = damageMapping(homog)%p(ip,el) + + sourceState(phase)%p(sourceOffset)%dotState(1,constituent) = 0.0_pReal + + index = 1 + do f = 1,lattice_maxNcleavageFamily + index_myFamily = sum(lattice_NcleavageSystem(1:f-1,phase)) ! at which index starts my family + do i = 1,source_damage_anisoBrittle_Ncleavage(f,instance) ! process each (active) cleavage system in family - traction_d = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,1,index_myFamily+i,phase)) - traction_t = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,2,index_myFamily+i,phase)) - traction_n = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,3,index_myFamily+i,phase)) - - traction_crit = param(instance)%critLoad(index)* & - damage(homog)%p(damageOffset)*damage(homog)%p(damageOffset) + traction_d = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,1,index_myFamily+i,phase)) + traction_t = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,2,index_myFamily+i,phase)) + traction_n = math_mul33xx33(S,lattice_Scleavage(1:3,1:3,3,index_myFamily+i,phase)) + + traction_crit = param(instance)%critLoad(index)* & + damage(homog)%p(damageOffset)*damage(homog)%p(damageOffset) - sourceState(phase)%p(sourceOffset)%dotState(1,constituent) = & - sourceState(phase)%p(sourceOffset)%dotState(1,constituent) + & - param(instance)%sdot_0* & - ((max(0.0_pReal, abs(traction_d) - traction_crit)/traction_crit)**param(instance)%N + & - (max(0.0_pReal, abs(traction_t) - traction_crit)/traction_crit)**param(instance)%N + & - (max(0.0_pReal, abs(traction_n) - traction_crit)/traction_crit)**param(instance)%N)/ & - param(instance)%critDisp(index) + sourceState(phase)%p(sourceOffset)%dotState(1,constituent) = & + sourceState(phase)%p(sourceOffset)%dotState(1,constituent) + & + param(instance)%sdot_0* & + ((max(0.0_pReal, abs(traction_d) - traction_crit)/traction_crit)**param(instance)%N + & + (max(0.0_pReal, abs(traction_t) - traction_crit)/traction_crit)**param(instance)%N + & + (max(0.0_pReal, abs(traction_n) - traction_crit)/traction_crit)**param(instance)%N)/ & + param(instance)%critDisp(index) - index = index + 1 - enddo - enddo + index = index + 1 + enddo + enddo end subroutine source_damage_anisoBrittle_dotState + !-------------------------------------------------------------------------------------------------- !> @brief returns local part of nonlocal damage driving force !-------------------------------------------------------------------------------------------------- subroutine source_damage_anisobrittle_getRateAndItsTangent(localphiDot, dLocalphiDot_dPhi, phi, phase, constituent) - use material, only: & - sourceState - integer, intent(in) :: & - phase, & - constituent - real(pReal), intent(in) :: & - phi - real(pReal), intent(out) :: & - localphiDot, & - dLocalphiDot_dPhi - integer :: & - sourceOffset + integer, intent(in) :: & + phase, & + constituent + real(pReal), intent(in) :: & + phi + real(pReal), intent(out) :: & + localphiDot, & + dLocalphiDot_dPhi + integer :: & + sourceOffset - sourceOffset = source_damage_anisoBrittle_offset(phase) - - localphiDot = 1.0_pReal & - - sourceState(phase)%p(sourceOffset)%state(1,constituent)*phi - - dLocalphiDot_dPhi = -sourceState(phase)%p(sourceOffset)%state(1,constituent) + sourceOffset = source_damage_anisoBrittle_offset(phase) + + localphiDot = 1.0_pReal & + - sourceState(phase)%p(sourceOffset)%state(1,constituent)*phi + + dLocalphiDot_dPhi = -sourceState(phase)%p(sourceOffset)%state(1,constituent) end subroutine source_damage_anisobrittle_getRateAndItsTangent - + + !-------------------------------------------------------------------------------------------------- !> @brief return array of local damage results !-------------------------------------------------------------------------------------------------- function source_damage_anisoBrittle_postResults(phase, constituent) - use material, only: & - sourceState - integer, intent(in) :: & - phase, & - constituent - real(pReal), dimension(sum(source_damage_anisoBrittle_sizePostResult(:, & - source_damage_anisoBrittle_instance(phase)))) :: & - source_damage_anisoBrittle_postResults + integer, intent(in) :: & + phase, & + constituent - integer :: & - instance, sourceOffset, o, c - - instance = source_damage_anisoBrittle_instance(phase) - sourceOffset = source_damage_anisoBrittle_offset(phase) + real(pReal), dimension(sum(source_damage_anisoBrittle_sizePostResult(:, & + source_damage_anisoBrittle_instance(phase)))) :: & + source_damage_anisoBrittle_postResults - c = 0 + integer :: & + instance, sourceOffset, o, c + + instance = source_damage_anisoBrittle_instance(phase) + sourceOffset = source_damage_anisoBrittle_offset(phase) - do o = 1,size(param(instance)%outputID) - select case(param(instance)%outputID(o)) - case (damage_drivingforce_ID) - source_damage_anisoBrittle_postResults(c+1) = & - sourceState(phase)%p(sourceOffset)%state(1,constituent) - c = c + 1 + c = 0 - end select - enddo + do o = 1,size(param(instance)%outputID) + select case(param(instance)%outputID(o)) + case (damage_drivingforce_ID) + source_damage_anisoBrittle_postResults(c+1) = & + sourceState(phase)%p(sourceOffset)%state(1,constituent) + c = c + 1 + + end select + enddo end function source_damage_anisoBrittle_postResults end module source_damage_anisoBrittle diff --git a/src/source_thermal_dissipation.f90 b/src/source_thermal_dissipation.f90 index 94452eb47..e8464edd0 100644 --- a/src/source_thermal_dissipation.f90 +++ b/src/source_thermal_dissipation.f90 @@ -5,27 +5,30 @@ !> @details to be done !-------------------------------------------------------------------------------------------------- module source_thermal_dissipation - use prec, only: & - pReal + use prec + use debug + use material + use config implicit none private + integer, dimension(:), allocatable, public, protected :: & - source_thermal_dissipation_offset, & !< which source is my current thermal dissipation mechanism? - source_thermal_dissipation_instance !< instance of thermal dissipation source mechanism + source_thermal_dissipation_offset, & !< which source is my current thermal dissipation mechanism? + source_thermal_dissipation_instance !< instance of thermal dissipation source mechanism integer, dimension(:,:), allocatable, target, public :: & - source_thermal_dissipation_sizePostResult !< size of each post result output + source_thermal_dissipation_sizePostResult !< size of each post result output character(len=64), dimension(:,:), allocatable, target, public :: & - source_thermal_dissipation_output !< name of each post result output + source_thermal_dissipation_output !< name of each post result output - type, private :: tParameters !< container type for internal constitutive parameters + type :: tParameters !< container type for internal constitutive parameters real(pReal) :: & kappa end type tParameters - type(tParameters), dimension(:), allocatable, private :: param !< containers of constitutive parameters (len Ninstance) + type(tParameters), dimension(:), allocatable :: param !< containers of constitutive parameters (len Ninstance) public :: & @@ -40,21 +43,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine source_thermal_dissipation_init - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use material, only: & - material_allocateSourceState, & - phase_source, & - phase_Nsources, & - phase_Noutput, & - SOURCE_thermal_dissipation_label, & - SOURCE_thermal_dissipation_ID, & - material_phase - use config, only: & - config_phase, & - material_Nphase integer :: Ninstance,instance,source,sourceOffset integer :: NofMyPhase,p diff --git a/src/source_thermal_externalheat.f90 b/src/source_thermal_externalheat.f90 index 699902ad3..99d9a6f1f 100644 --- a/src/source_thermal_externalheat.f90 +++ b/src/source_thermal_externalheat.f90 @@ -5,11 +5,14 @@ !> @brief material subroutine for variable heat source !-------------------------------------------------------------------------------------------------- module source_thermal_externalheat - use prec, only: & - pReal + use prec + use debug + use material + use config implicit none private + integer, dimension(:), allocatable, public, protected :: & source_thermal_externalheat_offset, & !< which source is my current thermal dissipation mechanism? source_thermal_externalheat_instance !< instance of thermal dissipation source mechanism @@ -23,7 +26,7 @@ module source_thermal_externalheat integer, dimension(:), allocatable, target, public :: & source_thermal_externalheat_Noutput !< number of outputs per instance of this source - type, private :: tParameters !< container type for internal constitutive parameters + type :: tParameters !< container type for internal constitutive parameters real(pReal), dimension(:), allocatable :: & time, & heat_rate @@ -31,7 +34,7 @@ module source_thermal_externalheat nIntervals end type tParameters - type(tParameters), dimension(:), allocatable, private :: param !< containers of constitutive parameters (len Ninstance) + type(tParameters), dimension(:), allocatable :: param !< containers of constitutive parameters (len Ninstance) public :: & @@ -47,22 +50,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine source_thermal_externalheat_init - use debug, only: & - debug_level,& - debug_constitutive,& - debug_levelBasic - use material, only: & - material_allocateSourceState, & - material_phase, & - phase_source, & - phase_Nsources, & - phase_Noutput, & - SOURCE_thermal_externalheat_label, & - SOURCE_thermal_externalheat_ID - use config, only: & - config_phase, & - material_Nphase - integer :: maxNinstance,instance,source,sourceOffset,NofMyPhase,p @@ -116,8 +103,6 @@ end subroutine source_thermal_externalheat_init !> @details state only contains current time to linearly interpolate given heat powers !-------------------------------------------------------------------------------------------------- subroutine source_thermal_externalheat_dotState(phase, of) - use material, only: & - sourceState integer, intent(in) :: & phase, & @@ -135,8 +120,6 @@ end subroutine source_thermal_externalheat_dotState !> @brief returns local heat generation rate !-------------------------------------------------------------------------------------------------- subroutine source_thermal_externalheat_getRateAndItsTangent(TDot, dTDot_dT, phase, of) - use material, only: & - sourceState integer, intent(in) :: & phase, & diff --git a/src/thermal_adiabatic.f90 b/src/thermal_adiabatic.f90 index bfd5633d1..3c9fd0c6e 100644 --- a/src/thermal_adiabatic.f90 +++ b/src/thermal_adiabatic.f90 @@ -3,9 +3,16 @@ !> @brief material subroutine for adiabatic temperature evolution !-------------------------------------------------------------------------------------------------- module thermal_adiabatic - use prec, only: & - pReal - + use prec + use config + use numerics + use material + use source_thermal_dissipation + use source_thermal_externalheat + use crystallite + use lattice + use mesh + implicit none private @@ -21,7 +28,7 @@ module thermal_adiabatic enumerator :: undefined_ID, & temperature_ID end enum - integer(kind(undefined_ID)), dimension(:,:), allocatable, private :: & + integer(kind(undefined_ID)), dimension(:,:), allocatable :: & thermal_adiabatic_outputID !< ID of each post result output @@ -41,21 +48,6 @@ contains !> @details reads in material parameters, allocates arrays, and does sanity checks !-------------------------------------------------------------------------------------------------- subroutine thermal_adiabatic_init - use material, only: & - thermal_type, & - thermal_typeInstance, & - homogenization_Noutput, & - THERMAL_ADIABATIC_label, & - THERMAL_adiabatic_ID, & - material_homogenizationAt, & - mappingHomogenization, & - thermalState, & - thermalMapping, & - thermal_initialT, & - temperature, & - temperatureRate - use config, only: & - config_homogenization integer :: maxNinstance,section,instance,i,sizeState,NofMyHomog character(len=65536), dimension(0), parameter :: emptyStringArray = [character(len=65536)::] @@ -112,16 +104,6 @@ end subroutine thermal_adiabatic_init !> @brief calculates adiabatic change in temperature based on local heat generation model !-------------------------------------------------------------------------------------------------- function thermal_adiabatic_updateState(subdt, ip, el) - use numerics, only: & - err_thermal_tolAbs, & - err_thermal_tolRel - use material, only: & - material_homogenizationAt, & - mappingHomogenization, & - thermalState, & - temperature, & - temperatureRate, & - thermalMapping integer, intent(in) :: & ip, & !< integration point number @@ -156,27 +138,11 @@ function thermal_adiabatic_updateState(subdt, ip, el) end function thermal_adiabatic_updateState + !-------------------------------------------------------------------------------------------------- !> @brief returns heat generation rate !-------------------------------------------------------------------------------------------------- subroutine thermal_adiabatic_getSourceAndItsTangent(Tdot, dTdot_dT, T, ip, el) - use material, only: & - homogenization_Ngrains, & - material_homogenizationAt, & - phaseAt, & - phasememberAt, & - thermal_typeInstance, & - phase_Nsources, & - phase_source, & - SOURCE_thermal_dissipation_ID, & - SOURCE_thermal_externalheat_ID - use source_thermal_dissipation, only: & - source_thermal_dissipation_getRateAndItsTangent - use source_thermal_externalheat, only: & - source_thermal_externalheat_getRateAndItsTangent - use crystallite, only: & - crystallite_S, & - crystallite_Lp integer, intent(in) :: & ip, & !< integration point number @@ -229,18 +195,12 @@ subroutine thermal_adiabatic_getSourceAndItsTangent(Tdot, dTdot_dT, T, ip, el) dTdot_dT = dTdot_dT/real(homogenization_Ngrains(homog),pReal) end subroutine thermal_adiabatic_getSourceAndItsTangent - + + !-------------------------------------------------------------------------------------------------- !> @brief returns homogenized specific heat capacity !-------------------------------------------------------------------------------------------------- function thermal_adiabatic_getSpecificHeat(ip,el) - use lattice, only: & - lattice_specificHeat - use material, only: & - homogenization_Ngrains, & - material_phase - use mesh, only: & - mesh_element integer, intent(in) :: & ip, & !< integration point number @@ -269,13 +229,6 @@ end function thermal_adiabatic_getSpecificHeat !> @brief returns homogenized mass density !-------------------------------------------------------------------------------------------------- function thermal_adiabatic_getMassDensity(ip,el) - use lattice, only: & - lattice_massDensity - use material, only: & - homogenization_Ngrains, & - material_phase - use mesh, only: & - mesh_element integer, intent(in) :: & ip, & !< integration point number @@ -303,8 +256,6 @@ end function thermal_adiabatic_getMassDensity !> @brief return array of thermal results !-------------------------------------------------------------------------------------------------- function thermal_adiabatic_postResults(homog,instance,of) result(postResults) - use material, only: & - temperature integer, intent(in) :: & homog, & From 358272eb2ede29437b1371e76c6fcc822267e37f Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 28 May 2019 12:29:46 +0200 Subject: [PATCH 30/36] not needed, better readable without --- src/debug.f90 | 22 +++------------------- 1 file changed, 3 insertions(+), 19 deletions(-) diff --git a/src/debug.f90 b/src/debug.f90 index 4f9566c05..ff084b133 100644 --- a/src/debug.f90 +++ b/src/debug.f90 @@ -6,12 +6,12 @@ !> @brief Reading in and interpretating the debugging settings for the various modules !-------------------------------------------------------------------------------------------------- module debug - use prec, only: & - pInt, & - pReal + use prec + use IO implicit none private + integer(pInt), parameter, public :: & debug_LEVELSELECTIVE = 2_pInt**0_pInt, & debug_LEVELBASIC = 2_pInt**1_pInt, & @@ -78,19 +78,7 @@ contains !> @brief reads in parameters from debug.config and allocates arrays !-------------------------------------------------------------------------------------------------- subroutine debug_init - use prec, only: & - pStringLen - use IO, only: & - IO_read_ASCII, & - IO_error, & - IO_isBlank, & - IO_stringPos, & - IO_stringValue, & - IO_lc, & - IO_floatValue, & - IO_intValue - implicit none character(len=pStringLen), dimension(:), allocatable :: fileContent integer :: i, what, j @@ -253,8 +241,6 @@ end subroutine debug_init !-------------------------------------------------------------------------------------------------- subroutine debug_reset - implicit none - debug_stressMaxLocation = 0_pInt debug_stressMinLocation = 0_pInt debug_jacobianMaxLocation = 0_pInt @@ -272,8 +258,6 @@ end subroutine debug_reset !-------------------------------------------------------------------------------------------------- subroutine debug_info - implicit none - !$OMP CRITICAL (write2out) debugOutputCPFEM: if (iand(debug_level(debug_CPFEM),debug_LEVELBASIC) /= 0 & .and. any(debug_stressMinLocation /= 0_pInt) & From 43a50713b0c1cc981457b269f316983584f155e4 Mon Sep 17 00:00:00 2001 From: Test User Date: Thu, 30 May 2019 11:00:01 +0200 Subject: [PATCH 31/36] [skip ci] updated version information after successful test of v2.0.3-344-gb25c64d1 --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index d961b0f73..40e72919d 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-332-g5abcca50 +v2.0.3-344-gb25c64d1 From 8c38a2e56f1ec77c6f7b0f8d2e576393591e55d1 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Thu, 30 May 2019 17:39:49 +0200 Subject: [PATCH 32/36] include relaxation to nonlocal tests --- PRIVATE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PRIVATE b/PRIVATE index 3a2f89547..d31da38cf 160000 --- a/PRIVATE +++ b/PRIVATE @@ -1 +1 @@ -Subproject commit 3a2f89547c264044a7bfab9d33aee78eec495a76 +Subproject commit d31da38cf25734a91e994a3d5d33bb048eb2f44f From d4392dc1bdb875cdd50b77af8bcc7d000841af36 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Thu, 30 May 2019 23:58:59 +0200 Subject: [PATCH 33/36] one implicit none is enough --- src/grid/spectral_utilities.f90 | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/src/grid/spectral_utilities.f90 b/src/grid/spectral_utilities.f90 index 1d5e42070..f545eab4e 100644 --- a/src/grid/spectral_utilities.f90 +++ b/src/grid/spectral_utilities.f90 @@ -196,7 +196,6 @@ subroutine utilities_init grid3Offset, & geomSize - implicit none PetscErrorCode :: ierr integer :: i, j, k, & FFTW_planner_flag @@ -425,7 +424,6 @@ subroutine utilities_updateGamma(C,saveReference) math_det33, & math_invert2 - implicit none real(pReal), intent(in), dimension(3,3,3,3) :: C !< input stiffness to store as reference stiffness logical , intent(in) :: saveReference !< save reference stiffness to file for restart complex(pReal), dimension(3,3) :: temp33_complex, xiDyad_cmplx @@ -473,7 +471,6 @@ end subroutine utilities_updateGamma !> @details Does an unweighted filtered FFT transform from real to complex !-------------------------------------------------------------------------------------------------- subroutine utilities_FFTtensorForward - implicit none call fftw_mpi_execute_dft_r2c(planTensorForth,tensorField_real,tensorField_fourier) @@ -485,7 +482,6 @@ end subroutine utilities_FFTtensorForward !> @details Does an weighted inverse FFT transform from complex to real !-------------------------------------------------------------------------------------------------- subroutine utilities_FFTtensorBackward - implicit none call fftw_mpi_execute_dft_c2r(planTensorBack,tensorField_fourier,tensorField_real) tensorField_real = tensorField_real * wgt ! normalize the result by number of elements @@ -497,7 +493,6 @@ end subroutine utilities_FFTtensorBackward !> @details Does an unweighted filtered FFT transform from real to complex !-------------------------------------------------------------------------------------------------- subroutine utilities_FFTscalarForward - implicit none call fftw_mpi_execute_dft_r2c(planScalarForth,scalarField_real,scalarField_fourier) @@ -509,7 +504,6 @@ end subroutine utilities_FFTscalarForward !> @details Does an weighted inverse FFT transform from complex to real !-------------------------------------------------------------------------------------------------- subroutine utilities_FFTscalarBackward - implicit none call fftw_mpi_execute_dft_c2r(planScalarBack,scalarField_fourier,scalarField_real) scalarField_real = scalarField_real * wgt ! normalize the result by number of elements @@ -522,7 +516,6 @@ end subroutine utilities_FFTscalarBackward !> @details Does an unweighted filtered FFT transform from real to complex. !-------------------------------------------------------------------------------------------------- subroutine utilities_FFTvectorForward - implicit none call fftw_mpi_execute_dft_r2c(planVectorForth,vectorField_real,vectorField_fourier) @@ -534,7 +527,6 @@ end subroutine utilities_FFTvectorForward !> @details Does an weighted inverse FFT transform from complex to real !-------------------------------------------------------------------------------------------------- subroutine utilities_FFTvectorBackward - implicit none call fftw_mpi_execute_dft_c2r(planVectorBack,vectorField_fourier,vectorField_real) vectorField_real = vectorField_real * wgt ! normalize the result by number of elements @@ -554,7 +546,6 @@ subroutine utilities_fourierGammaConvolution(fieldAim) grid, & grid3Offset - implicit none real(pReal), intent(in), dimension(3,3) :: fieldAim !< desired average value of the field after convolution complex(pReal), dimension(3,3) :: temp33_complex, xiDyad_cmplx real(pReal), dimension(6,6) :: A, A_inv @@ -615,7 +606,6 @@ subroutine utilities_fourierGreenConvolution(D_ref, mobility_ref, deltaT) grid, & grid3 - implicit none real(pReal), dimension(3,3), intent(in) :: D_ref real(pReal), intent(in) :: mobility_ref, deltaT complex(pReal) :: GreenOp_hat @@ -644,7 +634,6 @@ real(pReal) function utilities_divergenceRMS() grid, & grid3 - implicit none integer :: i, j, k, ierr complex(pReal), dimension(3) :: rescaledGeom @@ -694,7 +683,6 @@ real(pReal) function utilities_curlRMS() grid, & grid3 - implicit none integer :: i, j, k, l, ierr complex(pReal), dimension(3,3) :: curl_fourier complex(pReal), dimension(3) :: rescaledGeom @@ -766,7 +754,6 @@ function utilities_maskedCompliance(rot_BC,mask_stress,C) math_rotate_forward33, & math_invert2 - implicit none real(pReal), dimension(3,3,3,3) :: utilities_maskedCompliance !< masked compliance real(pReal), intent(in) , dimension(3,3,3,3) :: C !< current average stiffness real(pReal), intent(in) , dimension(3,3) :: rot_BC !< rotation of load frame @@ -861,7 +848,6 @@ subroutine utilities_fourierScalarGradient() grid3, & grid - implicit none integer :: i, j, k vectorField_fourier = cmplx(0.0_pReal,0.0_pReal,pReal) @@ -879,7 +865,6 @@ subroutine utilities_fourierVectorDivergence() grid3, & grid - implicit none integer :: i, j, k scalarField_fourier = cmplx(0.0_pReal,0.0_pReal,pReal) @@ -898,7 +883,6 @@ subroutine utilities_fourierVectorGradient() grid3, & grid - implicit none integer :: i, j, k, m, n tensorField_fourier = cmplx(0.0_pReal,0.0_pReal,pReal) @@ -919,7 +903,6 @@ subroutine utilities_fourierTensorDivergence() grid3, & grid - implicit none integer :: i, j, k, m, n vectorField_fourier = cmplx(0.0_pReal,0.0_pReal,pReal) @@ -954,7 +937,6 @@ subroutine utilities_constitutiveResponse(P,P_av,C_volAvg,C_minmaxAvg,& materialpoint_dPdF, & materialpoint_stressAndItsTangent - implicit none real(pReal),intent(out), dimension(3,3,3,3) :: C_volAvg, C_minmaxAvg !< average stiffness real(pReal),intent(out), dimension(3,3) :: P_av !< average PK stress real(pReal),intent(out), dimension(3,3,grid(1),grid(2),grid3) :: P !< PK stress @@ -1032,7 +1014,6 @@ pure function utilities_calculateRate(heterogeneous,field0,field,dt,avRate) grid3, & grid - implicit none real(pReal), intent(in), dimension(3,3) :: & avRate !< homogeneous addon real(pReal), intent(in) :: & @@ -1063,7 +1044,6 @@ function utilities_forwardField(timeinc,field_lastInc,rate,aim) grid3, & grid - implicit none real(pReal), intent(in) :: & timeinc !< timeinc of current step real(pReal), intent(in), dimension(3,3,grid(1),grid(2),grid3) :: & @@ -1100,7 +1080,6 @@ pure function utilities_getFreqDerivative(k_s) geomSize, & grid - implicit none integer, intent(in), dimension(3) :: k_s !< indices of frequency complex(pReal), dimension(3) :: utilities_getFreqDerivative @@ -1158,7 +1137,6 @@ subroutine utilities_updateIPcoords(F) grid3Offset, & geomSize, & mesh_ipCoordinates - implicit none real(pReal), dimension(3,3,grid(1),grid(2),grid3), intent(in) :: F integer :: i, j, k, m, ierr From 45efa9cc91c65926394a0724aa2872820b45a362 Mon Sep 17 00:00:00 2001 From: Test User Date: Fri, 31 May 2019 05:47:53 +0200 Subject: [PATCH 34/36] [skip ci] updated version information after successful test of v2.0.3-350-g8c38a2e5 --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 40e72919d..483423ba0 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-344-gb25c64d1 +v2.0.3-350-g8c38a2e5 From 30826c5c8666d5c50d1e42d1304a51c64b1ef258 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Fri, 31 May 2019 09:05:58 +0200 Subject: [PATCH 35/36] not supported anymore is part of the geometry --- examples/SpectralMethod/Polycrystal/material.config | 1 - 1 file changed, 1 deletion(-) diff --git a/examples/SpectralMethod/Polycrystal/material.config b/examples/SpectralMethod/Polycrystal/material.config index 71d7e07d7..8103e7128 100644 --- a/examples/SpectralMethod/Polycrystal/material.config +++ b/examples/SpectralMethod/Polycrystal/material.config @@ -11,7 +11,6 @@ mech none [almostAll] (output) phase (output) texture -(output) volume (output) orientation # quaternion (output) grainrotation # deviation from initial orientation as axis (1-3) and angle in degree (4) (output) f # deformation gradient tensor; synonyms: "defgrad" From 236b5c8bde2aa7a7e34ca4da592ac527b6050c92 Mon Sep 17 00:00:00 2001 From: Test User Date: Fri, 31 May 2019 15:40:17 +0200 Subject: [PATCH 36/36] [skip ci] updated version information after successful test of v2.0.3-367-g70428155 --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 483423ba0..4e8921669 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -v2.0.3-350-g8c38a2e5 +v2.0.3-367-g70428155