diff --git a/code/DAMASK_spectral_Driver.f90 b/code/DAMASK_spectral_Driver.f90 index 4ceadb829..030a75809 100644 --- a/code/DAMASK_spectral_Driver.f90 +++ b/code/DAMASK_spectral_Driver.f90 @@ -62,6 +62,7 @@ program DAMASK_spectral_Driver debugGeneral use DAMASK_spectral_SolverBasic + use DAMASK_spectral_SolverBasicPETSC use DAMASK_spectral_SolverAL implicit none @@ -276,6 +277,9 @@ program DAMASK_spectral_Driver case (DAMASK_spectral_SolverBasic_label) call basic_init() + case (DAMASK_spectral_SolverBasicPETSC_label) + call BasicPETSC_init() + case (DAMASK_spectral_SolverAL_label) call AL_init() @@ -359,6 +363,14 @@ program DAMASK_spectral_Driver temperature_bc = loadCases(currentLoadCase)%temperature, & rotation_BC = loadCases(currentLoadCase)%rotation) + case (DAMASK_spectral_SolverBasicPETSC_label) + solres = BasicPETSC_solution (& + guessmode,timeinc,timeinc_old, & + P_BC = loadCases(currentLoadCase)%P, & + F_BC = loadCases(currentLoadCase)%deformation, & + temperature_bc = loadCases(currentLoadCase)%temperature, & + rotation_BC = loadCases(currentLoadCase)%rotation) + case (DAMASK_spectral_SolverAL_label) solres = AL_solution (& guessmode,timeinc,timeinc_old, & @@ -396,6 +408,9 @@ program DAMASK_spectral_Driver case (DAMASK_spectral_SolverBasic_label) call basic_destroy() + case (DAMASK_spectral_SolverBasicPETSC_label) + call BasicPETSC_destroy() + case (DAMASK_spectral_SolverAL_label) call AL_destroy() diff --git a/code/DAMASK_spectral_SolverAL.f90 b/code/DAMASK_spectral_SolverAL.f90 index 68274fb4e..ff25ff2b6 100644 --- a/code/DAMASK_spectral_SolverAL.f90 +++ b/code/DAMASK_spectral_SolverAL.f90 @@ -182,7 +182,7 @@ module DAMASK_spectral_SolverAL close (777) call IO_read_jobBinaryFile(777,'convergedSpectralDefgradLambda_lastInc',& trim(getSolverJobName()),size(F_lambda_lastInc)) - read (777,rec=1) F_lastInc + read (777,rec=1) F_lambda_lastInc close (777) call IO_read_jobBinaryFile(777,'F_aim',trim(getSolverJobName()),size(F_aim)) read (777,rec=1) F_aim @@ -337,7 +337,7 @@ module DAMASK_spectral_SolverAL implicit none - integer(pInt) :: i,j,k,l, ctr + integer(pInt) :: i,j,k real(pReal), dimension(3,3) :: temp33_Real DMDALocalInfo :: in(DMDA_LOCAL_INFO_SIZE) @@ -385,15 +385,21 @@ module DAMASK_spectral_SolverAL residual_F(1:3,1:3,i,j,k) = temp33_Real field_real(i,j,k,1:3,1:3) = math_mul3333xx33(C_scale,F_lambda(1:3,1:3,i,j,k)-F(1:3,1:3,i,j,k)) enddo; enddo; enddo - + + !-------------------------------------------------------------------------------------------------- + ! doing Fourier transform call Utilities_forwardFFT() call Utilities_fourierConvolution(math_rotate_backward33(F_aim,params%rotation_BC)) call Utilities_backwardFFT() - + + !-------------------------------------------------------------------------------------------------- + ! constructing residual residual_F_lambda = F - reshape(field_real(1:res(1),1:res(2),1:res(3),1:3,1:3),& [3,3,res(1),res(2),res(3)],order=[3,4,5,1,2]) residual_F = residual_F - F_lambda + residual_F_lambda + !-------------------------------------------------------------------------------------------------- + ! calculating errors err_f = wgt*sqrt(sum(residual_F_lambda**2.0_pReal)) err_p = wgt*sqrt(sum((residual_F - residual_F_lambda)**2.0_pReal)) diff --git a/code/DAMASK_spectral_SolverBasicPETSC.f90 b/code/DAMASK_spectral_SolverBasicPETSC.f90 new file mode 100644 index 000000000..2f835ea8f --- /dev/null +++ b/code/DAMASK_spectral_SolverBasicPETSC.f90 @@ -0,0 +1,444 @@ +!-------------------------------------------------------------------------------------------------- +! $Id: DAMASK_spectral_SolverAL.f90 1654 2012-08-03 09:25:48Z MPIE\m.diehl $ +!-------------------------------------------------------------------------------------------------- +!> @author Pratheek Shanthraj, Max-Planck-Institut für Eisenforschung GmbH +!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH +!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH +!> @brief Basic scheme PETSc solver +!-------------------------------------------------------------------------------------------------- +module DAMASK_spectral_SolverBasicPETSC + + use, intrinsic :: iso_fortran_env ! to get compiler_version and compiler_options (at least for gfortran >4.6 at the moment) + + use prec, only: & + pInt, & + pReal + + use math, only: & + math_I3 + + use DAMASK_spectral_Utilities, only: & + solutionState + + implicit none +#ifdef PETSC +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif + + character (len=*), parameter, public :: & + DAMASK_spectral_SolverBasicPETSC_label = 'basicpetsc' + +!-------------------------------------------------------------------------------------------------- +! derived types + type solutionParams + real(pReal), dimension(3,3) :: P_BC, rotation_BC + real(pReal) :: timeinc + end type solutionParams + + type(solutionParams), private :: params + +!-------------------------------------------------------------------------------------------------- +! PETSc data + DM, private :: da + SNES, private :: snes + Vec, private :: solution_vec + +!-------------------------------------------------------------------------------------------------- +! common pointwise data + real(pReal), private, dimension(:,:,:,:,:), allocatable :: F_lastInc + real(pReal), private, dimension(:,:,:,:), allocatable :: coordinates + real(pReal), private, dimension(:,:,:), allocatable :: temperature + +!-------------------------------------------------------------------------------------------------- +! stress, stiffness and compliance average etc. + real(pReal), private, dimension(3,3) :: & + F_aim = math_I3, & + F_aim_lastInc = math_I3, & + P_av + + real(pReal), private, dimension(3,3,3,3) :: & + C = 0.0_pReal, & + S = 0.0_pReal + + real(pReal), private :: err_stress, err_div + logical, private :: ForwardData + real(pReal), private, dimension(3,3) :: mask_stress = 0.0_pReal + + contains + +!-------------------------------------------------------------------------------------------------- +!> @brief allocates all neccessary fields and fills them with data, potentially from restart info +!-------------------------------------------------------------------------------------------------- + subroutine BasicPETSC_init() + + use IO, only: & + IO_read_JobBinaryFile, & + IO_write_JobBinaryFile + + use FEsolving, only: & + restartInc + + use DAMASK_interface, only: & + getSolverJobName + + use DAMASK_spectral_Utilities, only: & + Utilities_init, & + Utilities_constitutiveResponse, & + Utilities_updateGamma, & + debugrestart + + use numerics, only: & + petsc_options + + use mesh, only: & + res, & + geomdim, & + mesh_NcpElems + + use math, only: & + math_invSym3333 + + implicit none + + integer(pInt) :: i,j,k + real(pReal), dimension(:,:,:,:,:), allocatable :: P + + PetscErrorCode :: ierr_psc + PetscObject :: dummy + PetscMPIInt :: rank + PetscScalar, pointer :: xx_psc(:,:,:,:), F(:,:,:,:) + + call Utilities_init() + + write(6,'(a)') '' + write(6,'(a)') ' <<<+- DAMASK_spectral_solverBasicPETSC init -+>>>' + write(6,'(a)') ' $Id: DAMASK_spectral_SolverBasicPETSC.f90 1654 2012-08-03 09:25:48Z MPIE\m.diehl $' +#include "compilation_info.f90" + write(6,'(a)') '' + + allocate (F_lastInc (3,3, res(1), res(2),res(3)), source = 0.0_pReal) + allocate (P (3,3, res(1), res(2),res(3)), source = 0.0_pReal) + allocate (coordinates( res(1), res(2),res(3),3), source = 0.0_pReal) + allocate (temperature( res(1), res(2),res(3)), source = 0.0_pReal) + + !-------------------------------------------------------------------------------------------------- + ! PETSc Init + call PetscInitialize(PETSC_NULL_CHARACTER,ierr_psc) + call MPI_Comm_rank(PETSC_COMM_WORLD,rank,ierr_psc) + call SNESCreate(PETSC_COMM_WORLD,snes,ierr_psc) + call DMDACreate3d(PETSC_COMM_WORLD, & + DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE, & + DMDA_STENCIL_BOX,res(1),res(2),res(3),PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE, & + 9,1,PETSC_NULL_INTEGER,PETSC_NULL_INTEGER,PETSC_NULL_INTEGER,da,ierr_psc) + + call DMCreateGlobalVector(da,solution_vec,ierr_psc) + call DMDASetLocalFunction(da,BasicPETSC_formResidual,ierr_psc) + call SNESSetDM(snes,da,ierr_psc) + call SNESSetConvergenceTest(snes,BasicPETSC_converged,dummy,PETSC_NULL_FUNCTION,ierr_psc) + call PetscOptionsInsertString(petsc_options,ierr_psc) + call SNESSetFromOptions(snes,ierr_psc) + + !-------------------------------------------------------------------------------------------------- + ! init fields + call DMDAVecGetArrayF90(da,solution_vec,xx_psc,ierr_psc) + F => xx_psc(0:8,:,:,:) + if (restartInc == 1_pInt) then ! no deformation (no restart) + F_lastInc = spread(spread(spread(math_I3,3,res(1)),4,res(2)),5,res(3)) ! initialize to identity + F = reshape(F_lastInc,[9,res(1),res(2),res(3)]) + do k = 1_pInt, res(3); do j = 1_pInt, res(2); do i = 1_pInt, res(1) + coordinates(i,j,k,1:3) = geomdim/real(res,pReal)*real([i,j,k],pReal) & + - geomdim/real(2_pInt*res,pReal) + enddo; enddo; enddo + elseif (restartInc > 1_pInt) then ! using old values from file + if (debugRestart) write(6,'(a,i6,a)') 'Reading values of increment ',& + restartInc - 1_pInt,' from file' + call IO_read_jobBinaryFile(777,'convergedSpectralDefgrad',& + trim(getSolverJobName()),size(F_lastInc)) + read (777,rec=1) F + close (777) + call IO_read_jobBinaryFile(777,'convergedSpectralDefgrad_lastInc',& + trim(getSolverJobName()),size(F_lastInc)) + read (777,rec=1) F_lastInc + close (777) + call IO_read_jobBinaryFile(777,'F_aim',trim(getSolverJobName()),size(F_aim)) + read (777,rec=1) F_aim + close (777) + call IO_read_jobBinaryFile(777,'F_aim_lastInc',trim(getSolverJobName()),size(F_aim_lastInc)) + read (777,rec=1) F_aim_lastInc + close (777) + + coordinates = 0.0 ! change it later!!! + endif + + call Utilities_constitutiveResponse(coordinates,F,F,temperature,0.0_pReal,P,C,P_av,.false.,math_I3) + call DMDAVecRestoreArrayF90(da,solution_vec,xx_psc,ierr_psc) + + !-------------------------------------------------------------------------------------------------- + ! reference stiffness + if (restartInc == 1_pInt) then + call IO_write_jobBinaryFile(777,'C_ref',size(C)) + write (777,rec=1) C + close(777) + elseif (restartInc > 1_pInt) then + call IO_read_jobBinaryFile(777,'C_ref',trim(getSolverJobName()),size(C)) + read (777,rec=1) C + close (777) + endif + + call Utilities_updateGamma(C) + + end subroutine BasicPETSC_init + +!-------------------------------------------------------------------------------------------------- +!> @brief solution for the Basic PETSC scheme with internal iterations +!-------------------------------------------------------------------------------------------------- + type(solutionState) function BasicPETSC_solution(guessmode,timeinc,timeinc_old,P_BC,F_BC,temperature_bc,rotation_BC) + + use numerics, only: & + update_gamma + use math, only: & + math_mul33x33 ,& + math_rotate_backward33, & + deformed_fft + use mesh, only: & + res,& + geomdim + use IO, only: & + IO_write_JobBinaryFile + + use DAMASK_spectral_Utilities, only: & + boundaryCondition, & + Utilities_forwardField, & + Utilities_maskedCompliance, & + Utilities_updateGamma + + use FEsolving, only: & + restartWrite + + implicit none +!-------------------------------------------------------------------------------------------------- +! input data for solution + real(pReal), intent(in) :: timeinc, timeinc_old, temperature_bc, guessmode + type(boundaryCondition), intent(in) :: P_BC,F_BC + real(pReal), dimension(3,3), intent(in) :: rotation_BC + real(pReal), dimension(3,3) :: deltaF_aim, & + F_aim_lab +!-------------------------------------------------------------------------------------------------- +! loop variables, convergence etc. + real(pReal), dimension(3,3) :: temp33_Real + +!-------------------------------------------------------------------------------------------------- +! + PetscScalar, pointer :: xx_psc(:,:,:,:), F(:,:,:,:) + PetscErrorCode ierr_psc + SNESConvergedReason reason + +!-------------------------------------------------------------------------------------------------- +! restart information for spectral solver + if (restartWrite) then + write(6,'(a)') 'writing converged results for restart' + call IO_write_jobBinaryFile(777,'convergedSpectralDefgrad',size(F_lastInc)) + write (777,rec=1) F_LastInc + close (777) + call IO_write_jobBinaryFile(777,'C',size(C)) + write (777,rec=1) C + close(777) + endif + BasicPETSC_solution%converged =.false. +!-------------------------------------------------------------------------------------------------- +! winding forward of deformation aim in loadcase system + if (F_BC%myType=='l') then ! calculate deltaF_aim from given L and current F + deltaF_aim = timeinc * F_BC%maskFloat * math_mul33x33(F_BC%values, F_aim) + elseif(F_BC%myType=='fdot') then ! deltaF_aim = fDot *timeinc where applicable + deltaF_aim = timeinc * F_BC%maskFloat * F_BC%values + endif + temp33_Real = F_aim + F_aim = F_aim & + + guessmode * P_BC%maskFloat * (F_aim - F_aim_lastInc)*timeinc/timeinc_old & + + deltaF_aim + F_aim_lastInc = temp33_Real + F_aim_lab = math_rotate_backward33(F_aim,rotation_BC) ! boundary conditions from load frame into lab (Fourier) frame + +!-------------------------------------------------------------------------------------------------- +! update local deformation gradient and coordinates + deltaF_aim = math_rotate_backward33(deltaF_aim,rotation_BC) + call DMDAVecGetArrayF90(da,solution_vec,xx_psc,ierr_psc) + F => xx_psc(0:8,:,:,:) + call Utilities_forwardField(deltaF_aim,timeinc,timeinc_old,guessmode,F_lastInc,F) + call DMDAVecRestoreArrayF90(da,solution_vec,xx_psc,ierr_psc) + call deformed_fft(res,geomdim,math_rotate_backward33(F_aim,rotation_BC),1.0_pReal,F_lastInc,coordinates) + +!-------------------------------------------------------------------------------------------------- +! update stiffness (and gamma operator) + S = Utilities_maskedCompliance(rotation_BC,P_BC%maskLogical,C) + if (update_gamma) call Utilities_updateGamma(C) + + ForwardData = .True. + mask_stress = P_BC%maskFloat + params%P_BC = P_BC%values + params%rotation_BC = rotation_BC + params%timeinc = timeinc + + call SNESSolve(snes,PETSC_NULL_OBJECT,solution_vec,ierr_psc) + call SNESGetConvergedReason(snes,reason,ierr_psc) + if (reason > 0 ) BasicPETSC_solution%converged = .true. + + end function BasicPETSC_solution + +!-------------------------------------------------------------------------------------------------- +!> @brief forms the AL residual vector +!-------------------------------------------------------------------------------------------------- + subroutine BasicPETSC_formResidual(in,x_scal,f_scal,dummy,ierr_psc) + + use numerics, only: & + itmax, & + itmin + use math, only: & + math_rotate_backward33, & + math_transpose33, & + math_mul3333xx33 + use mesh, only: & + res, & + wgt + use DAMASK_spectral_Utilities, only: & + field_real, & + Utilities_forwardFFT, & + Utilities_fourierConvolution, & + Utilities_backwardFFT, & + Utilities_constitutiveResponse, & + Utilities_divergenceRMS + + implicit none + + real(pReal), dimension(3,3) :: F_aim_lab_lastIter, F_aim_lab + + DMDALocalInfo :: in(DMDA_LOCAL_INFO_SIZE) + PetscScalar, target :: x_scal(3,3,XG_RANGE,YG_RANGE,ZG_RANGE) + PetscScalar, target :: f_scal(3,3,X_RANGE,Y_RANGE,Z_RANGE) + PetscScalar, pointer :: F(:,:,:,:,:) + PetscScalar, pointer :: residual_F(:,:,:,:,:) + PetscInt :: iter, nfuncs + PetscObject :: dummy + PetscErrorCode :: ierr_psc + + F => x_scal(:,:,:,:,:) + residual_F => f_scal(:,:,:,:,:) + + call SNESGetNumberFunctionEvals(snes,nfuncs,ierr_psc) + call SNESGetIterationNumber(snes,iter,ierr_psc) + + !-------------------------------------------------------------------------------------------------- + ! report begin of new iteration + write(6,'(a)') '' + write(6,'(a)') '==================================================================' + write(6,'(4(a,i6.6))') ' @ Iter. ',itmin,' < ',iter,' < ',itmax, ' | # Func. calls = ',nfuncs + write(6,'(a,/,3(3(f12.7,1x)/))',advance='no') 'deformation gradient aim =',& + math_transpose33(F_aim) + F_aim_lab_lastIter = math_rotate_backward33(F_aim,params%rotation_BC) + + !-------------------------------------------------------------------------------------------------- + ! evaluate constitutive response + call Utilities_constitutiveResponse(coordinates,F_lastInc,F,temperature,params%timeinc, & + residual_F,C,P_av,ForwardData,params%rotation_BC) + ForwardData = .False. + +!-------------------------------------------------------------------------------------------------- +! stress BC handling + F_aim = F_aim - math_mul3333xx33(S, ((P_av - params%P_BC))) ! S = 0.0 for no bc + err_stress = maxval(mask_stress * (P_av - params%P_BC)) ! mask = 0.0 for no bc + F_aim_lab = math_rotate_backward33(F_aim,params%rotation_BC) + +!-------------------------------------------------------------------------------------------------- +! updated deformation gradient using fix point algorithm of basic scheme + field_real = 0.0_pReal + field_real(1:res(1),1:res(2),1:res(3),1:3,1:3) = reshape(residual_F,[res(1),res(2),res(3),3,3],& + order=[4,5,1,2,3]) ! field real has a different order + call Utilities_forwardFFT() + err_div = Utilities_divergenceRMS() + call Utilities_fourierConvolution(F_aim_lab_lastIter - F_aim_lab) + call Utilities_backwardFFT() + + !-------------------------------------------------------------------------------------------------- + ! constructing residual + residual_F = reshape(field_real(1:res(1),1:res(2),1:res(3),1:3,1:3),shape(F),order=[3,4,5,1,2]) + + end subroutine BasicPETSC_formResidual + +!-------------------------------------------------------------------------------------------------- +!> @brief convergence check +!-------------------------------------------------------------------------------------------------- + subroutine BasicPETSC_converged(snes_local,it,xnorm,snorm,fnorm,reason,dummy,ierr_psc) + + use numerics, only: & + itmax, & + itmin, & + err_div_tol, & + err_stress_tolrel, & + err_stress_tolabs + + use math, only: & + math_mul33x33, & + math_eigenvalues33, & + math_transpose33 + + implicit none + + SNES snes_local + PetscInt it + PetscReal xnorm, snorm, fnorm + SNESConvergedReason reason + PetscObject dummy + PetscErrorCode ierr_psc + logical :: Converged + real(pReal) :: pAvgDivL2 + + pAvgDivL2 = sqrt(maxval(math_eigenvalues33(math_mul33x33(P_av,math_transpose33(P_av))))) + Converged = (it > itmin .and. & + all([ err_div/pAvgDivL2/err_div_tol, & + err_stress/min(maxval(abs(P_av))*err_stress_tolrel,err_stress_tolabs)] < 1.0_pReal)) + + if (Converged) then + reason = 1 + elseif (it > itmax) then + reason = -1 + else + reason = 0 + endif + + write(6,'(a,f6.2,a,es11.4,a)') 'error divergence = ', err_div/pAvgDivL2/err_div_tol,& + ' (',err_div/pAvgDivL2,' N/m³)' + write(6,'(a,f6.2,a,es11.4,a)') 'error stress = ', err_stress/min(maxval(abs(P_av))*err_stress_tolrel,err_stress_tolabs), & + ' (',err_stress,' Pa)' + return + + end subroutine BasicPETSC_converged + +!-------------------------------------------------------------------------------------------------- +!> @brief destroy routine +!-------------------------------------------------------------------------------------------------- + subroutine BasicPETSC_destroy() + + use DAMASK_spectral_Utilities, only: & + Utilities_destroy + implicit none + PetscErrorCode ierr_psc + + call VecDestroy(solution_vec,ierr_psc) + call SNESDestroy(snes,ierr_psc) + call DMDestroy(da,ierr_psc) + call PetscFinalize(ierr_psc) + call Utilities_destroy() + + end subroutine BasicPETSC_destroy + + end module DAMASK_spectral_SolverBasicPETSC diff --git a/code/DAMASK_spectral_Utilities.f90 b/code/DAMASK_spectral_Utilities.f90 index 8b3093d98..b0146ecfa 100644 --- a/code/DAMASK_spectral_Utilities.f90 +++ b/code/DAMASK_spectral_Utilities.f90 @@ -610,9 +610,9 @@ real(pReal) function Utilities_getFilter(k) Utilities_getFilter = 1.0_pReal case ('cosine') - Utilities_getFilter = 0.125_pReal*(1.0_pReal + cos(pi*k(3)*geomdim(3)/(res(3)/2_pInt + 1_pInt))) & - *(1.0_pReal + cos(pi*k(2)*geomdim(2)/(res(2)/2_pInt + 1_pInt))) & - *(1.0_pReal + cos(pi*k(1)*geomdim(1)/(res(1)/2_pInt + 1_pInt))) + Utilities_getFilter = (1.0_pReal + cos(pi*k(3)/res(3))) & + *(1.0_pReal + cos(pi*k(2)/res(2))) & + *(1.0_pReal + cos(pi*k(1)/res(1)))/8.0_pReal end select diff --git a/code/Makefile b/code/Makefile index a5e3fad64..ee5f009fa 100644 --- a/code/Makefile +++ b/code/Makefile @@ -279,14 +279,14 @@ COMPILED_FILES = prec.o DAMASK_spectral_interface.o IO.o numerics.o debug.o math homogenization_RGC.o homogenization_isostrain.o homogenization.o CPFEM.o ifeq "$(SOLVER)" "NEW" -COMPILED_FILES += DAMASK_spectral_Utilities.o DAMASK_spectral_SolverBasic.o DAMASK_spectral_SolverAL.o +COMPILED_FILES += DAMASK_spectral_Utilities.o DAMASK_spectral_SolverBasic.o DAMASK_spectral_SolverAL.o DAMASK_spectral_SolverBasicPETSC.o DAMASK_spectral.exe: DAMASK_spectral_Driver.o $(PREFIX) $(COMPILERNAME) $(OPENMP_FLAG_$(F90)) $(OPTIMIZATION_$(MAXOPTI)_$(F90)) $(STANDARD_CHECK_$(F90)) \ -o DAMASK_spectral.exe DAMASK_spectral_Driver.o \ $(COMPILED_FILES) $(LIB_DIRS) $(LIBRARIES) $(SUFFIX) -DAMASK_spectral_Driver.o: DAMASK_spectral_Driver.f90 DAMASK_spectral_SolverBasic.o DAMASK_spectral_SolverAL.o +DAMASK_spectral_Driver.o: DAMASK_spectral_Driver.f90 DAMASK_spectral_SolverBasic.o DAMASK_spectral_SolverAL.o DAMASK_spectral_SolverBasicPETSC.o $(PREFIX) $(COMPILERNAME) $(COMPILE_MAXOPTI) -c DAMASK_spectral_Driver.f90 $(SUFFIX) DAMASK_spectral_SolverAL.o: DAMASK_spectral_SolverAL.f90\ @@ -294,6 +294,9 @@ DAMASK_spectral_SolverAL.o: DAMASK_spectral_SolverAL.f90\ DAMASK_spectral_SolverBasic.o: DAMASK_spectral_SolverBasic.f90\ DAMASK_spectral_Utilities.o + +DAMASK_spectral_SolverBasicPETSC.o: DAMASK_spectral_SolverBasicPETSC.f90\ + DAMASK_spectral_Utilities.o DAMASK_spectral_Utilities.o: DAMASK_spectral_Utilities.f90\ CPFEM.o diff --git a/code/numerics.f90 b/code/numerics.f90 index 220d95f0d..589ed426c 100644 --- a/code/numerics.f90 +++ b/code/numerics.f90 @@ -261,7 +261,7 @@ subroutine numerics_init case ('myfilter') myfilter = IO_stringValue(line,positions,2_pInt) case ('petsc_options') - petsc_options = IO_stringValue(line,positions,2_pInt) + petsc_options = trim(line(positions(4):)) case ('rotation_tol') rotation_tol = IO_floatValue(line,positions,2_pInt) case ('divergence_correction')