def plot_timestep_convergence(self):
        from matplotlib.pyplot import figure,subplot,xlabel,ylabel,plot,errorbar,title,text,xticks,rcParams,savefig,xlim

        params = {'legend.fontsize':14,'figure.facecolor':'white','figure.subplot.hspace':0.,
          'axes.labelsize':16,'xtick.labelsize':14,'ytick.labelsize':14}
        rcParams.update(params) 


        timesteps = self.timesteps
        energies  = convert(self.energies.copy(),'Ha','eV')
        errors    = convert(self.errors.copy(),'Ha','eV')
        Esmall = energies[0]

        figure()
        tsrange = [0,1.1*timesteps[-1]]
        plot(tsrange,[0,0],'k-')
        errorbar(timesteps,energies-Esmall,errors,fmt='k.')
        text(array(tsrange).mean(),0,'{0:6.4f} eV'.format(Esmall))
        xticks(timesteps)
        xlim(tsrange)
        xlabel('Timestep (Ha)')
        ylabel('Total Energy (eV)')
        title('DMC Timestep Convergence')

        savefig('TimestepConvergence.png',format='png',bbox_inches ='tight',pad_inches=1)
Exemple #2
0
    def change_specifier(self,new_specifier,pwi):
        scale,axes = pwi.get_common_vars('scale','axes')

        pos = self.positions

        spec = self.specifier
        if spec=='alat' or spec=='':
            pos *= scale
        elif spec=='bohr':
            None
        elif spec=='angstrom':
            pos *= convert(1.,'A','B')
        elif spec=='crystal':
            pos = dot(pos,axes)
        else:
            self.error('old specifier for atomic_positions is invalid\n  old specifier: '+spec+'\n  valid options: alat, bohr, angstrom, crystal')
        #end if

        spec = new_specifier
        if spec=='alat' or spec=='':
            pos /= scale
        elif spec=='bohr':
            None
        elif spec=='angstrom':
            pos /= convert(1.,'A','B')
        elif spec=='crystal':
            pos = dot(pos,inv(axes))
        else:
            self.error('new specifier for atomic_positions is invalid\n  new specifier: '+spec+'\n  valid options: alat, bohr, angstrom, crystal')
        #end if
            
        self.positions = pos
        self.specifier = new_specifier
Exemple #3
0
 def plot(self,style='',rmax=4,vcoul=False,ptitle=None,mult=1,units='eV',lw=2):
     colors = self.lcolors
     r = self.r
     rc= self.rcut
     Z = self.Z
     if mult=='r':
         mult = r
     #end if
     vmin = 1e55
     vmax = -1e55
     for l,vpot in self.potentials.iteritems():
         pot = convert(mult*vpot,self.energy_units,units)
         vmin = min(vmin,pot.min())
         vmax = max(vmax,pot.max())
         plot(r,pot,colors[l]+style,lw=lw,label=self.ldict[l])
     #end for
     if vcoul:
         vcoul = convert(-Z/r,'Ha',units)
         vin = vcoul>vmin
         plot(r[vin],mult*vcoul[vin],'k-.')
     #dnd if
     plot([rc,rc],[vmin,vmax],'k-.',lw=lw)
     if rmax!=None:
         xlim([0,rmax])
     #end if
     if ptitle is None:
         title('Channel potentials for '+self.element+' '+self.type+' pseudopotential')
     else:
         title(ptitle)
     #end if
     ylabel('Potential Energy ({0})'.format(units))
     xlabel('Radius (bohr)')
     legend()
Exemple #4
0
def morse_rDw_fit(re,De,w,m1,m2=None,Einf=0.0,Dunit='eV'):
    alpha = 7.2973525698e-3            # fine structure constant
    m     = morse_reduced_mass(m1,m2)  # reduced mass
    ocm_to_oB = 1./convert(.01,'m','B')# conversion from 1/cm to 1/Bohr
    w    *= ocm_to_oB                  # convert from 1/cm to 1/Bohr
    re    = convert(re,'A','B')        # convert from Angstrom to Bohr
    De    = convert(De,Dunit,'Ha')     # convert from input energy unit
    wX    = (pi*w**2)/(2*alpha*De)     # get wX
    a     = sqrt(4*pi*m*wX/alpha)      # get the 'a' parameter
    p     = morse_params(re,a,De,Einf) # get the internal fit parameters
    return p
Exemple #5
0
def morse_spect_fit(re, w, wX, m1, m2=None, Einf=0.0):
    alpha = 7.2973525698e-3  # fine structure constant
    m = morse_reduced_mass(m1, m2)  # reduced mass
    ocm_to_oB = 1. / convert(.01, 'm', 'B')  # conversion from 1/cm to 1/Bohr
    w *= ocm_to_oB  # convert from 1/cm to 1/Bohr
    wX *= ocm_to_oB  # convert from 1/cm to 1/Bohr
    re = convert(re, 'A', 'B')  # convert from Angstrom to Bohr
    a = sqrt(4 * pi * m * wX / alpha)  # get the 'a' parameter
    De = (pi * w**2) / (2 * alpha * wX)  # get the 'De' parameter
    p = morse_params(re, a, De, Einf)  # get the internal fit parameters
    return p
Exemple #6
0
def morse_rDw_fit(re, De, w, m1, m2=None, Einf=0.0, Dunit='eV'):
    alpha = 7.2973525698e-3  # fine structure constant
    m = morse_reduced_mass(m1, m2)  # reduced mass
    ocm_to_oB = 1. / convert(.01, 'm', 'B')  # conversion from 1/cm to 1/Bohr
    w *= ocm_to_oB  # convert from 1/cm to 1/Bohr
    re = convert(re, 'A', 'B')  # convert from Angstrom to Bohr
    De = convert(De, Dunit, 'Ha')  # convert from input energy unit
    wX = (pi * w**2) / (2 * alpha * De)  # get wX
    a = sqrt(4 * pi * m * wX / alpha)  # get the 'a' parameter
    p = morse_params(re, a, De, Einf)  # get the internal fit parameters
    return p
Exemple #7
0
def morse_spect_fit(re,w,wX,m1,m2=None,Einf=0.0):
    alpha = 7.2973525698e-3            # fine structure constant
    m     = morse_reduced_mass(m1,m2)  # reduced mass
    ocm_to_oB = 1./convert(.01,'m','B')# conversion from 1/cm to 1/Bohr
    w    *= ocm_to_oB                  # convert from 1/cm to 1/Bohr
    wX   *= ocm_to_oB                  # convert from 1/cm to 1/Bohr
    re    = convert(re,'A','B')        # convert from Angstrom to Bohr
    a     = sqrt(4*pi*m*wX/alpha)      # get the 'a' parameter
    De    = (pi*w**2)/(2*alpha*wX)     # get the 'De' parameter
    p     = morse_params(re,a,De,Einf) # get the internal fit parameters
    return p
 def summarize(self,units='eV',header=True):
     timesteps = self.timesteps
     energies  = convert(self.energies.copy(),'Ha',units)
     errors    = convert(self.errors.copy(),'Ha',units)
     Esmall = energies[0]
     if header:
         print 'Timestep study summary:'
         print '======================'
     #end if
     for i in range(len(timesteps)):
         ts,E,Eerr = timesteps[i],energies[i],errors[i]
         print '    {0:>6.4f}   {1:>6.4f} +/- {2:>6.4f}'.format(ts,E-Esmall,Eerr)
 def summarize(self, units="eV", header=True):
     timesteps = self.timesteps
     energies = convert(self.energies.copy(), "Ha", units)
     errors = convert(self.errors.copy(), "Ha", units)
     Esmall = energies[0]
     if header:
         print "Timestep study summary:"
         print "======================"
     # end if
     for i in range(len(timesteps)):
         ts, E, Eerr = timesteps[i], energies[i], errors[i]
         print "    {0:>6.4f}   {1:>6.4f} +/- {2:>6.4f}".format(ts, E - Esmall, Eerr)
