2 % Copyright (C) 2009-2015 Peter Rakyta, Ph.D.
4 % This program is free software: you can redistribute it and/or modify
5 % it under the terms of the GNU General Public License as published by
6 % the Free Software Foundation, either version 3 of the License, or
7 % (at your option) any later version.
9 % This program is distributed in the hope that it will be useful,
10 % but WITHOUT ANY WARRANTY; without even the implied warranty of
11 % MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 % GNU General Public License
for more details.
14 % You should have received a copy of the GNU General Public License
15 % along with
this program. If not, see http:
17 %> @addtogroup utilities Utilities
20 %> @brief A
class for calculations on a ribbon of finite width
for equilibrium calculations mostly in the zero temperature limit.
21 %> @image html Ribbon_structure.jpg
22 %> @image latex Ribbon_structure.jpg
24 %> @brief A
class for calculations on a ribbon of finite width for equilibrium calculations mostly in the zero temperature limit.
25 %> <tr
class=
"heading"><td colspan=
"2"><h2
class=
"groupheader"><a name=
"avail"></a>Structure described by the
class</h2></td></tr>
26 %> @image html Ribbon_structure.jpg
27 %> @image latex Ribbon_structure.jpg
28 %> The drawing represents a two-terminal structure made of two leads, of a scattering region and of two
interface regions between the leads and scattering center.
29 %> Each rectangle describes a unit cell including singular and non-singular
sites.
30 %> The scattering center is also described by a
set of identical unit cells, but arbitrary potential can be used.
32 %> The orientation of the lead is +1
if the lead is terminated by the
interface region in the positive direction, and -1 if the lead is terminated by the interface region in the negative direction.
37 properties ( Access =
public )
38 %> An instance of
class #
Lead (or its subclass) describing the unit cell of the scattering region
42 %> width of the scattering region (number of the nonsingular atomic
sites in the cross section)
44 %> height (length) of the scattering region (number of unit cells)
51 methods ( Access = public )
52 %% Contructor of the class
53 %> @brief Constructor of the class.
54 %> @
param Opt An instance of the structure
#Opt. 56 %> @
return An instance of the
class 63 obj.transversepotential = [];
69 if strcmpi(
class(obj),
'Ribbon')
70 % processing the optional parameters
74 obj.display([
'EQuUs:Utils:',
class(obj),
':Ribbon: Creating a Ribbon object'])
76 % create the
shape of the scattering region
82 % exporting calculation parameters into an XML format
85 % create
class intances and initializing class attributes
89 obj.CreateRibbon(
'justHamiltonians',
true);
97 %> @brief Calculates the transport through the two terminal setup on two dimensional lattices. Use
for development pupose only.
98 %> @
param Energy The energy value.
99 %> @
param varargin Cell array of optional parameters (https:
100 %> @
param 'constant_channels' Logical value. Set true (
default) to keep constant the number of the open channels in the leads
for each energy value, or
false otherwise.
101 %> @
param 'gfininvfromHamiltonian' Logical value. Set
true calculate the surface Greens
function of the scattering region from the Hamiltonaian of the scattering region, or false (
default) to calculate it by the fast way (see Phys. Rev. B 90, 125428 (2014)
for details).
102 %> @
param 'decimateDyson' Logical value. Set true (
default) to decimate the
sites of the scattering region in the Dyson equation.
103 %> @
param 'PotInScatter' Obsolete parameter. Use
'scatterPotential' instead.
104 %> @
param 'scatterPotential' A
function handle pot=f( #coordinates ) or pot=f( #
CreateHamiltonians, Energy)
for the potential to be applied in the Hamiltonian (used when FiniteGreensFunctionFromHamiltonian=
true).
105 %> @
param 'selfEnergy' Logical value. Set
true to use the
self energies of the leads in the Dyson equation, or false (
default) to use the surface Green
function instead.
107 %> @
return [1] Conductivity The calculated conductivity.
108 %> @
return [2] aspect_ratio The aspect ratio W/L of the junction.
109 %> @
return [3] Conductance The conductance tensor
110 %> @
return [4] ny Array of the open channel in the leads.
111 %> @
return [5] DeltaC Error of the unitarity.
112 %> @
return [6] S The scattering matrix.
113 function [Conductivity,aspect_ratio,Conductance,ny,DeltaC,S] =
Transport(obj, Energy, varargin)
116 p.addParameter(
'constant_channels',
false);
117 p.addParameter(
'gfininvfromHamiltonian',
false);
118 p.addParameter(
'decimateDyson',
true);
119 p.addParameter(
'PotInScatter', []) %OBSOLETE use scatterPotential instead
120 p.addParameter(
'scatterPotential', []) %NEW overrides optional argument
'PotInScatter' 121 p.addParameter(
'selfEnergy',
false)
122 p.addParameter(
'Smatrix',
true) %logcal value to use the S-matrix method to calculate the conductance or not.
123 p.parse(varargin{:});
124 constant_channels = p.Results.constant_channels;
125 gfininvfromHamiltonian = p.Results.gfininvfromHamiltonian;
127 scatterPotential = p.Results.PotInScatter;
128 if ~isempty( p.Results.scatterPotential )
129 scatterPotential = p.Results.scatterPotential;
132 decimateDyson = p.Results.decimateDyson;
133 selfEnergy = p.Results.selfEnergy;
134 Smatrix = p.Results.Smatrix;
136 obj.CalcSpectralFunction(Energy, 'constant_channels', constant_channels, 'gfininvfromHamiltonian', gfininvfromHamiltonian, ...
137 'decimateDyson', decimateDyson, 'scatterPotential', scatterPotential, 'SelfEnergy', selfEnergy);
139 if strcmp(obj.
param.scatter.End_Type, 'A')
140 aspect_ratio = (obj.width*3/2)/((obj.height+3)*sqrt(3));
142 aspect_ratio = ((obj.width-0.5)*sqrt(3))/((obj.height+3)*3);
146 [S,ny] = obj.FL_handles.SmatrixCalc();
148 norma = norm(S*S'-eye(sum(ny)));
151 obj.display( ['error of the unitarity of S-matrix: ',num2str(norma)] )
155 obj.display( ['openchannels do not match: ',num2str(ny(1)), ' ', num2str(ny(2))] )
160 conductance = obj.FL_handles.Conduktance();
161 conductance = abs([conductance(1,:), conductance(2,:)]);
162 DeltaC = std(conductance);
164 C = mean(conductance);
165 Conductivity = C/aspect_ratio;
168 obj.display( ['aspect ratio = ', num2str(aspect_ratio), ' conductance = ', num2str(C), '
open_channels= ', num2str(ny(1)), ' conductivity = ', num2str(Conductivity)])
171 Conductance = obj.FL_handles.Conductance2();
173 Conductivity = Conductance/aspect_ratio;
176 obj.display( ['aspect ratio = ', num2str(aspect_ratio), ' conductance = ', num2str(Conductance), ' conductivity = ', num2str(Conductivity)])
182 %> @brief Gets the coordinates of the central region
184 %> @return [2]
Coordinates of the interface region.
185 function [coordinates, coordinates_interface] = getCoordinates( obj )
187 coordinates = obj.Scatter_UC.Read('coordinates');
188 H1 = obj.Scatter_UC.Read('H1');
189 [rows, cols] = find(H1);
192 fnames = fieldnames(coordinates);
193 for idx = 1:length( fnames )
195 if strcmp( fname,
'a' ) || strcmp( fname,
'b' ) || strcmp( fname,
'LatticeConstant' )
197 elseif strcmp( fname, 'x' )
198 coordinates.(fname) = [coordinates.(fname)(cols); coordinates.(fname)(rows) + (obj.height-1)*coordinates.a(1)];
199 elseif strcmp( fname, 'y' )
200 coordinates.(fname) = [coordinates.(fname)(cols); coordinates.(fname)(rows) + (obj.height-1)*coordinates.a(2)];
202 if ~isempty(coordinates.(fname))
203 coordinates.(fname) = [coordinates.(fname)(cols); coordinates.(fname)(rows)];
209 err = MException('EQuUs:Utils:
Ribbon:getCoordinatesFromRibbon', 'Error occured when retriving the coordinates of the ribbon.');
210 err = addCause(err, errCause);
211 save('Error_Ribbon_getCoordinatesFromRibbon.mat');
217 if isempty( obj.Interface_Regions )
218 coordinates_interface = [];
222 coordinates_interface = cell( length(obj.Interface_Regions), 1);
223 for idx = 1:length( obj.Interface_Regions )
224 coordinates_interface{idx} = obj.Interface_Regions{idx}.Read(
'coordinates');
228 err = MException(
'EQuUs:Utils:Ribbon:getCoordinatesFromRibbon',
'Error occured when retriving the coordinates of the interface region from a Ribbon interface');
229 err = addCause(err, errCause);
230 save(
'Error_Ribbon_getCoordinatesFromRibbon.mat');
237 %> @brief Shifts the coordinates of the
sites in the ribbon by an integer multiple of the lattice vector. The coordinates of the Leads are automatically adjusted later
238 %> @
param shift An integer value.
239 function ShiftCoordinates( obj, shift )
240 obj.Scatter_UC.ShiftCoordinates( shift );
241 if ~isempty( obj.Interface_Regions )
242 for idx = 1:length(obj.Interface_Regions)
243 obj.Interface_Regions{idx}.ShiftCoordinates( shift );
247 obj.shift = obj.shift + shift;
251 %> @brief Initializes
class #
CreateHamiltonians for storing and manipulate the Hamiltonian of the the scattering region. The created object is stored in attribute #CreateH.
252 function Scatter_UC = CreateScatter( obj )
253 Scatter_UC = obj.Scatter_UC.
CreateClone(
'empty',
true);
255 % create Hamiltonian of one unit cell of the scattering region
257 Scatter_UC.ShiftCoordinates( obj.shift );
259 %applying transverse potential
260 obj.ApplyTransversePotential( Scatter_UC )
263 % apply magnetic field in the unit cell of the scattering region
264 % can be applied
if the vector potential is identical in each unit cells
265 if ~isempty( obj.PeierlsTransform_Scatter ) && isempty(obj.q) && obj.
Opt.magnetic_field_trans_invariant %
for finite
q the vector potential must be parallel to
q, and perpendicular to the unit cell vector
266 obj.display([
'EQuUs:Utils:',
class(obj),
':CreateScatter: Applying magnetic field in the unit cell of the scattering region']);
267 obj.PeierlsTransform_Scatter.PeierlsTransformLeads( Scatter_UC );
270 % Create the Hamiltonian of the scattering region
272 createH.CreateScatterH(
'Scatter_UC', Scatter_UC );
274 % apply magnetic field in the whole HAmiltonian of the scattering region
275 % can be applied
for non-translational invariant vector potentials
276 if ~isempty( obj.PeierlsTransform_Scatter ) && isempty(obj.q) && ~obj.Opt.magnetic_field_trans_invariant
277 obj.display([
'EQuUs:Utils:',
class(obj),
':CreateScatter: Applying magnetic field in the whole Hamiltonian of the scattering region']);
278 obj.PeierlsTransform_Scatter.PeierlsTransform( createH );
282 obj.CreateH = createH;
284 H0 = Scatter_UC.
Read(
'H0');
285 H1 = Scatter_UC.
Read(
'H1');
287 [rows, cols] = find( H1 );
288 rows = unique(rows); % cols identical to non_singular_sites
289 cols = unique(cols); % cols identical to non_singular_sites
291 % identify
sites that would be directly connected to the leads
292 non_singular_sites = [reshape(cols, 1, length(cols)), (obj.height-1)*size(H0,1)+reshape(rows, 1, length(rows))];
293 createH.Write(
'kulso_szabfokok', non_singular_sites );
299 %> @brief Sets the energy
for the calculations
300 %> @
param Energy The value of the energy in the same units as the Hamiltonian.
301 function setEnergy( obj, Energy )
305 if ~isempty( obj.Scatter_UC ) && strcmpi(
class(obj.Scatter_UC),
'Lead')
306 obj.Scatter_UC.
Reset();
309 if ~isempty(obj.Scatter_UC)
310 obj.CreateRibbon('justHamiltonians', true);
317 %> @brief Custom Dyson function for a two terminal arrangement on a two dimensional lattice.
319 %> @
param 'gfininv' The inverse of the Greens function of the scattering region. For default the inverse of the attribute
#G is used. 320 %> @
param 'constant_channels' Logical value. Set
true (
default) to keep constant the number of the open channels in the leads
for each energy value, or
false otherwise.
321 %> @
param 'onlyGinverz' Logical value. Set
true to calculate only the inverse of the total Green
operator, or false (
default) to calculate #G as well.
322 %> @
param 'recalculateSurface' A vector of the identification numbers of the lead surfaces to be recalculated.
323 %> @
param 'decimate' Logical value. Set
true (
default) to eliminate all inner
sites in the Greens
function and keep only the selected
sites. Set
false to omit the decimation procedure.
324 %> @
param 'kulso_szabfokok' Array of
sites to be kept after the decimation procedure. (Use parameter
'keep_sites' instead)
325 %> @
param 'selfEnergy' Logical value. Set
true to use the
self energies of the leads in the Dyson equation, or
false (
default) to use the surface Green
function instead.
326 %> @
param 'keep_sites' Name of
sites to be kept in the resulted Green function (Possible values are:
'scatter',
'interface',
'lead').
327 %> @
param 'UseHamiltonian' Set
true if the
interface region is matched to the whole Hamiltonian of the scattering center, or false (default) if the surface Green operator of the scattering center is used in the calculations.
328 %> @
return [1] The calculated Greens
function.
329 %> @
return [2] The inverse of the Green
operator.
330 %> @
return [3] An instance of structure #
junction_sites describing the
sites in the calculated Green
operator.
331 function [Gret, Ginverz,
junction_sites] = CustomDysonFunc( obj, varargin ) %NEW output
334 p.addParameter(
'gfininv', []);
335 p.addParameter(
'constant_channels',
true);
336 p.addParameter(
'onlyGinverz',
false );
337 p.addParameter(
'recalculateSurface', [1 2] );
338 p.addParameter(
'decimate',
true );
339 p.addParameter(
'kulso_szabfokok', []); %The list of
sites to be left after the decimation procedure
340 p.addParameter(
'SelfEnergy',
false); %
set true to calculate the Dyson equation with the
self energy
341 p.addParameter(
'keep_sites',
'lead'); %Name of
sites to be kept (scatter, interface, lead)
342 p.addParameter(
'UseHamiltonian',
false); %
true if the
interface region is matched to the whole Hamiltonian of the scattering center, false if the surface Green operator of the scattering center is used in the calculations.
343 p.parse(varargin{:});
344 gfininv = p.Results.gfininv;
345 constant_channels = p.Results.constant_channels;
346 onlyGinverz = p.Results.onlyGinverz;
347 recalculateSurface = p.Results.recalculateSurface;
348 decimate = p.Results.decimate;
349 kulso_szabfokok = p.Results.kulso_szabfokok;
350 useSelfEnergy = p.Results.SelfEnergy;
351 keep_sites = p.Results.keep_sites;
352 UseHamiltonian = p.Results.UseHamiltonian;
355 if ~isempty(recalculateSurface)
357 % creating interfaces
for the Leads
359 shiftLeads = ones(length(obj.param.Leads),1)*obj.E;
361 shiftLeads = ones(length(obj.param.Leads),1)*0;
364 % creating
Lead instaces and calculating the retarded surface Green
operator/
self-energy
365 coordinates_shift = [-2, obj.height+1] + obj.shift;
366 obj.FL_handles.LeadCalc(
'coordinates_shift', coordinates_shift,
'shiftLeads', shiftLeads,
'transversepotential', obj.transversepotential, ...
367 'SelfEnergy', useSelfEnergy,
'SurfaceGreensFunction', ~useSelfEnergy,
'gauge_field', obj.gauge_field,
'leads', recalculateSurface,
'q', obj.q, ...
368 'leadmodel', obj.leadmodel);
370 for idx = 1:length(recalculateSurface)
371 obj.CreateInterface( recalculateSurface(idx),
'UseHamiltonian', UseHamiltonian );
377 'onlyGinverz', onlyGinverz, ...
378 'recalculateSurface', [], ...
379 'decimate', decimate, ...
380 'kulso_szabfokok', kulso_szabfokok, ...
381 'SelfEnergy', useSelfEnergy, ...
382 'keep_sites', keep_sites);
387 %% CalcFiniteGreensFunction
388 %> @brief Calculates the Green
operator of the scattering region by the fast way (see PRB 90, 125428 (2014)).
390 function CalcFiniteGreensFunction( obj, varargin )
393 p.addParameter(
'gauge_trans',
false); % logical:
true if want to perform gauge transformation on the Green
's function and Hamiltonians 394 p.addParameter('onlyGinv
', false); 395 p.parse(varargin{:}); 396 gauge_trans = p.Results.gauge_trans; 397 onlyGinv = p.Results.onlyGinv; 399 if ~obj.Scatter_UC.Read('OverlapApplied
') 400 obj.Scatter_UC.ApplyOverlapMatrices(obj.E); 403 % getting the Hamiltonian for the edge slabs 404 K0 = obj.Scatter_UC.Read('K0
'); 405 K1 = obj.Scatter_UC.Read('K1
'); 406 K1adj = obj.Scatter_UC.Read('K1adj
'); 408 q = obj.Scatter_UC.Read('q
'); 409 if ~isempty( q ) && ~obj.Scatter_UC.Read('HamiltoniansDecimated
') 410 K1_transverse = obj.Scatter_UC.Read('K1_transverse
'); 411 K0 = K0 + K1_transverse*diag(exp(1i*q)) + K1_transverse'*diag(exp(-1i*q));
417 if obj.Scatter_UC.Read(
'is_SVD_transformed')
418 V = obj.Scatter_UC.Get_V();
425 %> the first two and last two slabs are added manualy at the end 426 if ~obj.Scatter_UC.Read('is_SVD_transformed
') 437 obj.Scatter_UC.FiniteGreenFunction(z1,z2, 'onlygfininv
', true); 438 obj.Ginv = obj.Scatter_UC.Read( 'gfininv
' ); 440 %> adding to the scattering region the first set of transition layers 441 Neff = obj.Scatter_UC.Get_Neff(); 442 non_singular_sites = obj.Scatter_UC.Read( 'kulso_szabfokok
' ); 443 if isempty( non_singular_sites ) 444 non_singular_sites = 1:Neff; 447 non_singular_sites_edges = [non_singular_sites, size(K0,1)+1:2*size(K0,1)]; 448 ginv_edges = -[K0, K1; K1adj, K0]; 449 ginv_edges = obj.DecimationFunction( non_singular_sites_edges, ginv_edges ); 451 %Ginv = [first_slab, H1, 0; 453 % 0 , H1
', last_slab]; 455 obj.Ginv = [ginv_edges(1:Neff,1:Neff), [ginv_edges(1:Neff, Neff+non_singular_sites), zeros(Neff, Neff+size(K0,2))]; ... 456 [ginv_edges(Neff+non_singular_sites, 1:Neff); zeros(Neff, Neff)], obj.Ginv, [zeros(Neff, size(ginv_edges,2)-Neff); ginv_edges(1:Neff, Neff+1:end)]; ... 457 [zeros(size(K0,2),2*Neff), ginv_edges(Neff+1:end, 1:Neff)], ginv_edges(Neff+1:end, Neff+1:end)]; 459 [rows, cols] = find( K1 ); 460 rows = unique(rows); % cols identical to non_singular_sites 462 %non_singular_sites_Ginv = [1:length(non_singular_sites), size(obj.Ginv,1)-size(K0,1)+1:size(obj.Ginv,1)]; 463 non_singular_sites_Ginv = [1:length(non_singular_sites), size(obj.Ginv,1)-size(K0,1)+reshape(rows, 1, length(rows))]; 464 obj.Ginv = obj.DecimationFunction( non_singular_sites_Ginv, obj.Ginv ); 467 %> terminate the scattering region by the first and last slabs and transform back to the normal space from the SVD representation 468 if obj.Scatter_UC.Read('is_SVD_transformed
') 469 %> adding the first and last slab to 470 %Ginv = [first_slab, H1, 0; 472 % 0 , H1
', last_slab]; 474 obj.Ginv = [K0, [K1(:, 1:Neff), zeros(size(K0,1), 2*size(K0,2))]; ... 475 [K1adj(1:Neff,:); zeros(size(K0))], obj.Ginv, [zeros(Neff, size(K0,2)); K1]; ... 476 zeros(size(K0)), [zeros(size(K0,1), Neff), K1adj], K0]; 479 non_singular_sites_Ginv = [1:size(K0,1), size(obj.Ginv,1)-size(K0,1)+1:size(obj.Ginv,1)]; 480 obj.Ginv = obj.DecimationFunction( non_singular_sites_Ginv, obj.Ginv ); 482 % transform back to the normal space 483 V_tot = [V, zeros(size(K0)); zeros(size(K0)), V]; 484 obj.Ginv = V_tot*obj.Ginv*V_tot';
489 %> gauge transformation of the vector potential in the effective
Hamiltonians 492 % gauge transformation on Green
's function 493 if ~isempty(obj.Ginv) && ~isempty(obj.PeierlsTransform_Scatter) && isempty(obj.q) && ~isempty(obj.gauge_field) 494 coordinates_scatter = obj.getCoordinates(); 495 %> gauge transformation on the inverse Green's
function 496 obj.Ginv = obj.PeierlsTransform_Scatter.gaugeTransformation( obj.Ginv, coordinates_scatter, obj.gauge_field );
499 err = MException(
'EQuUs:Utils:Ribbon:CalcFiniteGreensFunction',
'Unable to perform gauge transformation');
500 err = addCause(err, errCause);
501 save(
'Error_Ribbon_CalcFiniteGreensFunction.mat')
507 rcond_Ginv = rcond(obj.Ginv);
508 if isnan(rcond_Ginv ) || abs( rcond_Ginv ) < 1e-15
509 obj.display( 'EQuUs:Utils:
Ribbon::CalcFiniteGreensFunction: Regularizing Ginv by SVD', 1);
510 obj.G = obj.inv_SVD( obj.Ginv );
512 obj.G = inv(obj.Ginv);
521 %% CalcFiniteGreensFunctionFromHamiltonian
522 %> @brief Calculates the Green operator of the scattering region from the whole Hamiltonian.
523 %> @
param varargin Cell array of optional parameters (https:
524 %> @
param 'gauge_trans' Logical value. Set true to perform gauge transformation on the Green operator and on the
Hamiltonians.
525 %> @
param 'onlyGinv' Logical value. Set true to calculate only the inverse of the surface Greens function
#Ginv, or false (default) to calculate #G as well. In the latter case the attribute #Ginv is set to empty at the end. 526 %> @
param 'PotInScatter' Obsolete parameter. Use
'scatterPotential' instead.
527 %> @
param 'scatterPotential' A
function handle pot=f( #coordinates ) or pot=f( #
CreateHamiltonians, Energy)
for the potential to be applied in the Hamiltonian (used when FiniteGreensFunctionFromHamiltonian=
true).
528 function CalcFiniteGreensFunctionFromHamiltonian( obj, varargin )
531 p.addParameter(
'gauge_trans',
false); % logical:
true if want to perform gauge transformation on the Green
's function and Hamiltonians 532 p.addParameter('onlyGinv
', false); 533 p.addParameter('PotInScatter
', []) %OBSOLETE use scatterPotential instead 534 p.addParameter('scatterPotential
', []) %NEW overrides optional argument 'PotInScatter
', might be a cell array of function handles 535 p.parse(varargin{:}); 536 gauge_trans = p.Results.gauge_trans; 537 onlyGinv = p.Results.onlyGinv; 539 scatterPotential = p.Results.PotInScatter; 540 if ~isempty( p.Results.scatterPotential ) 541 scatterPotential = p.Results.scatterPotential; 545 CreateH = obj.CreateH.CreateClone(); 547 Hscatter = CreateH.Read('Hscatter
'); 548 Hscatter_transverse = CreateH.Read('Hscatter_transverse
'); 551 %> apply magnetic field in scatter for finite q 552 if ~isempty( obj.PeierlsTransform_Scatter ) && ~isempty(obj.q) 553 obj.display('EQuUs:Utils:
Ribbon:CalcFiniteGreensFunctionFromHamiltonian: Applying magnetic field in the scattering region
') 554 obj.PeierlsTransform_Scatter.PeierlsTransform( CreateH ); 557 %> apply custom potential in the scattering center 558 if ~isempty(scatterPotential) 559 if iscell( scatterPotential ) 560 for idx = 1:length( scatterPotential ) 561 obj.ApplyPotentialInScatter( CreateH, scatterPotential{idx} ); 564 obj.ApplyPotentialInScatter( CreateH, scatterPotential); 566 Hscatter = CreateH.Read('Hscatter
'); 569 non_singular_sites_Ginv = CreateH.Read('kulso_szabfokok
'); 572 q = CreateH.Read('q
'); 573 if ~isempty( q ) && ~CreateH.Read('HamiltoniansDecimated
') 574 Hscatter = Hscatter + Hscatter_transverse*diag(exp(-1i*q)) + Hscatter_transverse'*diag(exp(1i*q));
577 obj.display(
'EQuUs:Utils:Ribbon:CalcFiniteGreensFunctionFromHamiltonian: Calculating the surface Green function of the scattering region.')
578 Hscatter = (sparse(1:size(Hscatter,1), 1:size(Hscatter,1), obj.E, size(Hscatter,1),size(Hscatter,1)) - Hscatter);
579 indexes =
false( size(Hscatter,1), 1);
580 indexes(non_singular_sites_Ginv) =
true;
581 Hscatter = [ Hscatter( ~indexes, ~indexes) , Hscatter(~indexes, indexes);
582 Hscatter(indexes, ~indexes), Hscatter(indexes, indexes)];
584 obj.G = obj.partialInv( Hscatter, length(non_singular_sites_Ginv) );
586 obj.CreateRibbon(
'justHamiltonians',
true);
589 %> gauge transformation of the vector potential in the effective
Hamiltonians 592 % gauge transformation on Green
's function 593 if ~isempty(obj.G) && ~isempty(obj.PeierlsTransform_Scatter) && isempty(obj.q) && ~isempty(obj.gauge_field) 594 surface_coordinates = obj.getCoordinates(); 595 %> gauge transformation on the inverse Green's
function 596 obj.G = obj.PeierlsTransform_Scatter.gaugeTransformation( obj.G, surface_coordinates, obj.gauge_field );
599 err = MException(
'EQuUs:Utils:Ribbon:CalcFiniteGreensFunctionFromHamiltonian',
'Unable to perform gauge transformation');
600 err = addCause(err, errCause);
601 save(
'Error_Ribbon_CalcFiniteGreensFunctionFromHamiltonian.mat')
607 rcond_G = rcond(obj.G);
608 if isnan(rcond_G ) || abs( rcond_G ) < 1e-15
609 obj.display( 'EQuUs:Utils:
Ribbon:CalcFiniteGreensFunctionFromHamiltonian: Regularizing Ginv by SVD',1);
610 obj.Ginv = obj.inv_SVD( obj.G );
612 obj.Ginv = inv(obj.G);
621 %> @brief Creates the
Hamiltonians for the ribbon shaped scattering region.
622 %> @
param varargin Cell array of optional parameters (https:
623 %> @
param 'justHamiltonians' Logical value. Set true to create the Hamiltonian of the unit cell without performing any further calculations. (default value is 'false')
624 function CreateRibbon( obj, varargin )
627 p.addParameter('justHamiltonians', false);
628 p.parse(varargin{:});
629 justHamiltonians = p.Results.justHamiltonians;
632 if ~obj.Scatter_UC.Read(
'HamiltoniansCreated' )
633 obj.display(
'EQuUs:Utils:Ribbon:CreateRibbon: Creating ribbon Hamiltonian.' )
634 obj.Scatter_UC.CreateHamiltonians(
'toSave', 0);
635 obj.Scatter_UC.ShiftCoordinates( obj.shift );
637 %applying transverse potential
638 obj.ApplyTransversePotential( obj.Scatter_UC )
644 % apply magnetic field in scatter
645 if ~isempty( obj.PeierlsTransform_Scatter ) && ~obj.Scatter_UC.Read(
'MagneticFieldApplied') && obj.Opt.magnetic_field_trans_invariant
646 obj.display(
'EQuUs:Utils:Ribbon:CreateRibbon: Applying magnetic field in ribbon Hamiltonians')
647 obj.PeierlsTransform_Scatter.PeierlsTransformLeads( obj.Scatter_UC );
654 if ~obj.Scatter_UC.Read(
'HamiltoniansDecimated' )
655 obj.display(
'EQuUs:Utils:Ribbon:CreateRibbon: Solving the eigenproblem in the scattering region' )
657 %> Trukkos sajatertek
658 obj.display([
'EQuUs:Utils:Ribbon:CreateRibbon: Eigenvalues of the scattering region'])
659 obj.Scatter_UC.TrukkosSajatertekek(obj.E);
661 obj.display([
'EQuUs:Utils:Ribbon:CreateRibbon: Group velocity for the scattering region'])
662 obj.Scatter_UC.Group_Velocity();
669 %> @brief Creates the
Hamiltonians for the
interface regions between the leads and scattering center.
670 %> @
param idx Identification number of the
interface region.
671 %> @
param varargin Cell array of optional parameters (https:
672 %> @
param 'UseHamiltonian' Logical value. Set
true if the interface region should be created to match to the whole Hamiltonian of the scattering center, false (
default)
if only the surface Green
operator of the scattering center is used in the calculations.
673 function CreateInterface( obj, idx, varargin )
676 p.addParameter(
'UseHamiltonian',
false); %
true if the
interface region is matched to the whole Hamiltonian of the scattering center, false if the surface Green operator of the scattering center is used in the calculations.
677 p.parse(varargin{:});
678 UseHamiltonian = p.Results.UseHamiltonian;
680 %> Hamiltoninans of the
interface region
681 Interface_Region = obj.Interface_Regions{idx};
683 % The regularization of the
interface is performed according to the Leads
684 Leads = obj.FL_handles.Read(
'Leads' );
687 Interface_Region.Write(
'coordinates2', obj.getCoordinates() );
688 Interface_Region.Write(
'K0',
Lead.
Read(
'K0'));
689 Interface_Region.Write(
'K1',
Lead.
Read(
'K1'));
690 Interface_Region.Write(
'K1adj',
Lead.
Read(
'K1adj'));
691 Interface_Region.Write(
'K1_transverse',
Lead.
Read(
'K1_transverse'));
692 Interface_Region.Write(
'coordinates',
Lead.
Read(
'coordinates'));
693 Interface_Region.Write(
'kulso_szabfokok',
Lead.
Read(
'kulso_szabfokok'));
694 Interface_Region.Write(
'OverlapApplied',
true);
696 coordinates_shift = [1, -1 ]; %relative to the leads
697 Interface_Region.ShiftCoordinates( coordinates_shift(idx) );
699 %> coupling between the
interface and the scattering region
700 Surface_sc = obj.createSurface_sc( idx );
701 Surface_sc.ApplyOverlapMatrices(obj.E);
704 Lead_Orientation = Surface_sc.Read(
'Lead_Orientation');
705 K1 = Surface_sc.Read(
'K1');
706 K1adj = Surface_sc.Read(
'K1adj');
707 [rows, cols] = find( K1 );
709 cols = unique(cols); % identical as non_singular_sites
710 if Lead_Orientation == 1
713 Hscatter = obj.CreateH.Read(
'Hscatter');
714 if isempty( Hscatter)
715 error(
'EQuUs:utils:Ribbon:CreateInterface: Hamiltonian of the scattering region needs to be constructed first.')
717 Neff = size(Hscatter,1)-size(K1,2);
718 if ~
Lead.Read('is_SVD_transformed')
720 Kcoupling = [K1, sparse([], [], [], size(K1,1), Neff )];
721 Kcouplingadj = [K1adj; sparse([], [], [], Neff, size(K1,1))];
723 % regularization with SVD
724 Kcoupling = [K1, sparse([], [], [], size(K1,1), Neff )];
725 Kcouplingadj = [K1adj; sparse([], [], [], Neff, size(K1,1))];
728 Neff = length(rows); %number of coupling
sites at Lead_Oriantation=-1
729 if ~
Lead.Read('is_SVD_transformed')
731 Kcoupling = [K1(:,cols), zeros( size(K1,1), Neff )];
732 Kcouplingadj = [K1adj(cols,:); zeros(Neff, size(K1,1))];
734 % regularization with SVD
735 Kcoupling = [K1(:,cols), zeros(size(K1,1), Neff )];
736 Kcouplingadj = [K1adj(cols,:); zeros(Neff, size(K1,1))];
742 elseif Lead_Orientation == -1
745 Hscatter = obj.CreateH.Read('Hscatter');
746 if isempty( Hscatter)
747 error('EQuUs:utils:
Ribbon:CreateInterface: Hamiltonian of the scattering region needs to be constructed first.')
749 Neff = size(Hscatter,1)-size(K1adj,2);
750 if ~
Lead.Read('is_SVD_transformed')
752 Kcoupling = [sparse([], [], [], length(cols), Neff ), K1adj(cols,:)];
753 Kcouplingadj = [sparse([], [], [], Neff, length(cols)); K1(:,cols)];
755 % regularization with SVD
756 Kcoupling = [sparse([], [], [], size(K1adj,1), Neff ), K1adj];
757 Kcouplingadj = [sparse([], [], [], Neff, size(K1,1) ); K1];
760 Neff = length(cols); %number of coupling
sites at Lead_Oriantation=1
761 if ~
Lead.Read('is_SVD_transformed')
763 Kcoupling = [zeros(length(cols), Neff), K1adj(cols,rows)];
764 Kcouplingadj = [zeros(Neff, length(cols)); K1(rows,cols)];
766 % regularization with SVD
767 Kcoupling = [zeros(size(K1,1), Neff), K1adj(:,rows)];
768 Kcouplingadj = [zeros(Neff, size(K1,2)); K1(rows,:)];
774 error('EQuUs:Utils:
Ribbon:CreateInterface', 'Unknown lead orientation');
779 Interface_Region.Write('Kcoupling', Kcoupling);
780 Interface_Region.Write('Kcouplingadj', Kcouplingadj);
782 % method to adjust the interface region and coupling to the scattering region by an external function.
783 if ~isempty( obj.interfacemodel )
784 obj.interfacemodel( Interface_Region );
787 Interface_Region.Calc_Effective_Hamiltonians( 0, '
Lead', Lead );
792 %> @brief Creates a clone of the present
object.
793 %> @return Returns with the cloned
object.
794 function ret = CreateClone( obj )
796 ret =
Ribbon( 'width', obj.width, ...
797 'height', obj.height, ...
798 'filenameIn', obj.filenameIn, ...
799 'filenameOut', obj.filenameOut, ...
803 'silent', obj.silent, ...
804 'transversepotential', obj.transversepotential, ...
806 '
param', obj.param, ...
808 'leadmodel', obj.leadmodel, ...
809 'interfacemodel', obj.interfacemodel);
812 ret.CreateH = obj.CreateH.CreateClone();
813 ret.FL_handles = obj.FL_handles.CreateClone();
814 ret.Scatter_UC = obj.Scatter_UC.CreateClone();
815 ret.Interface_Regions = cell(size(obj.Interface_Regions));
816 for idx = 1:length(obj.Interface_Regions)
817 ret.Interface_Regions{idx} = obj.Interface_Regions{idx}.
CreateClone();
819 if ~isempty( obj.PeierlsTransform_Scatter )
820 ret.PeierlsTransform_Scatter = obj.PeierlsTransform_Scatter.CreateClone();
823 if ~isempty( obj.PeierlsTransform_Leads )
824 ret.PeierlsTransform_Leads = obj.PeierlsTransform_Leads.CreateClone();
833 methods ( Access = protected )
836 %> @brief Sets the Fermi energy on the atomic
sites for the calculations (use the same units as the elements of the Hamiltonian).
837 function setFermiEnergy( obj )
839 obj.
param.scatter.epsilon = obj.
param.scatter.epsilon - obj.EF;
840 for idx = 1:length(obj.
param.Leads)
847 %> @brief Creates the copuling
Hamiltonians between the scattering and
interface region
848 %> @
param idx The identification number of the
interface region. (Integer value.)
849 %> @
return An instance of
class #
Lead describing the copuling between the scattering and interface region
850 function Surface_sc = createSurface_sc( obj, idx )
851 Surface_sc = obj.Scatter_UC.
CreateClone(
'empty',
true);
853 if ~isempty( obj.param.Leads{idx}.vargamma_sc )
855 params.vargamma = obj.
param.Leads{idx}.vargamma_sc;
861 coordinates_shift = 0 + obj.shift ;
863 coordinates_shift = obj.height-1 + obj.shift;
866 Surface_sc.
Write(
'Hanyadik_Lead', idx);
867 Surface_sc.
Write(
'Lead_Orientation', obj.Interface_Regions{idx}.Read(
'Lead_Orientation'));
869 %> applying transverse potential
870 obj.ApplyTransversePotential( Surface_sc )
872 %> applying magnetic field
873 if ~isempty( obj.PeierlsTransform_Leads )
874 %> In superconducting lead one must not include nonzero magnetic
877 %> traslational invariant.
879 obj.display(
'EQuUs:Utils:Ribbon:createSurface_sc: Applying magnetic field in the Hamiltonians')
880 obj.PeierlsTransform_Leads.PeierlsTransformLeads( Surface_sc );
882 obj.display(
'EQuUs:Utils:Ribbon:createSurface_sc: Applying gauge transformation in the Hamiltonians')
883 obj.PeierlsTransform_Leads.gaugeTransformationOnLead( Surface_sc, obj.gauge_field );
890 %% ApplyTransversePotential
891 %> @brief Apply the tranvesre potential in the
Hamiltonians 893 function ApplyTransversePotential( obj, Scatter_UC )
894 if ~isempty(obj.transversepotential) && isempty(obj.q) %In transverse computations no transverse potential can be applied
896 if nargin( obj.transversepotential ) == 1
897 potential2apply = obj.transversepotential( coordinates );
898 elseif nargin( obj.transversepotential ) == 2
899 potential2apply = obj.transversepotential( Scatter_UC, obj.E );
901 error(
'EQuUs:Utils:Ribbon:ApplyTransversePotential',
'To many input arguments in function handle scatterpotential');
904 if isfield(coordinates,
'BdG_u')
905 if size( potential2apply, 1) == 1 || size( potential2apply, 2) == 1
906 potential2apply(~coordinates.BdG_u) = -potential2apply(~coordinates.BdG_u);
908 potential2apply(~coordinates.BdG_u, ~coordinates.BdG_u) = -conj(potential2apply(~coordinates.BdG_u, ~coordinates.BdG_u));
919 %> @brief Initializes the attributes of the class.
920 function CreateHandles( obj )
924 obj.Scatter_UC = obj.FL_handles.SurfaceGreenFunctionCalculator([], 'createCore', 1, 'q', obj.q);
928 %% calculate_lead_attach_points
929 %> @brief Determines the site indexes at which the leads are connected to the scattering center.
930 function calculate_lead_attach_points( obj )
931 for idx = 1:length(obj.
param.Leads)
937 %> @brief Creates the geometry data of the ribbon shaped scattering region.
940 if ~isempty( obj.width ) && ~isempty( obj.height )
948 err = MException(['EQuUs:utils:', class(obj), ':
createShape'], 'Shape is not given correctly, width is missing');
955 err = MException(['EQuUs:utils:', class(obj), ':createShape'], 'Shape is not given correctly, height is missing');
959 obj.calculate_lead_attach_points();
963 end % protected methods
966 methods (Access=protected)
970 %> @brief Parses the optional parameters for the class constructor.
972 %> @
param 'width' Integer. The number of the nonsingular atomic
sites in the cross section of the ribbon.
973 %> @
param 'height' Integer. The height of the ribbon in units of the lattice vector.
974 %> @
param 'filenameIn' The input filename containing the computational parameters. (Use parameters 'Op' and '
param' instead)
975 %> @
param 'filenameOut' The output filename to export the computational parameters.
976 %> @
param 'WorkingDir' The absolute path to the working directoy.
977 %> @
param '
E' The energy value used in the calculations (in the same units as the Hamiltonian).
978 %> @
param 'EF' The Fermi energy in the same units as the Hamiltonian. Attribute
#E is measured from this value. (Use for equilibrium calculations in the zero temperature limit. Overrides the one comming from the external source) 979 %> @
param 'silent' Set
true to suppress output messages.
982 %> @
param 'interfacemodel' A
function handle f( #
InterfaceRegion ) to manually adjus the
interface regions. (Usefull when 'leadmodel' is also given. For example see @InterfaceModel)
983 %> @
param 'Opt' An instance of the structure #
Opt.
984 %> @
param 'param' An instance of the structure #
param.
985 %> @
param 'q' The transverse momentum quantum number.
986 function InputParsing( obj, varargin )
989 p.addParameter(
'width', obj.width);
990 p.addParameter(
'height', obj.height);
991 p.addParameter(
'filenameIn', obj.filenameIn, @ischar);
992 p.addParameter(
'filenameOut', obj.filenameOut, @ischar);
993 p.addParameter(
'WorkingDir', obj.WorkingDir, @ischar);
994 p.addParameter(
'E', obj.E, @isscalar);
995 p.addParameter(
'EF', obj.EF);
996 p.addParameter(
'silent', obj.silent);
997 p.addParameter(
'transversepotential', obj.transversepotential);
998 p.addParameter(
'leadmodel', obj.leadmodel); %individual physical model
for the contacts
999 p.addParameter(
'interfacemodel', obj.interfacemodel); %individual physical model
for the
interface regions
1000 p.addParameter('
Opt', obj.
Opt);
1001 p.addParameter(
'param', obj.param);
1002 p.addParameter(
'q', obj.q);
1004 p.parse(varargin{:});
1006 InputParsing@
NTerminal( obj,
'filenameIn', p.Results.filenameIn, ...
1007 'filenameOut', p.Results.filenameOut, ...
1008 'WorkingDir', p.Results.WorkingDir, ...
1009 'E', p.Results.E, ...
1010 'EF', p.Results.EF, ...
1011 'silent', p.Results.silent, ...
1012 'leadmodel', p.Results.leadmodel, ...
1013 'interfacemodel', p.Results.interfacemodel, ...
1014 'Opt', p.Results.Opt, ...
1015 'param', p.Results.param, ...
1019 obj.width = p.Results.width;
1020 obj.height = p.Results.height;
1021 obj.transversepotential = p.Results.transversepotential;
1025 end % methdos
private A class describing an N-terminal geometry for equilibrium calculations mostly in the zero temperature...
function isSuperconducting()
Test, whether the lead is in the superconducting phase or not.
function InputParsing(varargin)
Parses the optional parameters for the class constructor.
lead_param Leads
A list of structures lead_param containing the physical parameters for the scattering region...
function Landaux(x, y, eta_B, Aconst, height, lattice_constant)
Vector potential in the Landau gauge parallel to the x direction.
function CreateClone(varargin)
Creates a clone of the present class.
Property params
An instance of the structure lead_param.
Structure Opt contains the basic computational parameters used in EQuUs.
Structure open_channels describes the open channel in the individual leads.
function Conduktance()
Calculates the conductance matrix from the scattering matrix.
Structure shape contains data about the geometry of the scattering region.
function Write(MemberName, input)
Sets the value of an attribute in the class.
Class to create and store Hamiltonian of the translational invariant leads.
A class for calculations on a ribbon of finite width for equilibrium calculations mostly in the zero ...
Property H1
The coupling Hamiltonian between the unit cells.
function CalcFiniteGreensFunction(varargin)
Calculates the Green operator of the scattering region.
function Transport(Energy, B)
creating the Ribbon class representing the twoterminal setup
A class to evaluate the Dyson equation and to calculate the scattering matrix for equilibrium process...
function Hamiltonians(varargin)
Function to create the custom Hamiltonians for the 1D chain.
Property varargin
list of optional parameters (see http://www.mathworks.com/help/matlab/ref/varargin.html for details)
function createOutput(filename, Opt, param)
This function creates an output file containing the running parameters.
function Landauy(x, y, eta_B)
Vector potential in the Landau gauge parallel to the y direction.
function CreateHamiltonians(Opt, param, varargin)
Constructor of the class.
function CreateHamiltonians(varargin)
Creates the Hamiltonians H_0 and H_1 of the lead.
Property q
A transverse momentum.
function Reset()
Resets all elements in the class.
Property Hcoupling
Coupling Hamiltonian from the interface region to the scattering region.
A class describing the interface region between the scattering region and a lead. ...
A class to calculate the Green functions and self energies of a translational invariant lead The nota...
Property varargin
list of optional parameters (see http://www.mathworks.com/help/matlab/ref/varargin.html for details)
Structure param contains data structures describing the physical parameters of the scattering center ...
Property Lead_Orientation
The orientation of the lead. Set +1 is the "incoming" direction of the propagating states is defined ...
scatter_param scatter
An instance of the structure scatter_param containing the physical parameters for the scattering regi...
Structure sites contains data to identify the individual sites in a matrix.
function ShiftCoordinates(shift)
Shifts the coordinates of the sites by an integer multiple of the lattice vector Coordinates.a.
function Read(MemberName)
Query for the value of an attribute in the class.
epsilon
A physical parameter, see the individual lattice documentations for details.
Property Opt
An instance of structure Opt.
shape shape
An instance of structure shape describing the geometry of the scattering region.
function CreateClone(varargin)
Creates a clone of the present Lead object.
function SurfaceGreenFunctionCalculator(idx, varargin)
Calculates the surface Green's function or the self energy of a Lead.
function gauge_field(x, y, eta_B, Aconst, height, lattice_constant)
Scalar gauge field connecting Landaux and Landauy gauges.
function Conductance2()
Conductance calculated by Eq (19) in PRB 73 085414.
Property E
The energy value for which the TrukkosSajatertekek eigenvalue problem was solved. ...
width
The number of sites in the cross section.
Structure containing the coordinates and other quantum number identifiers of the sites in the Hamilto...
function AddPotential(V)
Adds on-site potential to the Hamiltonian H0.
function Read(MemberName)
Query for the value of an attribute in the class.
Structure junction_sites contains data to identify the individual sites of the leads, the interface regions and the scattering region in a matrix.
Property coordinates
An instance of the structure coordinates.
A class to create and store Hamiltonian of the scattering region.