LCOV - code coverage report
Current view: top level - vgen - od_mkgz.f (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 59 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_od_mkgz
       8             :       CONTAINS
       9           0 :       SUBROUTINE od_mkgz(
      10             :      >     z1,nmzxy,delz,
      11           0 :      >     nmzdf,jspins,rh1,rh2,rhdz1,rhdz2,rhdzz1,rhdzz2,
      12           0 :      <     agrt,agru,agrd,g2rt,g2ru,g2rd,gggrt,gggru,gggrd,
      13           0 :      <     gzgr)
      14             : 
      15             : c     by use of cartesian cylindrical z,phi,r components of charge 
      16             : c     density gradients, makes the quantities
      17             : c     agrt,agru,agrd,g2rt,g2ru,g2rd,gggrt,gggru,gggrd,
      18             : c     gzgr
      19             : c     used to calculate gradient contribution to xc potential and
      20             : c     energy.
      21             : c     for more comments on variables go to mkgxyz3_1.F and vvacxcg_1.F
      22             : c     Y.Mokrousov, 16-17 Oct 2002
      23             : 
      24             :       implicit none
      25             :       
      26             :       integer, intent (in) :: nmzdf,jspins,nmzxy
      27             :       real,    intent (in) :: z1,delz
      28             :       real,    intent (in) :: rh1(nmzdf),rh2(nmzdf) 
      29             :       real,    intent (in) :: rhdz1(nmzdf),rhdz2(nmzdf)
      30             :       real,    intent (in) ::  rhdzz1(nmzdf),rhdzz2(nmzdf)
      31             : 
      32             :       real,   intent (out) :: agrt(nmzdf),agru(nmzdf),agrd(nmzdf)
      33             :       real,   intent (out) :: g2rt(nmzdf),g2ru(nmzdf),g2rd(nmzdf)
      34             :       real,   intent (out) :: gggrt(nmzdf),gggru(nmzdf),gggrd(nmzdf)
      35             :       real,   intent (out) :: gzgr(nmzdf)
      36             : 
      37             : c     local
      38             : 
      39             :       integer :: i
      40             :       real    :: vlt,vlu,vld
      41             :       real    :: dvzt,dvzzt,dvzu
      42             :       real    :: dvzzu,dvzd,dvzzd
      43             :       real    :: dagrzt,dagrzu,dagrzd,dztadz
      44             :       real    :: sml,z
      45             : 
      46           0 :       sml = 1.e-14
      47             : 
      48           0 :       if (jspins.eq.1) then
      49           0 :          do 10 i = 1,nmzdf
      50             : 
      51           0 :             z = z1 + delz*(nmzxy+i)
      52             : 
      53           0 :             vlu = max(rh1(i)/2,sml)
      54           0 :             dvzu = rhdz1(i)/2
      55           0 :             dvzzu = rhdzz1(i)/2
      56           0 :             vld = vlu
      57           0 :             dvzd = dvzu
      58           0 :             dvzzd = dvzzu
      59             : 
      60           0 :             vlt = vlu+vld
      61           0 :             dvzt = dvzu+dvzd
      62           0 :             dvzzt = dvzzu+dvzzd
      63             : 
      64             : c     agr(up,down,total): abs(grad(rho))
      65             : 
      66           0 :             agrt(i) = max(abs(dvzt),sml)
      67           0 :             agru(i) = max(abs(dvzu),sml)
      68           0 :             agrd(i) = max(abs(dvzd),sml)
      69             : 
      70             : c     d(abs(grad(rho)))/dr
      71             : 
      72           0 :             dagrzt= dvzt*dvzzt/agrt(i)
      73           0 :             dagrzu= dvzu*dvzzu/agru(i)
      74           0 :             dagrzd= dvzd*dvzzd/agrd(i)
      75             : 
      76             : c     grad(rho)*grad(abs(grad(ro)))
      77             : 
      78           0 :             gggrt(i) = dvzt*dagrzt
      79           0 :             gggru(i) = dvzu*dagrzu
      80           0 :             gggrd(i) = dvzd*dagrzd
      81             : 
      82             : c     dztadz=d(zeta)/dz,..
      83             :             
      84           0 :             dztadz = (dvzu-dvzd)/vlt - (vlu-vld)*dvzt/vlt**2
      85             :             
      86             : c     gzgr=grad(zeta)*grad(ro).
      87             :             
      88           0 :             gzgr(i) = dztadz*dvzt
      89             :             
      90             : c     g2rt: grad(grad(ro))
      91             :             
      92           0 :             g2rt(i)  = dvzzt + dvzt/z
      93           0 :             g2ru(i)  = dvzzu + dvzu/z
      94           0 :             g2rd(i)  = dvzzd + dvzd/z
      95             : 
      96             : 
      97           0 :  10    continue
      98             : 
      99             :       else
     100             :          
     101           0 :          do 20 i = 1,nmzdf
     102             : 
     103           0 :             z = z1 + delz*(nmzxy + i)
     104             :             
     105           0 :             vlu = max(rh1(i),sml)
     106           0 :             dvzu = rhdz1(i)
     107           0 :             dvzzu = rhdzz1(i)
     108           0 :             vld = max(rh2(i),sml)
     109           0 :             dvzd = rhdz2(i)
     110           0 :             dvzzd = rhdzz2(i)
     111             :             
     112           0 :             vlt = vlu+vld
     113           0 :             dvzt = dvzu+dvzd
     114           0 :             dvzzt = dvzzu+dvzzd
     115             :             
     116             : c     agrt: abs(grad(ro)), u,d for up and down.
     117             :             
     118           0 :             agrt(i) = max(abs(dvzt),sml)
     119           0 :             agru(i) = max(abs(dvzu),sml)
     120           0 :             agrd(i) = max(abs(dvzd),sml)
     121             :             
     122           0 :             dagrzt= dvzt*dvzzt/agrt(i)
     123           0 :             dagrzu= dvzu*dvzzu/agru(i)
     124           0 :             dagrzd= dvzd*dvzzd/agrd(i)
     125             :             
     126           0 :             gggrt(i) = dvzt*dagrzt
     127           0 :             gggru(i) = dvzu*dagrzu
     128           0 :             gggrd(i) = dvzd*dagrzd
     129             :             
     130             : c     dztadz=d(zeta)/dz,..
     131             :             
     132           0 :             dztadz = (dvzu-dvzd)/vlt - (vlu-vld)*dvzt/vlt**2
     133             :             
     134             : c     gzgr=grad(zeta)*grad(ro).
     135             :             
     136           0 :             gzgr(i) = dztadz*dvzt
     137             :             
     138             : c     g2rt: grad(grad(ro))
     139             :             
     140           0 :             g2rt(i)  = dvzzt + dvzt/z
     141           0 :             g2ru(i)  = dvzzu + dvzu/z
     142           0 :             g2rd(i)  = dvzzd + dvzd/z
     143             :             
     144             :             
     145           0 :  20      continue
     146             : 
     147             :       ENDIF
     148             :       
     149           0 :       END SUBROUTINE od_mkgz
     150             :       END MODULE m_od_mkgz

Generated by: LCOV version 1.13