LCOV - code coverage report
Current view: top level - wannier - wann_hopping.F (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 132 0.0 %
Date: 2019-09-08 04:53:50 Functions: 0 1 0.0 %

          Line data    Source code
       1             : !--------------------------------------------------------------------------------
       2             : ! Copyright (c) 2016 Peter Grünberg Institut, Forschungszentrum Jülich, Germany
       3             : ! This file is part of FLEUR and available as free software under the conditions
       4             : ! of the MIT license as expressed in the LICENSE file in more detail.
       5             : !--------------------------------------------------------------------------------
       6             : 
       7             :       module m_wann_hopping
       8             :       use m_juDFT
       9             :       contains 
      10           0 :       subroutine wann_hopping(
      11           0 :      >          rvecnum,rvec,kpoints,
      12             :      >          jspins_in,nkpts,l_bzsym,film,l_onedimens,
      13             :      >          l_soc,band_min,band_max,neigd,
      14           0 :      >          l_socmmn0,l_ndegen,ndegen,wan90version,
      15             :      >          l_unformatted)
      16             : c****************************************************
      17             : c     Calculate the hoppings using the information
      18             : c     in file WF1.chk produced by wannier90.
      19             : c
      20             : c     Frank Freimuth
      21             : c****************************************************
      22             :       use m_constants, only:pimach
      23             :       use m_wann_read_umatrix
      24             : c      use m_wann_get_mp
      25             : c      use m_wann_get_kpts
      26             : c      use m_wann_wigner_seitz
      27             : 
      28             :       implicit none
      29             :       integer, intent(in) :: rvecnum
      30             :       integer, intent(in) :: rvec(:,:)
      31             :       real,    intent(in) :: kpoints(:,:)
      32             :       integer, intent(in) :: jspins_in
      33             :       integer, intent(in) :: nkpts
      34             :       logical, intent(in) :: l_bzsym,l_soc
      35             :       logical, intent(in) :: film,l_onedimens
      36             :       integer, intent(in) :: band_min(2),band_max(2),neigd
      37             :       logical, intent(in) :: l_socmmn0
      38             :       logical, intent(in) :: l_ndegen
      39             :       integer, intent(in) :: ndegen(:)
      40             :       integer, intent(in) :: wan90version
      41             :       logical, intent(in) :: l_unformatted      
      42             : 
      43             :       integer             :: ikpt,jspins
      44             :       integer             :: kpts
      45             :       logical             :: l_file
      46             : c      real                :: kpoints(3,nkpts)
      47             :       integer             :: num_wann,num_kpts,num_nnmax,jspin
      48             :       integer             :: kspin,kkspin
      49             :       integer             :: wann_shift,num_wann2
      50             :       integer             :: i,j,k,m,info,r1,r2,r3,dummy1
      51             :       integer             :: dummy2,dummy3
      52             :       integer             :: counter,m1,m2
      53             :       integer             :: num_bands2
      54           0 :       integer,allocatable :: iwork(:)
      55           0 :       real,allocatable    :: energy(:,:),ei(:)
      56           0 :       real,allocatable    :: eigw(:,:),rwork(:)
      57           0 :       complex,allocatable :: work(:),vec(:,:)
      58           0 :       complex,allocatable :: u_matrix(:,:,:),hwann(:,:,:)
      59           0 :       complex,allocatable :: hreal(:,:,:)
      60           0 :       complex,allocatable :: hrealsoc(:,:,:,:,:)
      61           0 :       complex,allocatable :: hwannsoc(:,:,:,:,:)
      62           0 :       complex,allocatable :: mmn0(:,:,:,:)
      63             :       complex             :: fac,eulav,eulav1
      64             :       real                :: tmp_omi,rdotk,tpi,minenerg,maxenerg
      65             :       real, allocatable   :: minieni(:),maxieni(:)
      66             :       character           :: jobz,uplo
      67             :       integer             :: kpt,band,lee,lwork,lrwork,liwork,n,lda
      68             :       complex             :: value(4)
      69             :       logical             :: um_format
      70             :       logical             :: repro_eig
      71             :       logical             :: l_chk,l_proj
      72             :       logical             :: have_disentangled
      73           0 :       integer,allocatable :: ndimwin(:)
      74           0 :       logical,allocatable :: lwindow(:,:)
      75             :       integer             :: chk_unit,nkp,ntmp,ierr
      76             :       character(len=33)   :: header
      77             :       character(len=20)   :: checkpoint
      78             :       real                :: tmp_latt(3,3), tmp_kpt_latt(3,nkpts)
      79             :       real                :: omega_invariant
      80           0 :       complex,allocatable :: u_matrix_opt(:,:,:)
      81             :       integer             :: num_bands,num(3)
      82             :       logical             :: l_umdat
      83           0 :       real,allocatable    :: eigval2(:,:)
      84           0 :       real,allocatable    :: eigval_opt(:,:)
      85             :       real                :: scale,a,b
      86             :       character(len=2)    :: spinspin12(0:2)
      87             :       character(len=3)    :: spin12(2)
      88             :       character(len=6)    :: filename
      89             :       logical             :: l_socham
      90             : !      integer             :: hopmin_x,hopmin_y,hopmin_z
      91             : !      integer             :: hopmax_x,hopmax_y,hopmax_z
      92             :       integer             :: rvecind!,rvecnum
      93             : !      integer,allocatable :: rvec(:,:)
      94             :       integer             :: ii,int_dummy
      95             : 
      96             :       data spinspin12/'  ','.1' , '.2'/
      97             :       data spin12/'WF1','WF2'/
      98             : 
      99           0 :       um_format=.false.   !if you would like to get a formatted um_dat
     100           0 :       repro_eig=.false.   !if you would like to check unitarity of u_matrix
     101             : 
     102           0 :       tpi=2*pimach()
     103             : 
     104           0 :       jspins=jspins_in
     105           0 :       if(l_soc)jspins=1
     106           0 :       l_socham=.false.
     107             : 
     108           0 :       write(6,*)"nkpts=",nkpts
     109             : 
     110           0 :       do jspin=1,jspins  !spin loop
     111             : c*****************************************************
     112             : c     get num_bands and num_wann from the proj file
     113             : c*****************************************************
     114           0 :          do j=jspin,0,-1
     115           0 :           inquire(file=trim('proj'//spinspin12(j)),exist=l_file)
     116           0 :           if(l_file)then
     117           0 :             filename='proj'//spinspin12(j)
     118           0 :             exit
     119             :           endif
     120             :          enddo
     121           0 :          if(l_file)then
     122           0 :           open (203,file=trim(filename),status='old')
     123           0 :           rewind (203)
     124             :          else
     125             :             CALL juDFT_error("no proj/proj.1/proj.2",calledby
     126           0 :      +           ="wann_hopping")
     127             :          endif
     128           0 :          read (203,*) num_wann,num_bands
     129           0 :          close (203)
     130           0 :          write(6,*)'According to proj there are ',num_bands,' bands'
     131           0 :          write(6,*)"and ",num_wann," wannier functions."
     132             : c****************************************************************
     133             : c     read in chk
     134             : c****************************************************************
     135           0 :          num_kpts=nkpts
     136           0 :          allocate( u_matrix_opt(num_bands,num_wann,nkpts) )
     137           0 :          allocate( u_matrix(num_wann,num_wann,nkpts) )
     138           0 :          allocate( lwindow(num_bands,nkpts) )
     139           0 :          allocate( ndimwin(nkpts) )
     140             :          call wann_read_umatrix2(
     141             :      >               nkpts,num_wann,num_bands,
     142             :      >               um_format,jspin,wan90version,
     143             :      <               have_disentangled,
     144             :      <               lwindow,ndimwin,
     145           0 :      <               u_matrix_opt,u_matrix)
     146             : c****************************************************************
     147             : c     read in eig-file
     148             : c****************************************************************
     149           0 :          num_bands2=num_bands
     150           0 :          if(l_soc.and.l_socmmn0)then
     151           0 :           num_bands2=neigd
     152             :          endif
     153           0 :          write(6,*)"read in eig-file"
     154           0 :          allocate(energy(num_bands2,num_kpts))
     155           0 :          inquire(file=spin12(jspin)//'.eig',exist=l_umdat)
     156           0 :          IF(.NOT.l_umdat)  CALL juDFT_error
     157             :      +        ("Thou shall not hide your eig file",calledby
     158           0 :      +        ="wann_hopping")
     159           0 :          open(300,file=spin12(jspin)//'.eig',form='formatted')
     160           0 :          do i=1,num_kpts
     161           0 :            do j=1,num_bands2
     162           0 :               read(300,*)band,kpt,energy(j,i)
     163             :            enddo
     164             :          enddo
     165           0 :          close(300)
     166             : 
     167           0 :          minenerg=minval(energy(:,:))
     168           0 :          maxenerg=maxval(energy(:,:))
     169           0 :          write(6,*)"minenerg=",minenerg
     170           0 :          write(6,*)"maxenerg=",maxenerg
     171             : c*********************************************
     172             : c       Preparations for spin-orbit coupling
     173             : c*********************************************
     174             :          if(l_socham)then
     175             :            allocate(mmn0(nkpts,num_bands2,num_bands2,2))
     176             :            open(304,file='spinup.mmn0',form='formatted')
     177             :            read(304,*)
     178             :            read(304,*)
     179             :            do nkp=1,num_kpts
     180             :             do i=1,num_bands2
     181             :              do j=1,num_bands2
     182             :                 read(304,*)dummy1,dummy2,dummy3,a,b
     183             : c                mmn0(nkp,j,i,1)=cmplx(a,b)
     184             :                 mmn0(nkp,i,j,1)=cmplx(a,-b)
     185             :              enddo !j
     186             :             enddo !i
     187             :            enddo !nkp
     188             :            close(304)
     189             :            open(304,file='spindown.mmn0',form='formatted')
     190             :            read(304,*)
     191             :            read(304,*)
     192             :            do nkp=1,num_kpts
     193             :             do i=1,num_bands2
     194             :              do j=1,num_bands2
     195             :                 read(304,*)dummy1,dummy2,dummy3,a,b
     196             : c                mmn0(nkp,j,i,2)=cmplx(a,b)
     197             :                 mmn0(nkp,i,j,2)=cmplx(a,-b)
     198             :              enddo !j
     199             :             enddo !i
     200             :            enddo !nkp
     201             :            close(304)
     202             :          endif!l_soc
     203             : c****************************************************************
     204             : c               calculate matrix elements of hamiltonian
     205             : c****************************************************************
     206             : 
     207             :          write(6,*)"calculate matrix elements of hamiltonian
     208           0 :      &   between wannier orbitals"
     209             : 
     210             : 
     211           0 :          allocate(eigval_opt(num_bands,nkpts))
     212           0 :          allocate(eigval2(num_bands2,nkpts))
     213           0 :          eigval_opt=0.0
     214           0 :          eigval2=0.0
     215             : 
     216             : 
     217           0 :          if(have_disentangled) then
     218             : 
     219             :          ! slim down eigval to contain states within the outer window
     220             : 
     221           0 :           do nkp=1,num_kpts
     222           0 :             counter=0
     223           0 :             do j=1,num_bands
     224           0 :               if(lwindow(j,nkp)) then
     225           0 :                 counter=counter+1
     226           0 :                 eigval_opt(counter,nkp)=energy(j,nkp)
     227             :               end if
     228             :             end do
     229             :           end do
     230             :        
     231             :           ! rotate eigval into the optimal subspace
     232             :           ! in general eigval would be a matrix at each kpoints
     233             :           ! but we choose u_matrix_opt such that the Hamiltonian is
     234             :           ! diagonal at each kpoint. (I guess we should check it here)
     235             :        
     236           0 :           do nkp=1,num_kpts
     237           0 :            do j=1,num_wann
     238           0 :              do m=1,ndimwin(nkp)
     239             :                 eigval2(j,nkp)=eigval2(j,nkp)+eigval_opt(m,nkp)* 
     240           0 :      &    real(conjg(u_matrix_opt(m,j,nkp))*u_matrix_opt(m,j,nkp))
     241             :              enddo
     242             :            enddo
     243             :           enddo
     244             : 
     245             :          else
     246           0 :           eigval2(1:num_bands2,:)=energy(1:num_bands2,:)
     247             :          end if                    !have_disentangled
     248             : 
     249           0 :          deallocate(eigval_opt)
     250           0 :          deallocate(energy)
     251             : 
     252           0 :          allocate(hwann(num_wann,num_wann,num_kpts))
     253           0 :          hwann=cmplx(0.0,0.0)
     254           0 :          wann_shift=0
     255           0 :          if(l_socmmn0)then
     256           0 :             wann_shift=band_min(jspin)-1
     257             :          endif
     258             : 
     259           0 :          do k=1,num_kpts
     260           0 :           do i=1,num_wann
     261           0 :            do j=1,num_wann
     262           0 :             do m=1,num_wann
     263             :                     hwann(i,j,k)=hwann(i,j,k)
     264             :      +    +eigval2(m+wann_shift,k)*u_matrix(m,j,k)*
     265           0 :      *     conjg(u_matrix(m,i,k))
     266             :             enddo
     267             :            enddo
     268             :           enddo
     269             :          enddo
     270             : 
     271             :          if(l_socham)then
     272             : 
     273             :          num_wann2=num_wann
     274             :          wann_shift=0
     275             :          if(l_socmmn0)then
     276             :           num_wann2=neigd
     277             :           wann_shift=band_min(jspin)-1
     278             :          endif
     279             :          write(6,*)"num_wann2=",num_wann2
     280             :          write(6,*)"num_wann=",num_wann
     281             :          write(6,*)"wann_shift=",wann_shift
     282             :          allocate(hwannsoc(num_wann,num_wann,num_kpts,2,2))
     283             :          hwannsoc=cmplx(0.0,0.0)
     284             :          do kspin=1,2
     285             :           do kkspin=1,2
     286             :            do i=1,num_wann
     287             :             do j=1,num_wann
     288             :              do k=1,num_kpts
     289             :               do m=1,num_wann2
     290             :               do m1=1,num_wann
     291             :               do m2=1,num_wann
     292             :                hwannsoc(i,j,k,kkspin,kspin)=
     293             :      =          hwannsoc(i,j,k,kkspin,kspin)
     294             :      +           +eigval2(m,k)*u_matrix(m2,j,k)*conjg(u_matrix(m1,i,k))*
     295             :      *           mmn0(k,m1+wann_shift,m,kkspin)*
     296             :      *           mmn0(k,m,m2+wann_shift,kspin)
     297             :               enddo
     298             :               enddo
     299             :               enddo !m
     300             :              enddo !k
     301             :             enddo !j
     302             :            enddo !i
     303             :           enddo !kkspin
     304             :          enddo !kspin
     305             :          deallocate(mmn0)
     306             : 
     307             : 
     308             :          do i=1,num_wann
     309             :           do j=1,num_wann
     310             :            do k=1,num_kpts
     311             :              eulav=hwannsoc(i,j,k,1,1)+hwannsoc(i,j,k,1,2)+
     312             :      &                   hwannsoc(i,j,k,2,1)+hwannsoc(i,j,k,2,2)
     313             :              eulav=eulav-hwann(i,j,k)
     314             :              if(abs(eulav).gt.1.e-6)then
     315             :                  write(6,*)"soc-hop: something wrong:",eulav
     316             :              endif
     317             :            enddo
     318             :           enddo
     319             :          enddo
     320             : 
     321             : 
     322             : 
     323             :          endif !l_soc
     324             : 
     325             : 
     326             : 
     327             : 
     328             : c***************************************************************
     329             : c        repro_eig
     330             : c***************************************************************
     331             : 
     332             :          if(repro_eig)then
     333             :    
     334             :          write(6,*)"As a check, try to reproduce the old eigenvalues"
     335             : 
     336             : c       Note, that this check will give positive result,
     337             : c       if u_matrix is unitary
     338             : 
     339             :         allocate (vec(num_wann,num_wann),ei(num_wann))
     340             :         allocate(eigw(num_kpts,num_wann))
     341             : 
     342             :         lee = log( dble(num_wann) )/log(2.d0) + 1
     343             :         lwork = 1 + 5*num_wann + 2*num_wann*lee + 3*(num_wann**2)
     344             :         lrwork = 1 + 4*num_wann + 2*num_wann*lee + 3*(num_wann**2)
     345             :         liwork = 2 + 5*num_wann +1
     346             : 
     347             :         allocate (work(lwork),rwork(lrwork),iwork(liwork))
     348             : 
     349             : 
     350             : 
     351             :         do i=1,num_kpts
     352             :           do j = 1,num_wann
     353             :             do k = 1,num_wann
     354             :                vec(j,k) = hwann(j,k,i)
     355             :             enddo
     356             :           enddo
     357             : 
     358             : 
     359             :           jobz = 'V' ; uplo = 'L' ; n = num_wann ; lda = num_wann
     360             :           call zheevd(jobz,uplo,n,vec,lda,ei,work,lwork,
     361             :      &             rwork,lrwork,iwork,liwork,info)
     362             : 
     363             :           if (info.lt.0) write (*,*)
     364             :      &               'ith argument had an illegal value ',info
     365             :           IF (info>0)  CALL juDFT_error("not converged diagonalization"
     366             :      +         ,calledby ="wann_hopping")
     367             : 
     368             :           do j = 1,num_wann
     369             :               eigw(i,j) = ei(j)
     370             :               if(abs(eigw(i,j)-eigval2(j,i)).gt.0.0001)then
     371             :                  write(6,*)"found different eigenvalues:"
     372             :                  write(6,*)"kpt=",i
     373             :                  write(6,*)"band=",j
     374             :                  write(6,*)"eig=",eigval2(j,i)
     375             :                  write(6,*)"neweig=",eigw(i,j)
     376             :               endif
     377             :           enddo
     378             : 
     379             :         enddo
     380             :         deallocate(work,rwork,iwork)
     381             :         deallocate(vec,ei)
     382             :         open(500,file='reeig'//spin12(jspin),form='formatted')
     383             :         do i=1,num_kpts
     384             :           do j=1,num_wann
     385             :              write(500,'(i5,3x,i5,3x,f20.16)')i,j,eigw(i,j)
     386             :           enddo
     387             :         enddo
     388             :         close(500)
     389             :         deallocate(eigw)
     390             :       endif !repro_eig
     391             : c************************************************************
     392             : c     Calculate hoppings.
     393             : c***********************************************************      
     394           0 :       write(6,*)"calculate hoppings"
     395           0 :       allocate( hreal(num_wann,num_wann,rvecnum) )
     396           0 :       hreal=cmplx(0.0,0.0)
     397           0 :       do rvecind=1,rvecnum
     398           0 :        do k=1,nkpts
     399             :           rdotk=tpi*(  kpoints(1,k)*rvec(1,rvecind)+
     400             :      +                 kpoints(2,k)*rvec(2,rvecind)+
     401           0 :      +                 kpoints(3,k)*rvec(3,rvecind)  )
     402           0 :           fac=cmplx(cos(rdotk),-sin(rdotk))
     403           0 :           do m2=1,num_wann
     404           0 :            do m1=1,num_wann
     405             :             hreal(m1,m2,rvecind)=hreal(m1,m2,rvecind)+
     406           0 :      &            fac*hwann(m1,m2,k)
     407             :            enddo !m1
     408             :           enddo !m2
     409             :        enddo !k
     410             :       enddo !rvecind
     411           0 :       hreal=hreal/cmplx(real(nkpts),0.0)
     412             : 
     413           0 :       if(l_ndegen)then
     414           0 :         do rvecind=1,rvecnum
     415           0 :           do m2=1,num_wann
     416           0 :             do m1=1,num_wann
     417             :               hreal(m1,m2,rvecind)=
     418           0 :      & hreal(m1,m2,rvecind)/cmplx(real(ndegen(rvecind)),0.0)
     419             :             enddo !m1
     420             :           enddo !m2
     421             :         enddo !rvecind  
     422             :       endif !l_ndegen
     423             : 
     424             : c************************************************************
     425             : c              calculate hoppings for soc
     426             : c***********************************************************   
     427             :       if(l_socham)then
     428             :        allocate(hrealsoc(num_wann,num_wann,rvecnum,
     429             :      &         2,2))
     430             :        hrealsoc=cmplx(0.0,0.0)
     431             :        do rvecind=1,rvecnum
     432             :          do k=1,nkpts
     433             :            rdotk=tpi*(  kpoints(1,k)*rvec(1,rvecind)+
     434             :      +                  kpoints(2,k)*rvec(2,rvecind)+
     435             :      +                  kpoints(3,k)*rvec(3,rvecind)  )
     436             :            fac=cmplx(cos(rdotk),-sin(rdotk))/nkpts
     437             :            do kspin=1,2
     438             :              do kkspin=1,2
     439             :                hrealsoc(:,:,rvecind,kspin,kkspin)=
     440             :      =           hrealsoc(:,:,rvecind,kspin,kkspin)+
     441             :      +           fac*hwannsoc(:,:,k,kspin,kkspin)
     442             :              enddo
     443             :            enddo
     444             :          enddo !k
     445             :        enddo !rvecnum
     446             :       endif !l_soc
     447             : 
     448             : c****************************************************************
     449             : c           make the hoppings real
     450             : c****************************************************************
     451             : c$$$      if(.false.)then
     452             : c$$$      do i=1,num_wann
     453             : c$$$       do j=i+1,num_wann
     454             : c$$$        eulav=cmplx(0.0,0.0)
     455             : c$$$        do r1=hopmin,hopmax
     456             : c$$$         do r2=hopmin,hopmax
     457             : c$$$          do r3=hopmin,hopmax
     458             : c$$$            eulav1=hreal(i,j,r1,r2,r3)
     459             : c$$$            if(abs(eulav1).gt.abs(eulav))then
     460             : c$$$               eulav=eulav1
     461             : c$$$            endif
     462             : c$$$          enddo !r1
     463             : c$$$         enddo !r2
     464             : c$$$        enddo !r3
     465             : c$$$        if(abs(eulav).gt.1e-6)then
     466             : c$$$         eulav=eulav/abs(eulav)
     467             : c$$$         do r1=hopmin,hopmax
     468             : c$$$          do r2=hopmin,hopmax
     469             : c$$$           do r3=hopmin,hopmax
     470             : c$$$             hreal(i,j,r1,r2,r3)=hreal(i,j,r1,r2,r3)/eulav
     471             : c$$$             hreal(j,i,-r1,-r2,-r3)=conjg(hreal(i,j,r1,r2,r3))
     472             : c$$$!             hreal(j,i,r1,r2,r3)=hreal(j,i,r1,r2,r3)/conjg(eulav)
     473             : c$$$             if(l_soc)then
     474             : c$$$               hrealsoc(i,j,r1,r2,r3,:,:)=
     475             : c$$$     &                  hrealsoc(i,j,r1,r2,r3,:,:)/eulav
     476             : c$$$               hrealsoc(j,i,-r1,-r2,-r3,:,:)=
     477             : c$$$     &                  conjg( hrealsoc(i,j,r1,r2,r3,:,:) )
     478             : c$$$!               hrealsoc(j,i,r1,r2,r3,:,:)=
     479             : c$$$!     &                  hrealsoc(j,i,r1,r2,r3,:,:)/conjg(eulav)
     480             : c$$$             endif
     481             : c$$$           enddo !r3
     482             : c$$$          enddo !r2   
     483             : c$$$         enddo !r1      
     484             : c$$$        endif !eulav
     485             : c$$$       enddo !j
     486             : c$$$      enddo !i
     487             : c$$$      endif
     488             : 
     489             :       if(l_socham)then
     490             :        do kspin=1,2
     491             :        do kkspin=1,2
     492             :        open(321,file='hopping'//spinspin12(kspin)//spinspin12(kkspin),
     493             :      &                        form='formatted')
     494             :        do rvecind=1,rvecnum
     495             :           r1=rvec(1,rvecind)
     496             :           r2=rvec(2,rvecind)
     497             :           r3=rvec(3,rvecind)
     498             :           do i=1,num_wann
     499             :            do j=1,num_wann
     500             :             write(321,'(i3,i3,i3,i3,i3,f20.8,f20.8)')
     501             :      &        r1,r2,r3,i,j,hrealsoc(i,j,rvecind,kspin,kkspin) 
     502             :            enddo !j
     503             :           enddo !i
     504             :        enddo !rvecind   
     505             :        close(321)       
     506             :        enddo  !kkspin
     507             :        enddo  !kspin
     508             :        deallocate(hrealsoc,hwannsoc)
     509             :       endif !l_soc  
     510             : 
     511           0 :       if(l_unformatted)then
     512           0 :        if(l_soc)then  
     513           0 :         if(l_ndegen)then                
     514             :          open(321,file='hunfndegen',form='unformatted'
     515             : #ifdef CPP_INTEL
     516             :      &                  ,convert='BIG_ENDIAN'
     517             : #endif
     518           0 :      &                   )
     519             :         else
     520             :          open(321,file='hunf',form='unformatted'
     521             : #ifdef CPP_INTEL
     522             :      &                  ,convert='BIG_ENDIAN'
     523             : #endif
     524           0 :      &                   )
     525             :         endif   
     526             :        else
     527           0 :         if(l_ndegen)then                
     528             :          open(321,file='hunfndegen'//spinspin12(jspin),
     529             :      &                  form='unformatted'
     530             : #ifdef CPP_INTEL
     531             :      &                  ,convert='BIG_ENDIAN'
     532             : #endif
     533           0 :      &                   )
     534             :         else
     535             :          open(321,file='hunf'//spinspin12(jspin),
     536             :      &                  form='unformatted'
     537             : #ifdef CPP_INTEL
     538             :      &                  ,convert='BIG_ENDIAN'
     539             : #endif
     540           0 :      &                   )
     541             :         endif   
     542             :        endif
     543           0 :        write(321)num_wann
     544           0 :        write(321)rvecnum
     545           0 :        write(321)rvec
     546           0 :        write(321)hreal  
     547             :       else      
     548           0 :        if(l_ndegen)then
     549             :         open(321,file='hopping_ndegen'//spinspin12(jspin),
     550           0 :      &            form='formatted')
     551             :        else
     552             :         open(321,file='hopping'//spinspin12(jspin),
     553           0 :      &            form='formatted')
     554             :        endif   
     555           0 :        do rvecind=1,rvecnum
     556           0 :          r3=rvec(3,rvecind)
     557           0 :          r2=rvec(2,rvecind)
     558           0 :          r1=rvec(1,rvecind)
     559           0 :          do j=1,num_wann
     560           0 :            do i=1,num_wann
     561             :             write(321,'(i3,1x,i3,1x,i3,1x,i3,1x,i3,1x,f20.8,1x,f20.8)')
     562           0 :      &          r1,r2,r3,i,j,hreal(i,j,rvecind) 
     563             :            enddo
     564             :          enddo   
     565             :        enddo !rvecnum
     566             :       endif !l_unformatted       
     567           0 :       close(321)
     568             : 
     569           0 :       deallocate(lwindow,u_matrix_opt,ndimwin)
     570           0 :       deallocate(eigval2,u_matrix,hwann,hreal)
     571             : !      deallocate(rvec)
     572             :       enddo !jspin
     573             : 
     574             : 
     575             : 
     576           0 :       end subroutine wann_hopping
     577             :       end module m_wann_hopping

Generated by: LCOV version 1.13