dft_tools/python/triqs_dft_tools/converters/elktools/readElkfiles.py

##########################################################################
#
# TRIQS: a Toolbox for Research in Interacting Quantum Systems
#
# Copyright (C) 2019 by A. D. N. James, M. Zingl and M. Aichhorn
#
# TRIQS is free software: you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later
# version.
#
# TRIQS is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# TRIQS. If not, see <http://www.gnu.org/licenses/>.
#
##########################################################################

from types import *
import numpy
from triqs_dft_tools.converters.converter_tools import *
import os.path
from locale import atof


class readElkfiles:
    """
    Read in the Elk output files for the elk_converter.py routines.
    """

    def __init__(self):
        self.dft_file = 'PROJ.OUT'
        self.band_file = 'BAND.OUT'
        self.eval_file = 'EIGVAL.OUT'
        self.efermi_file = 'EFERMI.OUT'
        self.kp_file = 'KPOINTS.OUT'
        self.geom_file='GEOMETRY.OUT'

    def read_elk_file(self, filename, to_replace):
        #this function is almost identical to read_fortran_file, but it removes words after ':'
        """
        Returns a generator that yields all numbers in the Fortran file as float, with possible replacements.

        Parameters
        ----------
        filename : string
                   Name of Fortran-produced file.
        to_replace : dict of str:str
                     Dictionary defining old_char:new_char.

        Yields
        ------
        string
            The next number in file.

        """
        #import os.path
        #import string
        import locale
        from locale import atof
        if not(os.path.exists(filename)):
            raise IOError("File %s does not exist." % filename)
        for line in open(filename, 'r'):
            for old, new in to_replace.items():
                line = line.replace(old, new)
            # removes the substring after ':' character - if it exists
            if ":" in line:
              line = self.split_string(line)
            if "(" in line:
              line = self.split_string3(line)
            for x in line.split():
                yield atof(x)

    def read_elk_file2(self, filename, to_replace):
        #this function is almost identical to read_fortran_file, but it removes words after '('
        """
        Returns a generator that yields all numbers in the Fortran file as float, with possible replacements.

        Parameters
        ----------
        filename : string
                   Name of Fortran-produced file.
        to_replace : dict of str:str
                     Dictionary defining old_char:new_char.

        Yields
        ------
        string
            The next number in file.

        """
        import os.path
        import string
        if not(os.path.exists(filename)):
            raise IOError("File %s does not exist." % filename)
        for line in open(filename, 'r'):
            for old, new in to_replace.items():
                line = line.replace(old, new)
            # removes the substring after '(' character - if it exists
            if "(" in line:
              line = self.split_string2(line,'(')
            # removes the substring after '+' character - if it exists
            if "+" in line:
              line = self.split_string2(line,'+')
            # removes the substring after '|' character - if it exists
            if "|" in line:
              line = self.split_string2(line,'|')
            #only include lines which have multiple characters
            if(len(line)>1):
              yield line.split()

    def split_string(self,line):
        """
        This removes the excess information after ':' of the string read in from the file
        """
        temp = line.split(':')
        line = temp[0]
        return line

    def split_string2(self,line,str):
        """
        This removes the excess information after 'str' of the string read in from the file
        """
        temp = line.split(str)
        line = temp[0]
        return line

    def split_string3(self,line):
        """
        This removes the excess information after '(' of the string read in from the file
        """
        temp = line.split('(')
        line = temp[0]
        return line


    def read_proj(self,dft_file):#,things_to_set):
      """
      This function reads the contents of PROJ.OUT and returns them for general use.
      """
      #read in PROJ.OUT file
      R = self.read_elk_file( dft_file, self.fortran_to_replace)
      try:
        #arrays of entry names
        gen_info_entries = ['nproj', 'n_k', 'spinpol', 'SO','natm']
        proj_entries = ['sort', 'natom', 'l', 'dim']
        at_entries = ['spatom','atom']
        #Read in the No. of projectors, no. of k-points, spin and spinorb info
        gen_info = {name: int(val) for name, val in zip(gen_info_entries, R)}
        #mpi.report(gen_info)
        #read in the information of all the projectors
        #initialized variables
        icorr=0
        lmax=3 #maximum l value that will be used
        n_shells=0
        n_inequiv_shells=0
        #local arrays
        neqatom=[]#numpy.zeros([n_shells], int)
        proj=[]
        shells=[]#numpy.zeros([n_shells], int)
        corr_shells=[]#numpy.zeros([n_shells], int)
        prjtype=[]
        wan=[]
        proj_info=[]#numpy.zeros([n_shells], int)
        T=[]
        basis=[]
        inequiv_to_corr=[]
        corr_to_inequiv=[]
        ind=[]
        proj_idx=[]
        at=[]
        idxlm=[]
        #assign global variables
        n_k=gen_info['n_k']
        SO=gen_info['SO']
        #loop over projector flags
        for ip in range(gen_info['nproj']):
          #projector index
          proj_idx.append(int(next(R)))
          proj.append({name: int(val) for name, val in zip(proj_entries, R)})
          na=proj[ip]['natom'] # integer which reduces when reading in atom info
          while(na>0):
            neqatom.append(int(next(R)))
            na-=neqatom[n_inequiv_shells]
            #appends the mapping array to index of inequivalent atom in shells
            inequiv_to_corr.append(icorr)
            for ia in range(neqatom[n_inequiv_shells]):
              corr_to_inequiv.append(n_inequiv_shells)
              at.append({name: int(val) for name, val in zip(at_entries, R)})
              shells.append(proj[ip].copy())
              shells[n_shells].update({'atom':at[n_shells]['atom'], 'spatom':at[n_shells]['spatom']})
              corr_shells.append(shells[n_shells].copy())
              n_orb=2*shells[n_shells]['l']+1
              #lm submatrix indices
              idxlm.append(numpy.zeros(2*lmax+1, dtype=int))
              nrep=proj[ip]['dim']
              for i in range(nrep):
                idxlm[n_shells][i]=next(R)-1
              ind.append(idxlm[n_shells][0:nrep])
              #determine basis type and transformation matrix
              basis.append(int(next(R)))
              #determine whether which basis the projectors where generated in
              #spherical harmonics
              T.append(numpy.zeros([n_orb, n_orb], dtype=complex))
              #Elk generated unitary basis
              if (basis[n_shells]==2):
                #reads the transformation matrix
                for i in range(n_orb):
                  for j in range(n_orb):
                    T[n_shells][i, j] = next(R)
                for i in range(n_orb):
                  for j in range(n_orb):
                    T[n_shells][i, j] += 1j * next(R)
           #transformation matrix from spherical harmonics to cubic basis
              elif (basis[n_shells]==1):
                T[n_shells]=self.determine_T(shells[n_shells]['l'])
              else:
                for i in range(n_orb):
                  T[n_shells][i,i] = 1.0
           #index for the next inequivalent atom (+1 to index is not needed as this is incorporated in
           #neqatom[ish]
              n_shells+=1
           #increase the inequiv_to_corr value
            icorr+=neqatom[n_inequiv_shells]
           #increase the numer of inequivalent atoms
            n_inequiv_shells+=1
           #end reading the file if read the last projector
          if (ip+1==gen_info['nproj']):
            break
        #determine the irreducible representation
        dim_reps=[]
        n_reps=[]
        irep=[]
        for ish in range(n_inequiv_shells):
          isheq=inequiv_to_corr[ish]
          [n_reps,dim_reps,irep] = self.determine_rep(isheq,ish,corr_shells,basis,ind,n_reps,dim_reps,irep)
        for ish in range(n_shells):
          ishin=corr_to_inequiv[ish]
          corr_shells[ish].update({'SO':SO, 'irep':irep[ishin]})

      except StopIteration:  # a more explicit error if the file is corrupted.
          #raise "Elk_converter : reading PROJ.OUT file failed!"
          raise IOError("Elk_converter : reading PROJ.OUT file failed!")

      R.close()
      #output desired information
      return (gen_info,n_shells,n_inequiv_shells,corr_to_inequiv,inequiv_to_corr,corr_shells,n_reps,dim_reps,ind,basis,T)

    def determine_T(self,l):
        """
        Current version calculates the transformation matrix T to convert the inputs from spherical
        harmonics to the cubic basis (as used in TRIQS and Wien2k).
        This routine is currently very similar to spherical_to_cubic in the TRIQS library.
        This routine can be extended to include other unitary rotation matrices
        """
        from math import sqrt
        size=2*l+1
        T = numpy.zeros((size,size),dtype=complex)
        if(l == 0):
          T[0,0]= 1.0
        elif(l == 1):
          T[0,0] = 1.0/sqrt(2);   T[0,2] = -1.0/sqrt(2)
          T[1,0] = 1j/sqrt(2);    T[1,2] = 1j/sqrt(2)
          T[2,1] = 1.0
        elif l == 2:
          T[0,2] = 1.0
          T[1,0] = 1.0/sqrt(2);   T[1,4] = 1.0/sqrt(2)
          T[2,0] =-1.0/sqrt(2);   T[2,4] = 1.0/sqrt(2)
          T[3,1] = 1.0/sqrt(2);   T[3,3] =-1.0/sqrt(2)
          T[4,1] = 1.0/sqrt(2);   T[4,3] = 1.0/sqrt(2)
        elif l == 3:
        #This needs to be checked
          T[0,0] = 1.0/sqrt(2);    T[0,6] = -1.0/sqrt(2)
          T[1,1] = 1.0/sqrt(2);    T[1,5] = 1.0/sqrt(2)
          T[2,2] = 1.0/sqrt(2);    T[2,4] = -1.0/sqrt(2)
          T[3,3] = 1.0
          T[4,2] = 1j/sqrt(2);   T[4,4] = 1j/sqrt(2)
          T[5,1] = 1j/sqrt(2);   T[5,5] = -1j/sqrt(2)
          T[6,0] = 1j/sqrt(2);   T[6,6] = 1j/sqrt(2)
        else: raise ValueError("determine: implemented only for l=0,1,2,3")
        return numpy.matrix(T)


    def determine_rep(self,ish,ishin,corr_shells,basis,ind,n_reps,dim_reps,irep):
      """
      Determines the irreducible representation used for projection calculation.
      Only for Cubic harmonics at the moment
      """
      #if all of the orbitals were used to construct the projectors
      rep=corr_shells[ish]['dim']
      if(rep==2*corr_shells[ish]['l']+1):
         n_reps.append(1)
         dim_reps.append([corr_shells[ish]['dim']])
         irep.append(1)
      #if a subset of obitals were used for generating the projectors (l>1)
      #if Elk generated T matrix is used
      elif((basis[ish]==2)&(corr_shells[ish]['l']>1)):
         if (corr_shells[ish]['l']==2):
            n_reps.append(2)
            dim_reps.append([3, 2])
            irep.append(dim_reps[ishin].index(rep)+1)
         elif (corr_shells[ish]['l']==3):
            n_reps.append(3)
            dim_reps.append([1, 3, 3])
      #cubic T matrix
      elif((basis[ish]==1)&(corr_shells[ish]['l']>1)):
         if (corr_shells[ish]['l']==2):
            n_reps.append(2)
            dim_reps.append([2, 3])
            irep.append(dim_reps[ishin].index(rep)+1)
         elif (corr_shells[ish]['l']==3):
            n_reps.append(3)
            dim_reps.append([2, 2, 3])
      #determine the dim_reps from the lm indices in ind
            if(rep==3):
              irep.append(3)
            else:
              for i in range(2):
                #look for ind[i]==0
                if(ind[i]==0):
                  irep.append(1)
                  break
                #default to irep=2
                elif(i==1):
                  irep.append(2)

      else:
         raise ValueError("Elk_converter (determine_rep) : irreducible representations were not found!")

      return (n_reps,dim_reps,irep)

    def read_projector(self,shell,n_spin_blocks,ish,proj_mat,ind,T,basis,filext):
        """
        This function reads the contents of WANPROJ_L**_S**_A****.OUT
        """
        import string
        l = str(shell[ish]['l']).zfill(2)
        s = str(shell[ish]['sort']).zfill(2)
        a = str(shell[ish]['spatom']).zfill(4)
        #construct file name from atoms info
        wan_shells_file = 'WANPROJ_L'+l+'_S'+s+'_A'+a+filext
        R = self.read_elk_file(wan_shells_file, self.fortran_to_replace)
        try:
        #no. of kpts and number of orbital
          gen_entries = ['n_k', 'lmmax','dim_rep']
          gen = {name: int(val) for name, val in zip(gen_entries, R)}
          #projector lm size
          dim=gen['lmmax']
          #no. of lm used to construct projector
          dim_rep=gen['dim_rep']
          lat=[]
          n_k=gen['n_k']
          n_orbitals = numpy.zeros([n_k, n_spin_blocks], int)
          band_window = [None for isp in range(n_spin_blocks)]
          for isp in range(n_spin_blocks):
            band_window[isp] = numpy.zeros([n_k, 2], dtype=int)
          for ik in range(0,n_k):
          #k-point index and correlated band window indices
             lat_entries =  ['ik','vklx','vkly','vklz']
             lat.append({name: int(val) for name, val in zip(lat_entries, R)})
             #loop over each spin
             for isp in range(0,n_spin_blocks):
               #band window indices
               proj_entries = ['isp', 'ist_min','ist_max']
               proj_dim={name: int(val) for name, val in zip(proj_entries, R)}
               if(isp+1!=proj_dim['isp']):
                 raise IOError("Elk_converter (",wan_shells_file,") : reading spin projecotrs failed!")
                 return
               #setting band window arrays
               n_orbitals[ik,isp]=proj_dim['ist_max']-proj_dim['ist_min']+1
               band_window[isp][ik, 0] = proj_dim['ist_min']
               band_window[isp][ik, 1] = proj_dim['ist_max']
               #define temporary matrix for reading in the projectors
               mat = numpy.zeros([dim, n_orbitals[ik,isp]], complex)
               # Real part
               for j in range(dim):
                  for i in range(n_orbitals[ik,isp]):
                     mat[j, i] = next(R)
               # Imag part:
               for j in range(dim):
                  for i in range(n_orbitals[ik,isp]):
                     mat[j, i] += 1j * next(R)
               #rotate projectors into basis T
               if(basis[ish]!=0):
                  mat[:,:]=numpy.matmul(T[ish],mat[:,:])

               #put desired projector subset into master array
               proj_mat[ik,isp,ish,0:dim_rep,0:n_orbitals[ik,isp]]=mat[ind[ish],0:n_orbitals[ik,isp]]
               #delete temporary index
               del mat
          #resize array length of band indices to maximum number used
          proj_mat=proj_mat[:,:,:,:,:numpy.max(n_orbitals)]

        except StopIteration:  # a more explicit error if the file is corrupted.
            raise IOError("Elk_converter (read projectors): reading file failed!")
        R.close()
        return(n_orbitals,band_window,dim_rep,proj_mat)

    def read_eig(self,filext=".OUT"):
        """
        This function reads the contents of EIGVAL.OUT and EFERMI.OUT
        """
        import string
        #construct file name from atoms info
        R = self.read_elk_file( self.efermi_file, self.fortran_to_replace)
        try:
          efermi=next(R)
        except StopIteration:  # a more explicit error if the file is corrupted.
            raise IOError("Elk_converter (EFERMI.OUT): reading file failed!")
        eval_file = 'EIGVAL'+filext
        R = self.read_elk_file( eval_file, self.fortran_to_replace)
        try:
        #no. of kpts
          n_k=int(next(R))
        #no. second variation states (no. bands)
          nstsv=int(next(R))
          en=[]
          occ=[]
          kp2=[]
          for ik in range(0,n_k):
            #k index and corresponing lattice coordinates
            k_entries = ['ik', 'vklx','vkly','vklz']
            kp2.append([{name: val for name, val in zip(k_entries, R)}])
            en.append([])
            occ.append([])
            for ist in range(0,nstsv):
            #stores the band index, energy eigenvalues and occupancies
              en_entries = ['ist', 'hopping','occ']
              read_en={name: val for name, val in zip(en_entries, R)}
            #Energy eigenvalues and occupations
              en[ik].append(read_en['hopping']-efermi)
              occ[ik].append(read_en['occ'])

        except StopIteration:  # a more explicit error if the file is corrupted.
            raise IOError("Elk_converter (EIGVAL.OUT): reading file failed!")
        R.close()
        return(en,occ,nstsv)

    def read_kpoints(self,filext=".OUT"):
        """
        This function reads the contents of KPOINTS.OUT
        """
        import string
        kp_file = 'KPOINTS'+filext
        R = self.read_elk_file( kp_file, self.fortran_to_replace)
        try:
        #no. of kpts
          n_k=int(next(R))
          kp=[]
        #reads in the k index, lattice vectors, weights and nmat for each kpt
          #array for bz weights
          bz_weights = numpy.ones([n_k], float) / float(n_k)
          #array for lattice vectors
          vkl = numpy.ones([n_k,3], float)
          for ik in range(n_k):
          #k-grid info
            k_entries = ['ik', 'vklx','vkly','vklz', 'bz_weights', 'nmat']
            kp.append({name: val for name, val in zip(k_entries, R)})
          #convert to integers
            kp[ik]['ik']=int(kp[ik]['ik'])
          #read in BZ weights
            bz_weights[ik]=kp[ik]['bz_weights']
            j=0
            for i in range(1,4):
              vkl[ik,j]=kp[ik][k_entries[i]]
              j=j+1
        except StopIteration:  # a more explicit error if the file is corrupted.
            raise IOError("Elk_converter (KPOINTS.OUT): reading file failed!")
        R.close()
        return(bz_weights,vkl)

    def readsym(self):
        """
        Read in the (crystal) symmetries in lattice coordinates
        """
        dft_file='SYMCRYS.OUT'
        R = self.read_elk_file2( dft_file, self.fortran_to_replace)
        try:
          symmat=[]
          spinmat=[]
          tr=[]
          #read the number of crystal symmetries
          x = next(R)
          nsym = int(atof(x[0]))
          #set up symmetry matrices
          for isym in range(nsym):
            symmat.append(numpy.zeros([3, 3], float))
            spinmat.append(numpy.zeros([3, 3], float))
            tr.append(numpy.zeros([3], float))
          #read each symmetry
          for isym in range(nsym):
            #read the symmetry index and check it
            x = next(R)
            isymm = int(x[3])
            if(isym+1!=isymm):
              raise IOError("Elk_converter : reading symmetries failed!")
            #next read has no useful infomation
            x = next(R)
            #read in the translation vector used for symmetries
            x = next(R)
            for i in range(3):
              tr[isym][i]=atof(x[i])
            #read in the spatial symmetries
            #string with no useful information
            x = next(R)
            #read in the spatial symmetry
            for i in range(3):
              x = next(R)
              for j in range(3):
                symmat[isym][i,j]=int(atof(x[j]))
            #string with no useful information
            x = next(R)
            #read in the spin symmetries
            for i in range(3):
              x = next(R)
              for j in range(3):
                spinmat[isym][i,j]=int(atof(x[j]))

        except StopIteration:  # a more explicit error if the file is corrupted.
          raise IOError("Elk_converter : reading SYMCRYS.OUT file failed!")
        R.close()
        return nsym,spinmat,symmat,tr

    def readlat(self):
        """
        Read in information about the lattice.
        """
        dft_file='LATTICE.OUT'
        R = self.read_elk_file2( dft_file, self.fortran_to_replace)
        try:
          amat = numpy.zeros([3, 3], float)
          amatinv = numpy.zeros([3, 3], float)
          bmat = numpy.zeros([3, 3], float)
          bmatinv = numpy.zeros([3, 3], float)
          #real space lattice matrices
          #cycling through information which is not needed
          for i in range(4):
            x = next(R)
          #reading in the lattice vectors as matrix
          for i in range(3):
            x = next(R)
            for j in range(3):
              amat[i,j] = atof(x[j])
          #cycling through information which is not needed
          x = next(R)
          #reading in the inverse lattice matrix
          for i in range(3):
            x = next(R)
            for j in range(3):
              amatinv[i,j] = atof(x[j])
          #read in cell volume (for transport)
          x = next(R)
          cell_vol = atof(x[-1])    
          #cycling through information which is not needed
          for i in range(4):
            x = next(R)
          #reading in the reciprocal lattice vectors as matrix
          for i in range(3):
            x = next(R)
            for j in range(3):
              bmat[i,j] = atof(x[j])
          #cycling through information which is not needed
          x = next(R)
          #reading in the inverse reciprocal lattice matrix
          for i in range(3):
            x = next(R)
            for j in range(3):
              bmatinv[i,j] = atof(x[j])

        except StopIteration:  # a more explicit error if the file is corrupted.
          raise IOError("Elk_converter : reading PROJ.OUT file failed!")
        R.close()
        return amat,amatinv,bmat,bmatinv,cell_vol

    def read_geometry(self):
      """
      This function reads the contents of GEOMETRY.OUT
      """
      import string
      #read in the Geometery file
      dft_file='GEOMETRY.OUT'
      #atom positions in lattice coordinates
      R = self.read_elk_file2( dft_file, self.fortran_to_replace)
      nspecies=0
      na=[]
      atpos_entries = ['kx', 'ky','kz','Bkx', 'Bky', 'Bkz']
      atpos=[]
      try:
         i=0
         #cycle through file until "atoms" is found
         while(i<1000):
           x = next(R)
           if "atoms" in x:
             break
           elif(i==1000):
             raise IOError("Elk_converter : Could not find 'atoms' in GEOMETRY.OUT!")
           i+=1
         #read in the number of species
         x = next(R)
         ns = int(atof(x[0]))
         #loop over species
         for js in range(ns):
           #Skip species name
           x = next(R)
           #read in the number of atoms per species
           x = next(R)
           na.append(int(atof(x[0])))
           #loop over atomss pre species
           atpos.append([])
           for ia in range(na[js]):
             atpos[js].append(numpy.zeros(6, float))
             x = next(R)
             for j in range(6):
               atpos[js][ia][j]=atof(x[j])
      except StopIteration:  # a more explicit error if the file is corrupted.
        raise IOError("Elk_converter : Could not open GEOMETRY.OUT!")
      R.close()
      return ns, na, atpos

