clear separation between solver and DAMASK

src/CPFEM.f90

@@ -86,7 +86,6 @@ subroutine CPFEM_initAll(el,ip)
      call config_init
      call math_init
      call rotations_init
-     call FE_init
      call HDF5_utilities_init
      call results_init
      call mesh_init(ip, el)

src/DAMASK_marc.f90

@@ -41,6 +41,7 @@ module DAMASK_interface
   implicit none
   private
 
+  logical,                     public :: symmetricSolver 
   character(len=*), parameter, public :: INPUTFILEEXTENSION = '.dat'
   
   public :: &
@@ -88,6 +89,7 @@ subroutine DAMASK_interface_init
     write(6,'(a20,a,a16)') ' working directory "',trim(wd),'" does not exist'
     call quit(1)
   endif
+  symmetricSolver = solverIsSymmetric()
 
 end subroutine DAMASK_interface_init
 
@@ -110,6 +112,53 @@ function getSolverJobName()
 end function getSolverJobName
 
 
+!--------------------------------------------------------------------------------------------------
+!> @brief determines whether a symmetric solver is used
+!--------------------------------------------------------------------------------------------------
+logical function solverIsSymmetric()
+
+  character(len=pStringLen) :: line
+  integer :: myStat,fileUnit,s,e
+  integer, allocatable, dimension(:) :: chunkPos
+
+  open(newunit=fileUnit, file=getSolverJobName()//INPUTFILEEXTENSION, &
+       status='old', position='rewind', action='read',iostat=myStat)
+  do
+    read (fileUnit,'(A)',END=100) line
+    if(index(trim(lc(line)),'solver') == 1) then
+      read (fileUnit,'(A)',END=100) line                                                            ! next line
+        s =     verify(line,      ' ')                                                              ! start of first chunk
+        s = s + verify(line(s+1:),' ')                                                              ! start of second chunk
+        e = s + scan  (line(s+1:),' ')                                                              ! end of second chunk
+      solverIsSymmetric = line(s:e) /= '1'
+    endif
+  enddo
+100 close(fileUnit)
+  contains
+
+  !--------------------------------------------------------------------------------------------------
+  !> @brief changes characters in string to lower case
+  !> @details copied from IO_lc
+  !--------------------------------------------------------------------------------------------------
+  function lc(string)
+
+    character(len=*), intent(in) :: string                                                            !< string to convert
+    character(len=len(string))   :: lc
+
+    character(26), parameter :: LOWER = 'abcdefghijklmnopqrstuvwxyz'
+    character(26), parameter :: UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+    integer                  :: i,n
+
+    do i=1,len(string)
+      lc(i:i) = string(i:i)
+      n = index(UPPER,lc(i:i))
+      if (n/=0) lc(i:i) = LOWER(n:n)
+    enddo
+  end function lc
+
+end function solverIsSymmetric
+
 end module DAMASK_interface
 
 
@@ -128,6 +177,7 @@ subroutine hypela2(d,g,e,de,s,t,dt,ngens,m,nn,kcus,matus,ndi,nshear,disp, &
                    strechn1,eigvn1,ncrd,itel,ndeg,ndm,nnode, &
                    jtype,lclass,ifr,ifu)
  use prec
+ use DAMASK_interface
  use numerics
  use FEsolving
  use debug

src/FEsolving.f90

@@ -1,88 +1,24 @@
 !--------------------------------------------------------------------------------------------------
 !> @author Franz Roters, Max-Planck-Institut für Eisenforschung GmbH
-!> Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH
+!> @author Philip Eisenlohr, Max-Planck-Institut für Eisenforschung GmbH
-!> @brief holds some global variables and gets extra information for commercial FEM
+!> @brief global variables for flow control
 !--------------------------------------------------------------------------------------------------
 module FEsolving
   use prec
-  use DAMASK_interface
    
   implicit none
-  private
  
-  logical, public :: &
+  logical :: &
     terminallyIll     = .false.                                                                     !< at least one material point is terminally ill
 
-  integer, dimension(:,:), allocatable, public :: &
+  integer, dimension(:,:), allocatable :: &
     FEsolving_execIP                                                                                !< for ping-pong scheme always range to max IP, otherwise one specific IP
-  integer, dimension(2),                public :: &
+  integer, dimension(2)                :: &
     FEsolving_execElem                                                                              !< for ping-pong scheme always whole range, otherwise one specific element
     
 #if defined(Marc4DAMASK) || defined(Abaqus)
-  logical, public, protected :: & 
+  logical, dimension(:,:), allocatable :: &
-    symmetricSolver   = .false.                                                                     !< use a symmetric FEM solver
-  logical, dimension(:,:), allocatable, public :: &
     calcMode                                                                                        !< do calculation or simply collect when using ping pong scheme
-
-  public :: FE_init
 #endif
 
-contains
-
-#if defined(Marc4DAMASK) || defined(Abaqus)
-!--------------------------------------------------------------------------------------------------
-!> @brief determine whether a symmetric solver is used
-!--------------------------------------------------------------------------------------------------
-subroutine FE_init
-
-  write(6,'(/,a)')   ' <<<+-  FEsolving init  -+>>>'
-  
-#if defined(Marc4DAMASK)
-  block
-    character(len=pStringLen) :: line
-    integer :: myStat,fileUnit,s,e
-    integer, allocatable, dimension(:) :: chunkPos
-    open(newunit=fileUnit, file=getSolverJobName()//INPUTFILEEXTENSION, &
-         status='old', position='rewind', action='read',iostat=myStat)
-    do
-      read (fileUnit,'(A)',END=100) line
-      if(index(trim(lc(line)),'solver') == 1) then
-        read (fileUnit,'(A)',END=100) line                                                          ! next line
-          s =     verify(line,      ' ')                                                            ! start of first chunk
-          s = s + verify(line(s+1:),' ')                                                            ! start of second chunk
-          e = s + scan  (line(s+1:),' ')                                                            ! end of second chunk           
-        symmetricSolver = line(s:e) /= '1'
-      endif
-    enddo
-100 close(fileUnit)
-  end block
-  contains
-
-  !--------------------------------------------------------------------------------------------------
-  !> @brief changes characters in string to lower case
-  !> @details copied from IO_lc
-  !--------------------------------------------------------------------------------------------------
-  function lc(string)
-
-    character(len=*), intent(in) :: string                                                            !< string to convert
-    character(len=len(string))   :: lc
-
-    character(26), parameter :: LOWER = 'abcdefghijklmnopqrstuvwxyz'
-    character(26), parameter :: UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-    integer                  :: i,n
-
-    do i=1,len(string)
-      lc(i:i) = string(i:i)
-      n = index(UPPER,lc(i:i))
-      if (n/=0) lc(i:i) = LOWER(n:n)
-    enddo
-  end function lc
-
-#endif
-
-end subroutine FE_init
-#endif
-
-
 end module FEsolving