Exemple #10
0
    def readfile(self, filepath):
        x = readxml(filepath, contract_names=True)
        x.convert_numeric()
        x.condense()
        x.remove_hidden()
        pp = x.pseudo
        self.pp = pp

        h = pp.header
        self.element = h.symbol
        self.type = h.flavor
        self.Z = h.zval
        vps = self.pp.semilocal.vps
        if not isinstance(vps, list):
            vps = [vps]
        #end if
        g = vps[0].radfunc.grid
        if g.type == 'linear':
            r = linspace(g.ri, g.rf, g.npts)
            self.r = r[1:]
        else:
            self.error('functionality for ' + g.type +
                       ' grids has not yet been implemented')
        #end if
        p = obj()
        r = self.r
        ldict = dict(s=0, p=1, d=2, f=3)
        for vp in vps:
            l = vp.l
            v = 1. / r * vp.radfunc.data[1:]
            p[ldict[l]] = convert(v, 'Ha', self.energy_units)
        #end for
        self.potentials = p
Exemple #11
0
 def summarize(self, units="eV", norm=1.0, energy=True, variance=True, header=True):
     if isinstance(norm, str):
         norm = norm.replace("_", " ").replace("-", " ")
         if norm == "per atom":
             norm = len(self.info.system.structure.elem)
         else:
             self.error('norm must be a number or "per atom"\n you provided ' + norm)
         # end if
     # end if
     econv = convert(1.0, "Ha", units) / norm
     en = econv * self.energy
     enerr = econv * self.energy_error
     va = econv ** 2 * self.variance
     vaerr = econv ** 2 * self.variance_error
     emax = en.max()
     vmax = va.max()
     if header:
         print "Optimization summary:"
         print "===================="
     # end if
     if energy:
         if header:
             print "  Energies ({0}):".format(units)
         # end if
         for i in range(len(en)):
             print "    {0:>2}    {1:9.6f} +/-{2:9.6f}".format(i, en[i] - emax, enerr[i])
         # end for
         print "    ref {0:9.6f}".format(emax)
     # end if
     if variance:
         if header:
             print "  Variances ({0}^2):".format(units)
         # end if
         for i in range(len(en)):
             print "    {0:>2}    {1:9.6f} +/- {2:9.6f}".format(i, va[i], vaerr[i])
Exemple #12
0
    def make_movie(self, filename, filepath=None):
        if 'structures' in self:
            from structure import Structure
            if filepath == None:
                filepath = os.path.join(self.abspath, filename)
            else:
                filepath = os.path.join(filepath, filename)
            #end if
            movie = ''
            structures = self.structures

            print structures

            aA = convert(self.input.system['celldm(1)'], 'B', 'A')
            cell = self.input.cell_parameters.vectors
            for i in range(len(structures)):
                s = structures[i]
                struct = Structure(elem=s.atoms,
                                   pos=s.positions,
                                   axes=cell,
                                   scale=aA,
                                   units='A')
                struct = struct.tile(2, 2, 2)
                ss = struct.write_xyz()
                movie += ss
                open(filepath, 'w').write(movie)
Exemple #13
0
    def test_morse_fit():
        import numpy as np
        from testing import value_eq
        from unit_converter import convert
        from numerics import morse
        from numerics import morse_rDw_fit,morse_fit,morse_fit_fine

        r_ref,D_ref,w_ref = 1.620,6.87,1009.18
        r_ref_A = r_ref
        p = morse_rDw_fit(r_ref,D_ref,w_ref,'Ti','O',Dunit='eV')

        r_ref = convert(r_ref,'A','B')


        rfine = np.linspace(0.8*r_ref,1.2*r_ref,100)
        Efine = morse(p,rfine)

        pf = morse_fit(rfine,Efine,p)

        pref = tuple(np.array(p,dtype=float))
        pf   = tuple(np.array(pf,dtype=float))

        assert(value_eq(pf,pref))

        pf,Ef = morse_fit_fine(rfine,Efine,p,rfine,both=True)
        pf   = tuple(np.array(pf,dtype=float))
        assert(value_eq(pf,pref))
        assert(value_eq(Ef,Efine))
Exemple #14
0
def morse_freq(p, m1, m2=None):
    alpha = 7.2973525698e-3  # fine structure constant
    c = 1. / alpha  # speed of light, hartree units
    m = morse_reduced_mass(m1, m2)  # reduced mass
    lam = 2 * pi * c * sqrt(m / morse_k(p))  # wavelength
    freq = 1. / (convert(lam, 'B', 'm') * 100)
    return freq
Exemple #15
0
    def readfile(self,filepath):
        text = TextFile(filepath)
        Zatom,Z = text.read_tokens('Atomic number and pseudo-charge',int,float)
        if Zatom>len(pt.simple_elements):
            self.error('element {0} is not in the periodic table')
        #end if
        element = pt.simple_elements[Zatom].symbol
        units = text.read_tokens('Energy units',str)
        if not units in self.unitmap:
            self.error('units {0} unrecognized from casino PP file {1}'.format(units,filepath))
        #end if
        lloc = text.read_tokens('Angular momentum of local component',int)
        ngrid = text.read_tokens('Number of grid points',int)
        i = text.find_line('R(i)',exit=True)+1
        r = empty((ngrid,),dtype=float)
        for ir in xrange(ngrid):
            r[ir] = float(text.lines[i])
            i+=1
        #end for
        r=r[1:]
        p = obj()
        while i<len(text.lines):
            line = text.lines[i]
            if 'potential' in line:
                eqloc = line.find('=')
                if eqloc==-1:
                    self.error('"=" not found in potential line')
                #end if
                l = int(line[eqloc+1])
                i+=1
                if i+ngrid>len(text.lines):
                    self.error('potentials in file {0} are not the right length'.format(filepath))
                #end if
                v = empty((ngrid,),dtype=float)
                for ir in xrange(ngrid):
                    v[ir] = float(text.lines[i])
                    i+=1
                #end for
                p[l] = v[1:]/r
            #end if
        #end while

        for l in p.keys():
            p[l] = convert(p[l],self.unitmap[units],self.energy_units)
        #end for

        self.set(
            element = element,
            type = 'Trail-Needs',
            Z = Z,
            r = r,
            potentials = p,
            pp = obj(
                Zatom = Zatom,
                Z     = Z,
                units = units,
                lloc  = lloc,
                ngrid = ngrid
                )
            )
 def summarize(self,units='eV',norm=1.,energy=True,variance=True,header=True):
     if isinstance(norm,str):
         norm = norm.replace('_',' ').replace('-',' ')
         if norm=='per atom':
             norm = len(self.info.system.structure.elem)
         else:
             self.error('norm must be a number or "per atom"\n you provided '+norm)
         #end if
     #end if
     econv = convert(1.0,'Ha',units)/norm
     en    = econv*self.energy
     enerr = econv*self.energy_error
     va    = econv**2*self.variance
     vaerr = econv**2*self.variance_error
     emax = en.max()
     vmax = va.max()
     if header:
         print 'Optimization summary:'
         print '===================='
     #end if
     if energy:
         if header:
             print '  Energies ({0}):'.format(units)
         #end if
         for i in range(len(en)):
             print '    {0:>2}    {1:9.6f} +/-{2:9.6f}'.format(i,en[i]-emax,enerr[i])
         #end for
         print '    ref {0:9.6f}'.format(emax)
     #end if
     if variance:
         if header:
             print '  Variances ({0}^2):'.format(units)
         #end if
         for i in range(len(en)):
             print '    {0:>2}    {1:9.6f} +/- {2:9.6f}'.format(i,va[i],vaerr[i])
Exemple #17
0
def morse_freq(p,m1,m2=None): 
    alpha = 7.2973525698e-3           # fine structure constant
    c     = 1./alpha                  # speed of light, hartree units
    m     = morse_reduced_mass(m1,m2) # reduced mass
    lam   = 2*pi*c*sqrt(m/morse_k(p)) # wavelength
    freq  = 1./(convert(lam,'B','m')*100)
    return freq