#commented out for now - unsure this will produce DFT+DMFT PDOS
##band character dependent calculations
#    def read_bc(self,fileext):
#        """
#        Read in the ELK generated band characters from BC.OUT
#        """

#        #import string
#        file = 'BC'+fileext
#        R = self.read_elk_file(file, self.fortran_to_replace)
#        try:
#        #no. of kpts and number of orbital
#          gen_entries = ['maxlm', 'nspinor','natmtot','nstsv','nkpt','irep']
#          gen = {name: int(val) for name, val in zip(gen_entries, R)}
#          #projector lm size
#          #check the read in information complies with previous read in data
#          nspinor=self.SP+1
#          if(gen['nspinor'] != nspinor):
#            mpi.report('HDF file nspinor = %s'%nspinor)
#            mpi.report('BC.OUT nspinor = %s'%gen['nspinor'])
#            raise IOError("Elk_converter (",file,") : reading nspinor failed!")
#            return
#          if(gen['natmtot'] != self.n_atoms):
#            raise IOError("Elk_converter (",file,") : reading no. of atoms failed!")
#            return
#          if(gen['nstsv'] != self.nstsv):
#            raise IOError("Elk_converter (",file,") : reading all states failed!")
#            return
#          if(gen['nkpt'] != self.n_k):
#            raise IOError("Elk_converter (",file,") : reading kpoints failed failed!")
#            return
#          if(gen['irep'] == 0):
#            raise IOError("Elk_converter (",file,") : Band characters are in spherical hamonics, may have issues with the PDOS!")
#            return

#          dim=gen['maxlm']
#          lmax=numpy.sqrt(dim)-1
#          bc = numpy.zeros([dim,nspinor,self.n_atoms,self.nstsv,self.n_k], float)

#          for ik in range(0,self.n_k):
#            for iatom in range(0,self.n_atoms):
#              for ispn in range(0,nspinor):
#                entry =  ['ispn','ias','is','ia','ik']
#                ent = {name: int(val) for name, val in zip(entry, R)}
#          #k-point index and correlated band window indices
#          #check read in values
#                if(ent['ispn'] != ispn+1):
#                  raise IOError("Elk_converter (",file,") : reading ispn failed!")
#                  return
#                if(ent['ias'] != iatom+1):
#                  raise IOError("Elk_converter (",file,") : reading iatom failed!")
#                  return
#                if(ent['ik'] != ik+1):
#                  raise IOError("Elk_converter (",file,") : reading ik failed!")
#                  return

#                for ist in range(self.nstsv):
#                  for lm in range(dim):
#                     bc[lm,ispn,iatom,ist,ik] = next(R)

#        except StopIteration:  # a more explicit error if the file is corrupted.
#            raise IOError("Elk_converter (read BC.OUT): reading file failed!")
#        R.close()
#        return(bc,dim)