コード例 #1
0
ファイル: bfield.py プロジェクト: NNemec/NNlib
from units import *
from calc import *
from param import param

param.createdefault("BFIELD_DIRECTION", 'perp')    # 'par', 'lateral'

def _conv_bfield(bfield):
    if isscalar(bfield):
	if param.BFIELD_DIRECTION == 'perp':
    	    return bfield * array((0.,1.,0.))
	elif param.BFIELD_DIRECTION == 'par':
    	    return bfield * array((0.,0.,1.))
	elif param.BFIELD_DIRECTION == 'lateral':
    	    return bfield * array((1.,0.,0.))
	else:
    	    raise "Error: unknown BFIELD_DIRECTION"
    else:
	bfield = asarray(bfield)
	assert bfield.shape == (3,)
	return bfield

def calc_H_int(bfield,H_int_B0,xyz):
    assert(shape(H_int_B0)[0] == len(xyz.atoms))
    assert(shape(H_int_B0)[1] == len(xyz.atoms))

    B_e_hbar = _conv_bfield(bfield) * electron / hbar
    if all(B_e_hbar == 0):
	return H_int_B0

    H_int = H_int_B0.copy()
    for i in range(len(xyz.atoms)):
コード例 #2
0
ファイル: cnt.py プロジェクト: NNemec/NNlib
#!/usr/bin/env python

from calc import *
from units import *
from param import param
import xyz

param.createdefault("GRAPHENE_CC_DISTANCE", 1.4226*Angstrom)
param.createdefault("GRAPHITE_INTERLAYER_DISTANCE", 3.34*Angstrom)

def SDOS_armchair_analytic(
    E, # in units of gamma
    N, # chirality of tube: (N,N)
):
    Gs = 0.j
    for j in range(1,2*N+1):
        X = E**2-sin(j*pi/N)**2
        if X < 0:
            continue
        cos_q = -.5*(cos(j*pi/N) + sign(E)*(X)**.5)
        if cos_q**2 > 1:
            continue
        print cos_q
        sin_q = (1-cos_q**2)**.5
        Gs += E*(.5+1j*sin_q/(2*cos_q+cos(j*pi/N)))
    return -Gs.imag/pi


def armchair(N):
    CC_distance = param.GRAPHENE_CC_DISTANCE
コード例 #3
0
ファイル: twoprobe.py プロジェクト: NNemec/NNlib
from calc import *
from units import *
from param import param

import lead as _lead
import conductor as _conductor

param.createdefault("BFIELD_IN_LEADS", True)

class twoprobe:
    def __init__(self,conductor,lead_L,lead_R):
        self.energy = None
        self.bfield = None
        self.conductor = conductor
        assert type(lead_L) is list
        self.lead_L = lead_L
        assert type(lead_R) is list
        self.lead_R = lead_R
        self.Sigma_L = None
        self.Sigma_R = None

    def set_energy(self,energy):
        if self.energy != energy:
            self.energy = energy
            for l in self.lead_L:
                l.set_energy(energy)
            for l in self.lead_R:
                l.set_energy(energy)
            self.conductor.set_energy(energy)
            self.Sigma_L = None
            self.Sigma_R = None
コード例 #4
0
ファイル: chain.py プロジェクト: NNemec/NNlib
from numpy import *
from numpy.linalg import *
import scipy, scipy.linalg
from param import param
from units import *

param.createdefault("LOPEZ_SANCHO_ETA", 1e-5*eV)
param.createdefault("LOPEZ_SANCHO_EPSILON", 1e-4*eV)
param.createdefault("LOPEZ_SANCHO_MAXSTEPS", 100)

class chain:
    def __init__(self,H_B0,xyz_chain=None,do_cache=True,S=None):
        assert type(H_B0) is list
        N = H_B0[0].shape[0]
        self.N_orbitals = N
        for h_b0 in H_B0:
            assert type(h_b0) is matrix
            assert h_b0.shape == (N,N)
            assert h_b0.dtype == H_B0[0].dtype
        self.H = H_B0
        self.H_B0 = H_B0

        if xyz_chain is not None:
	    import xyz

            assert isinstance(xyz_chain,xyz.chain)
            self.xyz = xyz_chain
            self.xyz_shifted = [ xyz_chain.shift(xyz_chain.period * i) for i in range(1,len(H_B0)) ]
            self.bfield = array((0,0,0))

        self.nonorthogonal = (S is not None)
コード例 #5
0
ファイル: conductor.py プロジェクト: NNemec/NNlib
from calc import *

from copy import deepcopy
from param import param

param.createdefault("DISORDER_TYPE", "diagonal")
# param.DISORDER_TYPE = "hopping"

param.createdefault("DO_CALC_CHANNELS", False)
param.createdefault("NO_DISORDER_IN_CONTACTS", False)

class conductor:
    def __init__(self,xyz,H_int,H_hop):
        N = [ H.shape[0] for H in H_int ]
#        N = [ len(x.atoms) for x in xyz ]
        assert len(H_int)==len(N)
        assert len(H_hop)==len(N)-1
        for i in range(len(N)):
            assert type(H_int[i]) == type(matrix(()))
            assert shape(H_int[i]) == (N[i],N[i])
        for i in range(len(N)-1):
            assert type(H_hop[i]) == type(matrix(()))
            assert shape(H_hop[i]) == (N[i],N[i+1])
        self.N = N
	if xyz is not None:
	    assert len(xyz) == len(N)
	    for i in range(len(N)):
		assert len(xyz[i].atoms) == N[i]
            self.xyz = xyz
        self.H_int_B0 = H_int
        self.H_hop_B0 = H_hop
コード例 #6
0
ファイル: tightbinding.py プロジェクト: NNemec/NNlib
#!/usr/bin/env python

import re
from itertools import count

import xyz, cnt, chain, sheet
from param import param
from units import *
from calc import *

###########################

param.createdefault("GRAPHENE_1STNN_HOPPING", 2.66*eV)


def graphene_1stNN_params(dist):
    if dist == 0.0:
	return (0.0,1.0)
    elif dist < param.GRAPHENE_CC_DISTANCE * 1.1:
	return (-gamma,0.0)
    else:
	return (0.0,0.0)

param.createdefault("GRAPHENE_3RDNN_EPSILON0", -0.28*eV)
param.createdefault("GRAPHENE_3RDNN_GAMMA0", 2.97*eV)
param.createdefault("GRAPHENE_3RDNN_GAMMA1", 0.073*eV)
param.createdefault("GRAPHENE_3RDNN_GAMMA2", 0.33*eV)
param.createdefault("GRAPHENE_3RDNN_S0", 0.073)
param.createdefault("GRAPHENE_3RDNN_S1", 0.018)
param.createdefault("GRAPHENE_3RDNN_S2", 0.026)