Exemple #18
0
    def readfile(self,filepath):
        x = readxml(filepath,contract_names=True)
        x.convert_numeric()
        x.condense()
        x.remove_hidden()
        pp = x.pseudo
        self.pp = pp

        h = pp.header
        self.element = h.symbol
        self.type = h.flavor        
        self.Z    = h.zval
        vps = self.pp.semilocal.vps
        if not isinstance(vps,list):
            vps = [vps]
        #end if
        g = vps[0].radfunc.grid
        if g.type=='linear':
            r = linspace(g.ri,g.rf,g.npts)
            self.r = r[1:]
        else:
            self.error('functionality for '+g.type+' grids has not yet been implemented')
        #end if
        p = obj()
        r = self.r
        ldict = dict(s=0,p=1,d=2,f=3)
        for vp in vps:
            l = vp.l
            v = 1./r*vp.radfunc.data[1:]
            p[ldict[l]]= convert(v,'Ha',self.energy_units)
        #end for
        self.potentials = p
Exemple #19
0
 def change_distance_units(self, units):
     units_old = self.get_attribute('distance_units')
     rscale = 1.0 / convert(1.0, units_old, units)
     dscale = 1. / rscale**3
     grid = self.get_attribute('grid')
     grid.points *= rscale
     for c in self.components():
         c.values *= dscale
Exemple #20
0
    def readfile(self, filepath):
        text = TextFile(filepath)
        Zatom, Z = text.read_tokens('Atomic number and pseudo-charge', int,
                                    float)
        if Zatom > len(pt.simple_elements):
            self.error('element {0} is not in the periodic table')
        #end if
        element = pt.simple_elements[Zatom].symbol
        units = text.read_tokens('Energy units', str)
        if not units in self.unitmap:
            self.error('units {0} unrecognized from casino PP file {1}'.format(
                units, filepath))
        #end if
        lloc = text.read_tokens('Angular momentum of local component', int)
        ngrid = text.read_tokens('Number of grid points', int)
        i = text.find_line('R(i)', exit=True) + 1
        r = empty((ngrid, ), dtype=float)
        for ir in xrange(ngrid):
            r[ir] = float(text.lines[i])
            i += 1
        #end for
        r = r[1:]
        p = obj()
        while i < len(text.lines):
            line = text.lines[i]
            if 'potential' in line:
                eqloc = line.find('=')
                if eqloc == -1:
                    self.error('"=" not found in potential line')
                #end if
                l = int(line[eqloc + 1])
                i += 1
                if i + ngrid > len(text.lines):
                    self.error(
                        'potentials in file {0} are not the right length'.
                        format(filepath))
                #end if
                v = empty((ngrid, ), dtype=float)
                for ir in xrange(ngrid):
                    v[ir] = float(text.lines[i])
                    i += 1
                #end for
                p[l] = v[1:] / r
            #end if
        #end while

        for l in p.keys():
            p[l] = convert(p[l], self.unitmap[units], self.energy_units)
        #end for

        self.set(element=element,
                 type='Trail-Needs',
                 Z=Z,
                 r=r,
                 potentials=p,
                 pp=obj(Zatom=Zatom, Z=Z, units=units, lloc=lloc, ngrid=ngrid))
Exemple #21
0
    def plot_timestep_convergence(self):
        from matplotlib.pyplot import (
            figure,
            subplot,
            xlabel,
            ylabel,
            plot,
            errorbar,
            title,
            text,
            xticks,
            rcParams,
            savefig,
            xlim,
        )

        params = {
            "legend.fontsize": 14,
            "figure.facecolor": "white",
            "figure.subplot.hspace": 0.0,
            "axes.labelsize": 16,
            "xtick.labelsize": 14,
            "ytick.labelsize": 14,
        }
        rcParams.update(params)

        timesteps = self.timesteps
        energies = convert(self.energies.copy(), "Ha", "eV")
        errors = convert(self.errors.copy(), "Ha", "eV")
        Esmall = energies[0]

        figure()
        tsrange = [0, 1.1 * timesteps[-1]]
        plot(tsrange, [0, 0], "k-")
        errorbar(timesteps, energies - Esmall, errors, fmt="k.")
        text(array(tsrange).mean(), 0, "{0:6.4f} eV".format(Esmall))
        xticks(timesteps)
        xlim(tsrange)
        xlabel("Timestep (Ha)")
        ylabel("Total Energy (eV)")
        title("DMC Timestep Convergence")

        savefig("TimestepConvergence.png", format="png", bbox_inches="tight", pad_inches=1)
Exemple #22
0
 def plot(self,
          style='',
          rmax=4,
          vcoul=False,
          ptitle=None,
          mult=1,
          units='eV',
          lw=2):
     colors = self.lcolors
     r = self.r
     rc = self.rcut
     Z = self.Z
     if mult == 'r':
         mult = r
     #end if
     vmin = 1e55
     vmax = -1e55
     for l, vpot in self.potentials.iteritems():
         pot = convert(mult * vpot, self.energy_units, units)
         vmin = min(vmin, pot.min())
         vmax = max(vmax, pot.max())
         plot(r, pot, colors[l] + style, lw=lw, label=self.ldict[l])
     #end for
     if vcoul:
         vcoul = convert(-Z / r, 'Ha', units)
         vin = vcoul > vmin
         plot(r[vin], mult * vcoul[vin], 'k-.')
     #dnd if
     plot([rc, rc], [vmin, vmax], 'k-.', lw=lw)
     if rmax != None:
         xlim([0, rmax])
     #end if
     if ptitle is None:
         title('Channel potentials for ' + self.element + ' ' + self.type +
               ' pseudopotential')
     else:
         title(ptitle)
     #end if
     ylabel('Potential Energy ({0})'.format(units))
     xlabel('Radius (bohr)')
     legend()
def read_eshdf_eig_data(filename, Ef_list):
    import numpy as np
    from numpy import array, pi
    from numpy.linalg import inv
    from unit_converter import convert
    from hdfreader import read_hdf
    from developer import error

    def h5int(i):
        return array(i, dtype=int)[0]

    #end def h5int

    h = read_hdf(filename, view=True)
    axes = array(h.supercell.primitive_vectors)
    kaxes = 2 * pi * inv(axes).T
    nk = h5int(h.electrons.number_of_kpoints)
    ns = h5int(h.electrons.number_of_spins)
    if len(Ef_list) != ns:
        msg = 'Ef "%s" must have same length as nspin=%d' % (str(Ef_list), ns)
        error(msg)
    data = obj()
    for k in range(nk):
        kp = h.electrons['kpoint_' + str(k)]
        for s, Ef in zip(range(ns), Ef_list):
            E_fermi = Ef + 1e-8
            eig_s = []
            path = 'electrons/kpoint_{0}/spin_{1}'.format(k, s)
            spin = h.get_path(path)
            eig = convert(array(spin.eigenvalues), 'Ha', 'eV')
            nst = h5int(spin.number_of_states)
            for st in range(nst):
                e = eig[st]
                if e < E_fermi:
                    eig_s.append(e)
                #end if
            #end for
            data[k, s] = obj(
                kpoint=array(kp.reduced_k),
                eig=array(eig_s),
            )
        #end for
    #end for
    res = obj(
        orbfile=filename,
        axes=axes,
        kaxes=kaxes,
        nkpoints=nk,
        nspins=ns,
        data=data,
    )
    return res
