LCOV - code coverage report
Current view: top level - io - io_hybrid.F90 (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 64 0.0 %
Date: 2019-09-08 04:53:50 Functions: 0 18 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_io_hybrid
       8             :   use m_io_matrix
       9             :   use m_judft
      10             :   use m_types
      11             :   implicit none
      12             :   !private
      13             :   integer,save :: id_olap,id_z,id_v_x,id_coulomb,id_coulomb_spm
      14             :   !public:: open_hybrid_io,read_cmt,write_cmt
      15             : contains
      16             : 
      17           0 :   SUBROUTINE open_hybrid_io1(DIMENSION,l_real)
      18             :     implicit none
      19             :     TYPE(t_dimension),INTENT(IN):: dimension
      20             :     LOGICAL,INTENT(IN)          :: l_real
      21             :     LOGICAL :: opened=.false.
      22             : 
      23           0 :     if (opened) return
      24           0 :     opened=.true.
      25             : 
      26             :     !print *,"Open olap.mat"
      27           0 :     id_olap=OPEN_MATRIX(l_real,DIMENSION%nbasfcn,1,1,"olap.mat")
      28             :     !print *,"Open z.mat"
      29           0 :     id_z=OPEN_MATRIX(l_real,DIMENSION%nbasfcn,1,1,"z.mat")
      30             :   END SUBROUTINE open_hybrid_io1
      31             : 
      32             : 
      33           0 :   SUBROUTINE open_hybrid_io1b(DIMENSION,l_real)
      34             :     implicit none
      35             :     TYPE(t_dimension),INTENT(IN):: dimension
      36             :     LOGICAL,INTENT(IN)          :: l_real
      37             :     LOGICAL :: opened=.false.
      38             : 
      39           0 :     if (opened) return
      40           0 :     opened=.true.
      41             : 
      42             :     !print *,"Open v_x.mat"
      43           0 :     id_v_x=OPEN_MATRIX(l_real,DIMENSION%nbasfcn,1,1,"v_x.mat")
      44             :   END SUBROUTINE open_hybrid_io1b
      45             : 
      46             : 
      47           0 :   SUBROUTINE open_hybrid_io2(hybrid,DIMENSION,atoms,l_real)
      48             :     IMPLICIT NONE
      49             :     TYPE(t_hybrid),INTENT(IN)   :: hybrid
      50             :     TYPE(t_dimension),INTENT(IN):: dimension
      51             :     TYPE(t_atoms),INTENT(IN)    :: atoms
      52             :     LOGICAL,INTENT(IN)          :: l_real
      53             :     INTEGER:: irecl_coulomb
      54             :     LOGICAL :: opened=.FALSE.
      55             : 
      56             :     
      57             : 
      58           0 :     if (opened) return
      59           0 :     opened=.true.
      60             :     OPEN(unit=777,file='cmt',form='unformatted',access='direct',&
      61           0 :          &     recl=dimension%neigd*hybrid%maxlmindx*atoms%nat*16)
      62             :   
      63             : #ifdef CPP_NOSPMVEC
      64             :     irecl_coulomb = hybrid%maxbasm1 * (hybrid%maxbasm1+1) * 8 / 2
      65             :     if (.not.l_real) irecl_coulomb =irecl_coulomb *2
      66             :     OPEN(unit=778,file='coulomb',form='unformatted',access='direct', recl=irecl_coulomb)
      67             :     id_coulomb=778
      68             : #else
      69             :     ! if the sparse matrix technique is used, several entries of the
      70             :     ! matrix vanish so that the size of each entry is smaller
      71             :     irecl_coulomb = ( atoms%ntype*(hybrid%maxlcutm1+1)*(hybrid%maxindxm1-1)**2&
      72             :          +   atoms%nat *(hybrid%maxlcutm1+2)*(2*hybrid%maxlcutm1+1)*(hybrid%maxindxm1-1)&
      73             :          +   (hybrid%maxindxm1-1)*atoms%nat**2&
      74             :          +   ((hybrid%maxlcutm1+1)**2*atoms%nat+hybrid%maxgptm)&
      75           0 :          *((hybrid%maxlcutm1+1)**2*atoms%nat+hybrid%maxgptm+1)/2 )*8
      76           0 :     if (.not.l_real) irecl_coulomb =irecl_coulomb *2
      77           0 :     OPEN(unit=778,file='coulomb1',form='unformatted',access='direct', recl=irecl_coulomb)
      78           0 :     id_coulomb_spm=778
      79             : #endif
      80             :   END SUBROUTINE open_hybrid_io2
      81             :   
      82           0 :   subroutine write_cmt(cmt,nk)
      83             :     implicit none
      84             :     complex,INTENT(IN):: cmt(:,:,:)
      85             :     integer,INTENT(IN):: nk
      86             : 
      87           0 :     write(777,rec=nk) cmt
      88           0 :   end subroutine write_cmt
      89             : 
      90           0 :   subroutine read_cmt(cmt,nk)
      91             :     implicit none
      92             :     complex,INTENT(OUT):: cmt(:,:,:)
      93             :     integer,INTENT(IN):: nk
      94             : 
      95           0 :     read(777,rec=nk) cmt
      96           0 :   end subroutine read_cmt
      97             : 
      98           0 :   subroutine write_coulomb(nk,l_real,coulomb)
      99             :     implicit none
     100             :     complex,intent(in) :: coulomb(:)
     101             :     integer,intent(in) :: nk
     102             :     logical,intent(in) :: l_real
     103             : 
     104           0 :     if (l_real) THEN
     105           0 :        write(id_coulomb,rec=nk) real(coulomb)
     106             :     else
     107           0 :        write(id_coulomb,rec=nk) coulomb
     108             :     end if
     109           0 :   end subroutine write_coulomb
     110             : 
     111           0 :    subroutine write_coulomb_spm_r(nk,coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir)
     112             :     implicit none
     113             :     real,intent(in)    :: coulomb_mt1(:,:,:,:)
     114             :     real,intent(in) :: coulomb_mt2(:,:,:,:), coulomb_mt3(:,:,:)
     115             :     real,intent(in) :: coulomb_mtir(:)
     116             :     integer,intent(in) :: nk
     117             :     
     118             :     !print *, "write coulomb",nk,size(coulomb_mt1),size(coulomb_mt2),size(coulomb_mt3),size(coulomb_mtir)
     119           0 :     write(id_coulomb_spm,rec=nk) coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir
     120           0 :   end subroutine write_coulomb_spm_r
     121             : 
     122           0 :    subroutine write_coulomb_spm_c(nk,coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir)
     123             :     implicit none
     124             :     real,intent(in)    :: coulomb_mt1(:,:,:,:)
     125             :     complex,intent(in) :: coulomb_mt2(:,:,:,:), coulomb_mt3(:,:,:)
     126             :     complex,intent(in) :: coulomb_mtir(:)
     127             :     integer,intent(in) :: nk
     128             :     
     129           0 :     write(id_coulomb_spm,rec=nk) coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir
     130           0 :   end subroutine write_coulomb_spm_c
     131             : 
     132           0 :      subroutine read_coulomb_spm_r(nk,coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir)
     133             :     implicit none
     134             :     real,intent(out)    :: coulomb_mt1(:,:,:,:)
     135             :     real,intent(out) :: coulomb_mt2(:,:,:,:), coulomb_mt3(:,:,:)
     136             :     real,intent(out) :: coulomb_mtir(:)
     137             :     integer,intent(in) :: nk
     138             :     
     139             :     !print *, "read coulomb",nk,size(coulomb_mt1),size(coulomb_mt2),size(coulomb_mt3),size(coulomb_mtir)
     140           0 :     read(id_coulomb_spm,rec=nk) coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir
     141           0 :   end subroutine read_coulomb_spm_r
     142             : 
     143           0 :    subroutine read_coulomb_spm_c(nk,coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir)
     144             :     implicit none
     145             :     real,intent(out)    :: coulomb_mt1(:,:,:,:)
     146             :     complex,intent(out) :: coulomb_mt2(:,:,:,:), coulomb_mt3(:,:,:)
     147             :     complex,intent(out) :: coulomb_mtir(:)
     148             :     integer,intent(in) :: nk
     149           0 :     read(id_coulomb_spm,rec=nk) coulomb_mt1,coulomb_mt2,coulomb_mt3,coulomb_mtir
     150           0 :   end subroutine read_coulomb_spm_c
     151             : 
     152           0 :   subroutine read_coulomb_r(nk,coulomb)
     153             :     implicit none
     154             :     real   ,intent(out) :: coulomb(:)
     155             :     integer,intent(in) :: nk
     156             : 
     157           0 :     read(id_coulomb,rec=nk) coulomb
     158           0 :   end subroutine read_coulomb_r
     159             :   
     160           0 :   subroutine read_coulomb_c(nk,coulomb)
     161             :     implicit none
     162             :     complex,intent(out) :: coulomb(:)
     163             :     integer,intent(in) :: nk
     164             :     
     165           0 :     read(id_coulomb,rec=nk) coulomb
     166           0 :   end subroutine read_coulomb_c
     167             : 
     168             : 
     169             :   
     170           0 :   subroutine read_olap(mat,rec)
     171             :     implicit none
     172             :     TYPE(t_mat),INTENT(INOUT):: mat
     173             :     INTEGER,INTENT(IN)           :: rec
     174             :     
     175           0 :     CALL read_matrix(mat,rec,id_olap)
     176           0 :   END subroutine read_olap
     177             : 
     178           0 :     subroutine write_olap(mat,rec)
     179             :     implicit none
     180             :     TYPE(t_mat),INTENT(IN)   :: mat
     181             :     INTEGER,INTENT(IN)           :: rec
     182             :     
     183           0 :     CALL write_matrix(mat,rec,id_olap)
     184           0 :   END subroutine write_olap
     185             : 
     186           0 :   subroutine read_z(mat,rec)
     187             :     implicit none
     188             :     TYPE(t_mat),INTENT(INOUT):: mat
     189             :     INTEGER,INTENT(IN)           :: rec
     190             :     !print *,"read z:",rec
     191             :     
     192           0 :     CALL read_matrix(mat,rec,id_z)
     193           0 :   END subroutine read_z
     194             : 
     195           0 :     subroutine write_z(mat,rec)
     196             :     implicit none
     197             :     TYPE(t_mat),INTENT(IN)   :: mat
     198             :     INTEGER,INTENT(IN)           :: rec
     199             :      !print *,"write z:",rec
     200           0 :    CALL write_matrix(mat,rec,id_z)
     201           0 :   END subroutine write_z
     202             : 
     203           0 :   subroutine read_v_x(mat,rec)
     204             :     implicit none
     205             :     TYPE(t_mat),INTENT(INOUT):: mat
     206             :     INTEGER,INTENT(IN)           :: rec
     207             :     
     208           0 :     CALL read_matrix(mat,rec,id_v_x)
     209           0 :   END subroutine read_v_x
     210             : 
     211           0 :   subroutine write_v_x(mat,rec)
     212             :     implicit none
     213             :     TYPE(t_mat),INTENT(IN)   :: mat
     214             :     INTEGER,INTENT(IN)           :: rec
     215             :     
     216           0 :     CALL write_matrix(mat,rec,id_v_x)
     217           0 :   END subroutine write_v_x
     218             : 
     219             :   
     220             :  
     221             : 
     222             : end module m_io_hybrid

Generated by: LCOV version 1.13