Exemple #24
0
    def test_eos_fit():
        import numpy as np
        from testing import value_eq
        from unit_converter import convert
        from numerics import eos_fit,eos_eval,eos_param

        data = np.array([
                [0.875, -83.31851261], 
                [0.900, -83.38085214], 
                [0.925, -83.42172843], 
                [0.950, -83.44502216], 
                [0.975, -83.45476035], 
                [1.025, -83.44564229], 
                [1.050, -83.43127254], 
                [1.000, -83.45412846], 
                [1.100, -83.39070714], 
                [1.125, -83.36663810], 
                ])

        a = 5.539 # lattice constant

        V = (a*data[:,0])**3
        E = convert(data[:,1],'Ry','eV')

        # done originally to get params below
        #pf = eos_fit(V,E,'vinet')

        Einf = -1.13547294e+03
        V0   =  1.62708941e+02
        B0   =  1.34467867e-01
        Bp0  =  4.55846963e+00

        pf = Einf,V0,B0,Bp0

        Ef = eos_eval(pf,V,'vinet')

        pf2 = eos_fit(V,Ef,'vinet')

        pf  = np.array(pf,dtype=float)
        pf2 = np.array(pf2,dtype=float)

        assert(value_eq(pf,pf2,atol=1e-3))
Exemple #25
0
    def make_movie(self,filename,filepath=None):
        if 'structures' in self:
            from structure import Structure
            if filepath==None:
                filepath = os.path.join(self.abspath,filename)
            else:
                filepath = os.path.join(filepath,filename)
            #end if
            movie = ''
            structures = self.structures

            aA = convert(self.input.system['celldm(1)'],'B','A')
            cell = self.input.cell_parameters.vectors
            for i in range(len(structures)):
                s = structures[i]
                struct = Structure(elem=s.atoms,pos=s.positions,axes=cell,scale=aA,units='A')
                struct=struct.tile(2,2,2)
                ss=struct.write_xyz()
                movie += ss
                open(filepath,'w').write(movie)
Exemple #26
0
def morse_wX(p, m1, m2=None):
    ocm = 1. / (convert(1.0, 'B', 'm') * 100)  # 1/Bohr to 1/cm
    alpha = 7.2973525698e-3  # fine structure constant
    m = morse_reduced_mass(m1, m2)  # reduced mass
    wX = (alpha * morse_a(p)**2) / (4 * pi * m)
    return wX
Exemple #27
0
dirs = os.listdir('./')

scales = []
energies = []
errors = []
for dir in dirs:
    if dir.startswith('scale_'):
        scale = float(dir.split('_')[1])
        infile = os.path.join(dir,prefix+'.in.xml')
        outfile = os.path.join(dir,prefix+'.s001.scalar.dat')
        if os.path.exists(outfile):
            qa = QmcpackAnalyzer(infile,analyze=True)
            le = qa.qmc[1].scalars.LocalEnergy
            scales.append(scale)
            E = convert(le.mean,'Ha','eV')
            Eerr = convert(le.error,'Ha','eV')
            E -= 2*Eatom
            Eerr = sqrt(Eerr**2+(2*Eatom_err)**2)
            energies.append(E)
            errors.append(Eerr)
        #end if
    #end if
#end for



se = 1.2074
ee = -5.165

seps = array(scales)*se
Exemple #28
0
from unit_converter import convert

from nexus import settings, job, obj, run_project
from nexus import generate_physical_system
from nexus import generate_rmg

settings(
    pseudo_dir='../../qmcpack/pseudopotentials',
    results='',
    sleep=3,
    machine='ws8',
)

# lattice constant for diamond
a = 3.57  # A
a = convert(a, 'A', 'B')

# RMG inputs shared for both manual and generated cell specification
shared_inputs = obj(
    # nexus inputs
    identifier='scf',
    job=job(cores=8, app='rmg-cpu'),
    pseudos=['C.BFD.xml'],
    input_type='generic',
    # control options
    calculation_mode='Quench Electrons',
    compressed_infile=False,
    compressed_outfile=False,
    description='diamond',
    energy_convergence_criterion=1.0e-09,
    max_scf_steps=100,
Exemple #29
0
def morse_wX(p,m1,m2=None):
    ocm   = 1./(convert(1.0,'B','m')*100) # 1/Bohr to 1/cm
    alpha = 7.2973525698e-3               # fine structure constant
    m     = morse_reduced_mass(m1,m2)     # reduced mass
    wX = (alpha*morse_a(p)**2)/(4*pi*m)
    return wX
Exemple #30
0
    def readfile(self, filepath):
        text = open(filepath, 'r').read()
        if '<UPF' not in text:
            upf_format = 'old'
            lines = text.split('\n')
            xml = '<upf>\n'
            for l in lines:
                if l.find('/>') != -1:
                    ln = l.replace('/>', '>').replace('<', '</')
                else:
                    ln = l
                #end if
                xml += ln + '\n'
            #end for
            xml += '</upf>\n'
            tmppath = filepath + '_tmp'
            open(tmppath, 'w').write(xml)
            x = readxml(tmppath, contract_names=True, strip_prefix='pp_')
            os.system('rm ' + tmppath)
            x.convert_numeric()
            x.condense()
            x.remove_hidden()
            pp = x.upf
        else:
            upf_format = 'new'
            #x = readxml(filepath,contract_names=True,strip_prefix='pp_')
            #x.convert_numeric()
            #x.condense()
            #x.remove_hidden()
            #pp = x.upf
            pp = obj()
            pp_contents = open(filepath, 'r').read()
        #end if
        if upf_format == 'old':
            lines = pp.header.split('\n')
            h = obj()
            i = 0
            h.version = string2val(lines[i].split()[0])
            i += 1
            h.element = string2val(lines[i].split()[0])
            i += 1
            h.type = string2val(lines[i].split()[0])
            i += 1
            ncc = string2val(lines[i].split()[0])
            i += 1
            h.nonlinear_cc = dict(T=True, F=False)[ncc]
            h.functional = lines[i].split()[0:4]
            i += 1
            h.Z = string2val(lines[i].split()[0])
            i += 1
            h.total_energy = string2val(lines[i].split()[0])
            i += 1
            h.wfc_cutoff, h.rho_cutoff = array(lines[i].split()[0:2],
                                               dtype=float)
            i += 1
            h.lmax = string2val(lines[i].split()[0])
            i += 1
            h.npts = string2val(lines[i].split()[0])
            i += 1
            h.nwfc = string2val(lines[i].split()[0])
            i += 1
            pp.header = h
            if 'beta' in pp. nonlocal:
                beta = pp. nonlocal .beta
                if isinstance(beta, str):
                    beta = [beta]
                #end if
                b = obj()
                for i in range(len(beta)):
                    sections = beta[i].split('\n', 2)
                    p = string2val(sections[0].split()[0])
                    v = string2val(sections[2])
                    b[p] = v
                #end for
                pp. nonlocal .beta = b
            #end if
            dij = pp. nonlocal .dij
            d = obj()
            lines = dij.split('\n')[1:]
            for l in lines:
                t = l.split()
                d[int(t[0]), int(t[1])] = string2val(t[2])
            #end for
            pp. nonlocal .dij = d
            pswfc = pp.pswfc
            tokens = pswfc.split()
            nwfc = pp.header.nwfc
            npts = pp.header.npts
            wf = []
            for n in range(nwfc):
                i = n * (4 + npts)
                label = tokens[i]
                l = int(tokens[i + 1])
                ws = []
                for v in tokens[i + 4:i + 4 + npts]:
                    ws.append(float(v))
                #end for
                orb = obj()
                orb.label = label
                orb.l = l
                orb.wfc = array(ws)
                wf.append(orb)
            #end for
            pp.pswfc = wf

            #fill in standard fields
            self.pp = pp
            self.r = pp.mesh.r[1:]
            self.local = convert(pp.local, 'Ry', self.energy_units)[1:]
            nl = obj()
            vnl = zeros(self.local.shape)
            if 'beta' in pp. nonlocal:
                beta = pp. nonlocal .beta
                for t, d in pp. nonlocal .dij.iteritems():
                    bi = beta[t[0]]
                    bj = beta[t[1]]
                    if not isinstance(bi, str) and not isinstance(bj, str):
                        bb = d * bi * bj
                    else:  # the file is being misread, fix later
                        bb = 0 * pp.mesh.r
                    #end if
                    naftcut = len(pp.mesh.r) - len(bb)
                    if naftcut > 0:
                        bb = append(bb, zeros((naftcut, )))
                    #end if
                    vnl += bb[1:] / self.r**2
                #end for
            #end if
            vnl = convert(vnl, 'Ry', self.energy_units)
            nl[0] = vnl
            self. nonlocal = nl
            h = pp.header
            p = obj()
            p[0] = self.local
            p[1] = self.local + self. nonlocal [0]
            self.potentials = p
            self.element = h.element
            self.type = h.type
            self.Z = h.Z
Exemple #31
0
    def readfile(self, filepath):
        text = open(filepath, 'r').read()
        lines = text.splitlines()
        pp = obj()
        i = 0
        pp.name, pp.type, Zcore, lmax = lines[i].split()
        i += 1
        Zcore = int(Zcore)
        lmax = int(lmax)
        pp.Zcore = Zcore
        pp.lmax = lmax

        element = split_delims(pp.name)[0]
        if not element in pt:
            element = split_delims(self.filename)[0]
            if not element in pt:
                self.error(
                    'cannot identify element for pseudopotential file ' +
                    filepath)
            #end if
        #end if
        Zatom = pt[element].atomic_number
        Z = Zatom - Zcore

        r = mgrid[1.e-10:150.00001:.005]
        p = obj()
        vlocal = None
        print
        print lmax
        for index in range(lmax + 1):
            l = (index + lmax) % (lmax + 1)
            print l
            ngpot = int(lines[i].strip())
            i += 1
            coeffs = empty((ngpot, ), dtype=float)
            powers = empty((ngpot, ), dtype=int)
            exponents = empty((ngpot, ), dtype=float)
            for ig in range(ngpot):
                coef, power, exponent = lines[i].split()
                i += 1
                coeffs[ig] = float(coef)
                powers[ig] = int(power)
                exponents[ig] = float(exponent)
            #end for
            pp[index] = obj(coeffs=coeffs, powers=powers, exponents=exponents)
            v = 0 * r
            for ig in range(ngpot):
                v += coeffs[ig] * r**(powers[ig] - 2) * exp(
                    -exponents[ig] * r**2)
            #end for
            if index == 0:
                vlocal = v - Z / r
                p[l] = vlocal.copy()
            else:
                p[l] = v + vlocal
            #end if
        #end for
        for l in p.keys():
            p[l] = convert(p[l], 'Ha', self.energy_units)
        #end for

        self.set(element=element, type=pp.type, Z=Z, r=r, potentials=p)

        print repr(p)
        import code
        code.interact(local=locals())
        #end for
        return electrons
    #end def get_electrons

    def count_electrons(self):
        nelectrons = 0
        for electron in ('up_electron','down_electron'):
            if electron in self:
                nelectrons += self[electron].count
            #end if
        #end for
        return nelectrons
    #end def count_electrons
#end class Particles

me_amu = convert(1.,'me','amu')

plist = [
    Particle('up_electron'  ,1.0,-1, 1),
    Particle('down_electron',1.0,-1,-1),
    ]
from periodic_table import ptable
for name,a in ptable.elements.iteritems():
    spin = 0 # don't have this data
    protons  = a.atomic_number
    neutrons = int(round(a.atomic_weight['amu']-a.atomic_number))
    p = Ion(a.symbol,a.atomic_weight['me'],a.atomic_number,spin,protons,neutrons)
    plist.append(p)
#end for
for name,iso in ptable.isotopes.iteritems():
    for mass_number,a in iso.iteritems():
Exemple #33
0
 def change_units(self,in_unit,out_unit):
     fac = 1.0/convert(1.0,in_unit,out_unit)**3
     density = self.get_density()
     density.values *= fac
     if 'values_noghost' in density:
         density.values_noghost *= fac
Exemple #34
0
    def readfile(self,filepath):
        text = open(filepath,'r').read()
        lines = text.splitlines()
        pp = obj()
        i=0
        pp.name,pp.type,Zcore,lmax = lines[i].split(); i+=1
        Zcore = int(Zcore)
        lmax  = int(lmax)
        pp.Zcore = Zcore
        pp.lmax  = lmax

        element = split_delims(pp.name)[0]
        if not element in pt:
            element = split_delims(self.filename)[0]
            if not element in pt:
                self.error('cannot identify element for pseudopotential file '+filepath)
            #end if
        #end if
        Zatom = pt[element].atomic_number
        Z = Zatom-Zcore

        r = mgrid[1.e-10:150.00001:.005]
        p = obj()
        vlocal = None
        print
        print lmax
        for index in range(lmax+1):
            l = (index+lmax)%(lmax+1)
            print l
            ngpot = int(lines[i].strip()); i+=1
            coeffs    = empty((ngpot,),dtype=float)
            powers    = empty((ngpot,),dtype=int)
            exponents = empty((ngpot,),dtype=float)
            for ig in range(ngpot):
                coef,power,exponent = lines[i].split(); i+=1
                coeffs[ig]    = float(coef)
                powers[ig]    = int(power)
                exponents[ig] = float(exponent)
            #end for
            pp[index] = obj(coeffs=coeffs,powers=powers,exponents=exponents)
            v = 0*r
            for ig in range(ngpot):
                v += coeffs[ig]*r**(powers[ig]-2)*exp(-exponents[ig]*r**2)
            #end for
            if index==0:
                vlocal = v - Z/r
                p[l] = vlocal.copy()
            else:
                p[l] = v + vlocal
            #end if
        #end for
        for l in p.keys():
            p[l] = convert(p[l],'Ha',self.energy_units)
        #end for

        self.set(
            element    = element,
            type       = pp.type,
            Z          = Z,
            r          = r,
            potentials = p
            )

        print repr(p)
        import code
        code.interact(local=locals())
Exemple #35
0
    def readfile(self,filepath):
        text = open(filepath,'r').read()
        if '<UPF' not in text:
            upf_format = 'old'
            lines = text.split('\n')
            xml = '<upf>\n'
            for l in lines:
                if l.find('/>')!=-1:
                    ln = l.replace('/>','>').replace('<','</')
                else:
                    ln = l
                #end if
                xml+=ln+'\n'
            #end for
            xml += '</upf>\n'
            tmppath = filepath+'_tmp'
            open(tmppath,'w').write(xml)
            x = readxml(tmppath,contract_names=True,strip_prefix='pp_')
            os.system('rm '+tmppath)
            x.convert_numeric()
            x.condense()
            x.remove_hidden()
            pp = x.upf
        else:
            upf_format = 'new'
            #x = readxml(filepath,contract_names=True,strip_prefix='pp_')
            #x.convert_numeric()
            #x.condense()
            #x.remove_hidden()
            #pp = x.upf
            pp = obj()
        #end if
        if upf_format=='old':
            lines = pp.header.split('\n')
            h = obj()
            i=0
            h.version = string2val(lines[i].split()[0]); i+=1
            h.element = string2val(lines[i].split()[0]); i+=1
            h.type = string2val(lines[i].split()[0]); i+=1
            ncc = string2val(lines[i].split()[0]); i+=1
            h.nonlinear_cc = dict(T=True,F=False)[ncc]
            h.functional = lines[i].split()[0:4]; i+=1
            h.Z = string2val(lines[i].split()[0]); i+=1
            h.total_energy = string2val(lines[i].split()[0]); i+=1
            h.wfc_cutoff,h.rho_cutoff = array(lines[i].split()[0:2],dtype=float); i+=1
            h.lmax = string2val(lines[i].split()[0]); i+=1
            h.npts = string2val(lines[i].split()[0]); i+=1
            h.nwfc = string2val(lines[i].split()[0]); i+=1
            pp.header = h
            if 'beta' in pp.nonlocal:
                beta = pp.nonlocal.beta
                if isinstance(beta,str):
                    beta = [beta]
                #end if
                b = obj()
                for i in range(len(beta)):
                    sections = beta[i].split('\n',2)
                    p = string2val(sections[0].split()[0])
                    v = string2val(sections[2])
                    b[p]=v
                #end for
                pp.nonlocal.beta = b
            #end if
            dij = pp.nonlocal.dij
            d = obj()
            lines = dij.split('\n')[1:]
            for l in lines:
                t = l.split()
                d[int(t[0]),int(t[1])] = string2val(t[2])
            #end for
            pp.nonlocal.dij = d
            pswfc = pp.pswfc
            tokens = pswfc.split()
            nwfc= pp.header.nwfc
            npts= pp.header.npts
            wf = []
            for n in range(nwfc):
                i = n*(4+npts)
                label = tokens[i]
                l = int(tokens[i+1])
                ws = []
                for v in tokens[i+4:i+4+npts]:
                    ws.append(float(v))
                #end for
                orb = obj()
                orb.label = label
                orb.l = l
                orb.wfc = array(ws)
                wf.append(orb)
            #end for
            pp.pswfc = wf

            #fill in standard fields
            self.pp = pp
            self.r = pp.mesh.r[1:]
            self.local = convert(pp.local,'Ry',self.energy_units)[1:]
            nl = obj()
            vnl = zeros(self.local.shape)
            if 'beta' in pp.nonlocal:
                beta = pp.nonlocal.beta
                for t,d in pp.nonlocal.dij.iteritems():
                    bi = beta[t[0]]
                    bj = beta[t[1]]
                    if not isinstance(bi,str) and not isinstance(bj,str):
                        bb = d*bi*bj
                    else: # the file is being misread, fix later
                        bb  = 0*pp.mesh.r
                    #end if
                    naftcut = len(pp.mesh.r)-len(bb)
                    if naftcut>0:
                        bb=append(bb,zeros((naftcut,)))
                    #end if
                    vnl += bb[1:]/self.r**2
                #end for
            #end if
            vnl = convert(vnl,'Ry',self.energy_units)
            nl[0] = vnl
            self.nonlocal = nl
            h = pp.header
            p = obj()
            p[0] = self.local
            p[1] = self.local+self.nonlocal[0]
            self.potentials = p
            self.element = h.element
            self.type = h.type
            self.Z  = h.Z
Exemple #36
0
        counts = []
        for electron in ('up_electron', 'down_electron'):
            if electron in self:
                counts.append(self[electron].count)
            else:
                counts.append(0)
            #end if
        #end for
        return counts

    #end def electron_counts


#end class Particles

me_amu = convert(1., 'me', 'amu')

plist = [
    Particle('up_electron', 1.0, -1, 1),
    Particle('down_electron', 1.0, -1, -1),
]
from periodic_table import ptable
for name, a in ptable.elements.items():
    spin = 0  # don't have this data
    protons = a.atomic_number
    neutrons = int(round(a.atomic_weight['amu'] - a.atomic_number))
    p = Ion(a.symbol, a.atomic_weight['me'], a.atomic_number, spin, protons,
            neutrons)
    plist.append(p)
#end for
for name, iso in ptable.isotopes.items():
Exemple #37
0
def read_eshdf_nofk_data(filename, Ef):
    from numpy import array, pi, dot, sqrt, abs, zeros
    from numpy.linalg import inv, det
    from hdfreader import read_hdf

    def h5int(i):
        return array(i, dtype=int)[0]

    #end def h5int

    # Use slightly shifted Fermi energy
    E_fermi = Ef + 1e-8

    # Open the HDF file w/o loading the arrays into memory (view mode)
    vlog('Reading ' + filename)
    h = read_hdf(filename, view=True)

    # Get the G-vectors in cell coordinates
    gvu = array(h.electrons.kpoint_0.gvectors)

    # Get the untiled cell axes
    axes = array(h.supercell.primitive_vectors)

    # Compute the k-space cell axes
    kaxes = 2 * pi * inv(axes).T

    # Convert G-vectors from cell coordinates to atomic units
    gv = dot(gvu, kaxes)

    # Get number of kpoints/twists, spins, and G-vectors
    nkpoints = h5int(h.electrons.number_of_kpoints)
    nspins = h5int(h.electrons.number_of_spins)
    ngvecs = len(gv)

    # Process the orbital data
    data = obj()
    for k in range(nkpoints):
        vlog('Processing k-point {:>3}'.format(k), n=1, time=True)
        kin_k = obj()
        eig_k = obj()
        k_k = obj()
        nk_k = obj()
        nelec_k = zeros((nspins, ), dtype=float)
        kp = h.electrons['kpoint_' + str(k)]
        gvs = dot(array(kp.reduced_k), kaxes)
        gvk = gv.copy()
        for d in range(3):
            gvk[:, d] += gvs[d]
        #end for
        kinetic = (gvk**2).sum(1) / 2  # Hartree units
        for s in range(nspins):
            kin_s = []
            eig_s = []
            k_s = gvk
            nk_s = zeros((ngvecs, ), dtype=float)
            nelec_s = 0
            path = 'electrons/kpoint_{0}/spin_{1}'.format(k, s)
            spin = h.get_path(path)
            eigs = convert(array(spin.eigenvalues), 'Ha', 'eV')
            nstates = h5int(spin.number_of_states)
            for st in range(nstates):
                eig = eigs[st]
                if eig < E_fermi:
                    stpath = path + '/state_{0}/psi_g'.format(st)
                    psi = array(h.get_path(stpath))
                    nk_orb = (psi**2).sum(1)
                    kin_orb = (kinetic * nk_orb).sum()
                    nelec_s += nk_orb.sum()
                    nk_s += nk_orb
                    kin_s.append(kin_orb)
                    eig_s.append(eig)
                #end if
            #end for
            data[k, s] = obj(
                kpoint=array(kp.reduced_k),
                kin=array(kin_s),
                eig=array(eig_s),
                k=k_s,
                nk=nk_s,
                ne=nelec_s,
            )
        #end for
    #end for
    res = obj(
        orbfile=filename,
        E_fermi=E_fermi,
        axes=axes,
        kaxes=kaxes,
        nkpoints=nkpoints,
        nspins=nspins,
        data=data,
    )

    return res
def test_convert():
    import numpy as np
    from testing import value_eq
    from unit_converter import convert

    # distance
    meters_per_angstrom = convert(1.0, 'A', 'm')
    meters_per_bohr = convert(1.0, 'B', 'm')
    angstrom_per_bohr = convert(1.0, 'B', 'A')

    B = .52917720859e-10
    B_per_A = B * 1e10
    assert (value_eq(meters_per_angstrom, 1e-10))
    assert (value_eq(meters_per_bohr, B, atol=1e-10))
    assert (value_eq(angstrom_per_bohr, B_per_A, atol=1e-10))

    v = 2.34
    vc = convert(v, 'A', 'B')
    assert (value_eq(vc, v / B_per_A))

    vc = convert(v, 'B', 'A')
    assert (value_eq(vc, v * B_per_A))

    v = 2.34 * np.arange(5)
    vc = convert(v, 'A', 'B')
    assert (value_eq(vc, v / B_per_A))

    vc = convert(v, 'B', 'A')
    assert (value_eq(vc, v * B_per_A))

    # mass
    kg_per_electron = convert(1.0, 'me', 'kg')
    kg_per_proton = convert(1.0, 'mp', 'kg')
    kg_per_amu = convert(1.0, 'amu', 'kg')

    assert (value_eq(kg_per_electron, 9.10938291e-31, rtol=1e-8))
    assert (value_eq(kg_per_proton, 1.672621777e-27, rtol=1e-8))
    assert (value_eq(kg_per_amu, 1.660538921e-27, rtol=1e-8))

    electrons_per_proton = convert(1.0, 'mp', 'me')
    assert (value_eq(electrons_per_proton, 1836.15267195))

    # energy
    joules_per_eV = convert(1.0, 'eV', 'J')
    joules_per_K = convert(1.0, 'K', 'J')
    eV_per_rydberg = convert(1.0, 'Ry', 'eV')
    eV_per_hartree = convert(1.0, 'Ha', 'eV')
    eV_per_kJ_mol = convert(1.0, 'kJ_mol', 'eV')
    eV_per_kcal_mol = convert(1.0, 'kcal_mol', 'eV')
    eV_per_kelvin = convert(1.0, 'K', 'eV')
    kelvin_per_eV = convert(1.0, 'eV', 'K')

    assert (value_eq(joules_per_eV, 1.60217646e-19, rtol=1e-8))
    assert (value_eq(eV_per_rydberg, 13.6056923, rtol=1e-8))
    assert (value_eq(eV_per_hartree, 27.2113846, rtol=1e-8))
    assert (value_eq(eV_per_kJ_mol, 0.0103642695083, rtol=1e-8))
    assert (value_eq(eV_per_kcal_mol, 0.04336411531, rtol=1e-8))
    assert (value_eq(eV_per_kelvin, 8.61734231197e-05, rtol=1e-8))
    assert (value_eq(kelvin_per_eV, 11604.5059346, rtol=1e-8))

    # temperature
    assert (value_eq(convert(100, 'degC', 'K'), 373.15))
    assert (value_eq(convert(0, 'degC', 'K'), 273.15))
    assert (value_eq(convert(212, 'degF', 'K'), 373.15))
    assert (value_eq(convert(32, 'degF', 'K'), 273.15))
    assert (value_eq(convert(100, 'degC', 'degF'), 212.0))
    assert (value_eq(convert(0, 'degC', 'degF'), 32.0))
    assert (value_eq(convert(212, 'degF', 'degC'), 100.0))
    assert (value_eq(convert(32, 'degF', 'degC'), 0.0, atol=1e-8))
Exemple #39
0
    def incorporate_system(self,system,spin_polarized=False):
        system.check_folded_system()
        system.update_particles()
        system.change_units('B')
        p  = system.particles
        s  = system.structure
        nc = system.net_charge
        ns = system.net_spin

        nup = p.up_electron.count
        ndn = p.down_electron.count

        self.system.ibrav        = 0
        self.system['celldm(1)'] = 1.0e0
        nions,nspecies = p.count_ions(species=True)
        self.system.nat          = nions
        self.system.ntyp         = nspecies
        #self.system.nelec        = nup+ndn
        self.system.tot_charge   = nc
        mag = nup-ndn
        if mag!=0 or spin_polarized:
            self.system.nspin = 2
            self.system.tot_magnetization = mag
        #end if

        if not 'cell_parameters' in self:
            self.cell_parameters = self.element_types['cell_parameters']()
        #end if
        self.cell_parameters.specifier = 'cubic'
        self.cell_parameters.vectors   = s.axes.copy()

        kpoints = s.kpoints/(2*pi)
        nkpoints = len(kpoints)
        if nkpoints>0:
            self.k_points.specifier = 'tpiba'
            self.k_points.nkpoints  = nkpoints
            self.k_points.kpoints   = kpoints
            self.k_points.weights   = s.kweights.copy()
        #end if

        atoms = p.get_ions()
        masses = obj()
        for name,a in atoms.iteritems():
            masses[name] = convert(a.mass,'me','amu')
        #end for
        self.atomic_species.atoms  = list(atoms.keys())
        self.atomic_species.masses = masses
        # set pseudopotentials for renamed atoms (e.g. Cu3 is same as Cu)
        pp = self.atomic_species.pseudopotentials
        for atom in self.atomic_species.atoms:
            if not atom in pp:
                iselem,symbol = p.is_element(atom,symbol=True)
                if iselem and symbol in pp:
                    pp[atom] = str(pp[symbol])
                #end if
            #end if
        #end for

        self.atomic_positions.specifier = 'alat'
        self.atomic_positions.positions = s.pos.copy()
        self.atomic_positions.atoms     = list(s.elem)
        if 'frozen' in s:
            frozen = s.frozen
            if 'relax_directions' in self.atomic_positions:
                relax_directions = self.atomic_positions.relax_directions
            else:
                relax_directions = ones(s.pos.shape,dtype=int)
            #end if
            for i in xrange(len(s.pos)):
                relax_directions[i,0] = int(not frozen[i,0] and relax_directions[i,0])
                relax_directions[i,1] = int(not frozen[i,1] and relax_directions[i,1])
                relax_directions[i,2] = int(not frozen[i,2] and relax_directions[i,2])
            #end for
            self.atomic_positions.relax_directions = relax_directions
Exemple #40
0
 def change_density_units(self, units):
     units_old = self.get_attribute('density_units')
     dscale = 1.0 / convert(1.0, units_old, units)
     for c in self.components():
         c.values *= dscale
Exemple #41
0
 def change_units(self, new_unit):
     old_unit = self.units
     for name in self.energy.keys():
         self.energy[name] = convert(self.energy[name], old_unit, new_unit)
     #end for
     self.units = new_unit
Exemple #42
0
def test_morse():
    from testing import value_eq
    from unit_converter import convert
    from numerics import morse,morse_re,morse_a,morse_De,morse_Einf,morse_width
    from numerics import morse_depth,morse_Ee,morse_k,morse_params
    from numerics import morse_reduced_mass,morse_freq,morse_w,morse_wX
    from numerics import morse_E0,morse_En,morse_zero_point,morse_harmfreq
    from numerics import morse_harmonic_potential,morse_spect_fit
    from numerics import morse_rDw_fit,morse_fit,morse_fit_fine

    rm = morse_reduced_mass('Ti','O')
    assert(value_eq(rm,21862.2266134))

    r_ref,D_ref,w_ref = 1.620,6.87,1009.18
    r_ref_A = r_ref
    p = morse_rDw_fit(r_ref,D_ref,w_ref,'Ti','O',Dunit='eV')

    r_ref = convert(r_ref,'A','B')
    D_ref = convert(D_ref,'eV','Ha')

    r = morse_re(p)
    D = morse_De(p)
    w = morse_w(p,'Ti','O')
    Einf = morse_Einf(p)
    assert(value_eq(float(r),r_ref))
    assert(value_eq(float(D),D_ref))
    assert(value_eq(float(w),w_ref))
    assert(value_eq(float(Einf),0.0))

    width_ref = 1.0451690611
    width = morse_width(p)
    assert(value_eq(float(width),width_ref))

    depth = morse_depth(p)
    assert(value_eq(depth,D_ref))

    a = morse_a(p)
    assert(value_eq(float(a),1/width_ref))

    Ee = morse_Ee(p)
    assert(value_eq(float(Ee),-D_ref))

    k_ref = 0.462235185922
    k = morse_k(p)
    assert(value_eq(float(k),k_ref))

    assert(value_eq(morse_params(r,a,D,Einf),p))

    assert(value_eq(morse_freq(p,'Ti','O'),w))

    #wX_ref = 2.43157675597e-08 # might be buggy
    #wX = morse_wX(p,'Ti','O')
    #assert(value_eq(float(wX),wX_ref))

    E0_ref = -0.250174011529
    E0 = morse_E0(p,'Ti','O')
    assert(value_eq(float(E0),E0_ref))

    E0 = morse_En(p,0,'Ti','O')
    assert(value_eq(float(E0),E0_ref))

    En_ref = [-0.250174011529,
              -0.245617721989,
              -0.241103305298,
              -0.236630761457,
              -0.232200090465]

    for n in range(5):
        En = morse_En(p,n,'Ti','O')
        assert(value_eq(float(En),En_ref[n]))
    #end for

    zp_ref = 0.00229384708885
    zp = morse_zero_point(p,'Ti','O')
    assert(value_eq(float(zp),zp_ref))

    # not consistent w/ morse_wX
    #p_sf = morse_spect_fit(r_ref_A,w_ref,wX_ref,'Ti','O')

    hf_ref = 0.00459816239012
    hf = morse_harmfreq(p,'Ti','O')
    assert(value_eq(float(hf),hf_ref))

    E = morse(p,r_ref)
    assert(value_eq(float(E),-D_ref))
Exemple #43
0
    def read_setup_info(self, logfile):
        setup_info = obj()
        f = logfile
        mode = None
        if f.seek('Calculation type', 1) != -1:
            line = f.readline().lower()
            if 'quench electrons' in line:
                mode = 'scf'
            elif 'band structure' in line:
                mode = 'band'
            else:
                mode = rmg_modes.mode_match(line, short=True)
            #end if
            setup_info.run_mode = mode
        #end if
        setup_start = None
        setup_end = None
        if mode == 'scf':
            setup_start = 'Files'
            setup_end = 'Diagonalization using'
        elif mode == 'band':
            setup_start = 'Files'
            setup_end = 'converged in'
        else:
            # don't know how to handle other cases yet
            None
        #end if
        unit_set = set(['a0'])
        on_off = dict(ON=True, OFF=False)

        def process_name(s):
            tokens = s.strip().lower().split()
            name = ''
            for t in tokens:
                if not t.startswith('('):
                    name += t + '_'
                #end if
            #end for
            name = name[:-1].replace('/', '_').replace('-', '_')
            return name

        #end def process_name
        def process_value(v, list=False):
            v = v.strip()
            units = None
            try:
                v = int(v)
            except:
                try:
                    v = float(v)
                except:
                    if ' ' in v or ',' in v:
                        vt = v.replace(',', ' ')
                        if len(vt) > 0:
                            tokens = vt.split()
                            if tokens[-1] in unit_set:
                                units = tokens[-1]
                                tokens = tokens[:-1]
                            #end if
                            try:
                                if not list:
                                    v = np.array(tokens, dtype=float)
                                else:
                                    v = [
                                        process_value(t, list=True)[0]
                                        for t in tokens
                                    ]
                                #end if
                            except:
                                units = None
                            #end try
                        #end if
                    elif v in on_off:
                        v = on_off[v]
                    #end if
                #end try
            #end try
            return v, units

        #end def process_value
        if setup_start is not None:
            istart = f.seek(setup_start)
            if istart != -1:
                istart = f.tell()
                iend = f.seek(setup_end, 1)
                if iend != -1:
                    iend = f.tell()
                    text = to_str(f.mm[istart:iend])
                    blocks = []
                    b = ''
                    last_header = False
                    for line in text.splitlines():
                        if len(line) > 0:
                            if line[0] != ' ':
                                if last_header:
                                    b += '\n' + line
                                else:
                                    if len(b) > 0:
                                        blocks.append(b)
                                    #end if
                                    b = line
                                    last_header = True
                                #end if
                            else:
                                b += '\n' + line
                                last_header = False
                            #end if
                        #end if
                    #end for
                    other_blocks = obj()
                    for b in blocks:
                        header, body = b.split('\n', 1)
                        bname = process_name(header)
                        lines = body.splitlines()
                        simple_values = True
                        for line in lines:
                            simple_values &= ':' in line
                        #end for
                        if simple_values:
                            bvalues = obj()
                            for line in lines:
                                name, value = line.split(':', 1)
                                name = process_name(name)
                                value, units = process_value(value)
                                bvalues[name] = value
                                if units is not None:
                                    bvalues.units = units
                                #end if
                            #end for
                            setup_info[bname] = bvalues
                        else:
                            other_blocks[bname] = header, body, lines
                        #end if
                    #end for
                    # additional processing for specific blocks
                    if 'grid_points' in setup_info:
                        b = setup_info.grid_points
                        try:
                            grid = []
                            grid_pe = []
                            spacing = []
                            grid_units = None
                            for c in 'xyz':
                                if c in b:
                                    s = b[c].replace('Total:', '')
                                    s = s.replace('Per PE:', '')
                                    s = s.replace('Spacing:', '')
                                    v, u = process_value(s, list=True)
                                    grid_units = u
                                    grid.append(v[0])
                                    grid_pe.append(v[1])
                                    spacing.append(v[2])
                                #end if
                            #end for
                            grid = np.array(grid, dtype=int)
                            grid_pe = np.array(grid_pe, dtype=int)
                            spacing = np.array(spacing, dtype=float)
                            ecut, ecut_charge, ecut_units = b.equivalent_energy_cutoffs.split(
                            )
                            b.set(
                                grid=grid,
                                grid_pe=grid_pe,
                                grid_spacing=spacing,
                                grid_units=grid_units,
                                ecut=float(ecut),
                                ecut_charge=float(ecut_charge),
                                ecut_units=ecut_units,
                            )
                        except:
                            None
                        #end try
                    #end if
                    if 'lattice_setup' in setup_info:
                        b = setup_info.lattice_setup
                        try:
                            b.axes = np.array([
                                b.x_basis_vector, b.y_basis_vector,
                                b.z_basis_vector
                            ],
                                              dtype=float)
                        except:
                            None
                        #end try
                    #end if
                    if 'k_points' in other_blocks:
                        try:
                            header, body, lines = other_blocks.k_points
                            del other_blocks.k_points
                            for i, line in enumerate(lines):
                                if 'Weight in crystal unit' in line:
                                    break
                                #end if
                            #end for
                            kp = []
                            kw = []
                            for line in lines[i + 1:]:
                                if 'Weight in' in line:
                                    break
                                #end if
                                t = np.array(line.split(), dtype=float)
                                kp.append(t[:3])
                                kw.append(t[3])
                            #end for
                            setup_info.k_points = obj(
                                kpoints_crystal=np.array(kp, dtype=float),
                                kweights=np.array(kw, dtype=float),
                            )
                        except:
                            None
                        #end try
                    #end if
                    k = 'initial_ionic_positions_and_displacements'
                    if k in other_blocks:
                        try:
                            header, body, lines = other_blocks[k]
                            del other_blocks[k]
                            h = header.lower()
                            punits = None
                            if 'bohr' in h:
                                punits = 'B'
                            elif 'angstrom' in h:
                                punits = 'A'
                            #end if
                            pos = []
                            spec = []
                            for i, line in enumerate(lines):
                                if 'Species' in line:
                                    break
                                #end if
                            #end for
                            for line in lines[i + 1:]:
                                ls = line.strip()
                                if len(ls) > 0:
                                    t = line.split()
                                    spec.append(t[0])
                                    pos.append(t[1:4])
                                #end if
                            #end for
                            setup_info.ion_positions = obj(
                                units=punits,
                                atoms=np.array(spec, dtype=object),
                                positions=np.array(pos, dtype=float),
                            )
                        except:
                            None
                        #end try
                    #end if
                #end if
            #end if
        #end if
        if 'lattice_setup' in setup_info and 'ion_positions' in setup_info:
            try:
                aunits = setup_info.lattice_setup.get('units', 'B')
                axes = setup_info.lattice_setup.axes
                elem = setup_info.ion_positions.atoms
                pos = setup_info.ion_positions.positions
                punits = setup_info.ion_positions.units
                kpu = None
                kw = None
                if aunits == 'a0':
                    aunits = 'B'
                elif aunits != 'B':
                    aunits = 'A'  # assume for now
                #end if
                units = 'B'
                axes = convert(axes, aunits, units)
                pos = convert(pos, punits, units)
                s = generate_structure(
                    units=units,
                    axes=axes,
                    elem=elem,
                    pos=pos,
                )
                if 'k_points' in setup_info and 'kpoints_crystal' in setup_info.k_points:
                    kpu = setup_info.k_points.kpoints_crystal
                    if len(kpu) > 0:
                        kw = setup_info.k_points.kweights
                        kp = np.dot(kpu, s.kaxes)
                        s.add_kpoints(kpoints=kp, kweights=kw)
                    #end if
                #end if
                setup_info.structure = s
            except:
                None
            #end try
        #end if
        if 'files' in setup_info and 'control_input_file' in setup_info.files:
            filepath = os.path.join(self.path,
                                    setup_info.files.control_input_file)
            if os.path.exists(filepath):
                try:
                    self.input = RmgInput(filepath)
                except:
                    None
                #end try
            #end if
        #end if
        self.setup_info = setup_info
Exemple #44
0
 def change_units(self, new_unit):
     old_unit = self.units
     for name in self.energy.keys():
         self.energy[name] = convert(self.energy[name], old_unit, new_unit)
     # end for
     self.units = new_unit