test_skew_coupling.m

Go to the documentation of this file.

%%   Eotvos Quantum Transport Utilities
%    Copyright (C) 2019 Peter Rakyta, Ph.D
%
%    This program is free software: you can redistribute it and/or modify
%    it under the terms of the GNU General Public License as published by
%    the Free Software Foundation, either version 3 of the License, or
%    (at your option) any later version.
%
%    This program is distributed in the hope that it will be useful,
%    but WITHOUT ANY WARRANTY; without even the implied warranty of
%    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%    GNU General Public License for more details.
%
%    You should have received a copy of the GNU General Public License
%    along with this program.  If not, see http://www.gnu.org/licenses/.
%
%> @addtogroup unit_tests Unit Tests
%> @{
%> @file test_CreateHamiltonians.m
%> @brief Testfile to check the skew coupling matrix elements in the transport calculations. 
%> @Available
%> EQuUs v5.0.144 or later
%> @}
%> @brief Testfile to check the skew coupling matrix elements in the transport calculations. (Constant vector potential and transverse momentum included in the test)
function test_skew_coupling()


filename = mfilename('fullpath');
[directory, fncname] = fileparts( filename );

    % filename containing the input XML    
    inputXML = 'Basic_Input_Graphene_SOC_Lattice.xml';
    % Parsing the input file and creating data structures
    [Opt, param] = parseInput( fullfile( directory, inputXML ) );
  
    
    % setting the on-site potentials
    param.Leads{1}.epsilon = -0.34;
    param.Leads{2}.epsilon = -0.24;
    param.scatter.epsilon = -0.34;
    
    % staggered A-B potential
    param.Leads{1}.deltaAB = 0*param.Leads{1}.vargamma;
    param.Leads{2}.deltaAB = 0*param.Leads{1}.vargamma;
    param.scatter.deltaAB = 0*param.Leads{1}.vargamma;
    
    % setting the Rashba-type SOC
    param.Leads{1}.Rashba = 0.0*param.Leads{1}.vargamma;
    param.Leads{2}.Rashba = 0.0*param.Leads{1}.vargamma;
    param.scatter.Rashba = 0.0*param.Leads{1}.vargamma;
    
    % setting the Intrinsic SOC
    param.Leads{1}.Intrinsic = 0.01*param.Leads{1}.vargamma;
    param.Leads{2}.Intrinsic = 0.01*param.Leads{1}.vargamma;
    param.scatter.Intrinsic = 0.01*param.Leads{1}.vargamma;
    
    % setting the Valley Zeeman SOC
    param.Leads{1}.ValleyZeeman = 0.00*param.Leads{1}.vargamma;   
    param.Leads{2}.ValleyZeeman = 0.00*param.Leads{1}.vargamma;   
    param.scatter.ValleyZeeman = 0.00*param.Leads{1}.vargamma;   
       

    %> length of the junction (number of unit cells)
    height = 1016;

        
    % setting the transverse momentum
    q = 0;
    
    %% Testing the transport using the whole Hamiltonian of the scattering region without the vector potential
    disp( '***** Testing the transport using the whole Hamiltonian of the scattering region without the vector potential *****' );    
    
    % turning off the vector potential
    Opt.magnetic_field = false;
    Opt.magnetic_field_trans_invariant = [];
                        
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );
    conductance = Transport_q( cRibbon, true, false );
    
    
    %  Transport through the connected leds without the scattering region)
    cRibbon_Leads = Ribbon_Leads('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance_leads = Transport_q( cRibbon_Leads, [], false );
    
    
    checkpoint = norm( conductance - conductance_leads );
    if checkpoint > 1e-6
        warning(['EQuUs:Tests:', fncname, ':checkpoint failed with error ', num2str( checkpoint)]);
    end
    
    %% Testing the transport using the whole Hamiltonian of the scattering region including the vector potential
    disp( '***** Testing the transport using the whole Hamiltonian of the scattering region including the vector potential *****' );    
    
    % turning off the vector potential
    Opt.magnetic_field = true;
    Opt.magnetic_field_trans_invariant = false;
                        
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance = Transport_q( cRibbon, true, false );
    
    
    %  Transport through the connected leds without the scattering region)
    cRibbon_Leads = Ribbon_Leads('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance_leads = Transport_q( cRibbon_Leads, [], false );
    
    checkpoint = norm( conductance - conductance_leads );
    if checkpoint > 1e-6
        warning(['EQuUs:Tests:', fncname, ':checkpoint failed with error ', num2str( checkpoint)]);
    end
    
    
    %% Testing the transport using the translational invariant method without the vector potential
    disp( '***** Testing the transport using the translational invariant method without the vector potential *****' );    
    
    % turning off the vector potential
    Opt.magnetic_field = false;
    Opt.magnetic_field_trans_invariant = [];
                        
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance = Transport_q( cRibbon, false, false );
    
    
    %  Transport through the connected leds without the scattering region)
    cRibbon_Leads = Ribbon_Leads('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance_leads = Transport_q( cRibbon_Leads, [], false );
    
    checkpoint = norm( conductance - conductance_leads );
    if checkpoint > 1e-6
        warning(['EQuUs:Tests:', fncname, ':checkpoint failed with error ', num2str( checkpoint)]);
    end
    
    %% Testing the transport using the translational invariant method including the vector potential
    disp( '***** Testing the transport using the translational invariant method including the vector potential *****' );    
    
    % turning off the vector potential
    Opt.magnetic_field = true;
    Opt.magnetic_field_trans_invariant = true;
                        
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance = Transport_q( cRibbon, false, false );
    
    
    %  Transport through the connected leds without the scattering region)
    cRibbon_Leads = Ribbon_Leads('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance_leads = Transport_q( cRibbon_Leads, [], false ); 
    
    checkpoint = norm( conductance - conductance_leads );
    if checkpoint > 1e-6
        warning(['EQuUs:Tests:', fncname, ':checkpoint failed with error ', num2str( checkpoint)]);
    end
    
    
    
    
    %% Testing the transport using the whole Hamiltonian of the scattering region including the vector potential, comapring to the self-energy results
    disp( '***** Testing the transport using the whole Hamiltonian of the scattering region including the vector potential, comapring to the self-energy results *****' );    
    
    % turning off the vector potential
    Opt.magnetic_field = true;
    Opt.magnetic_field_trans_invariant = true;
                        
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance_self_energy = Transport_q( cRibbon, true, true );
    
    
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance = Transport_q( cRibbon, true, false );
    
    checkpoint = norm( conductance - conductance_self_energy );
    if checkpoint > 1e-6
        warning(['EQuUs:Tests:', fncname, ':checkpoint failed with error ', num2str( checkpoint)]);
    end
    
    
    
    %% Testing the transport using the whole Hamiltonian of the scattering region including the vector potential, comapring to the self-energy results
    disp( '***** Testing the transport using the translational invariant method including the vector potential, comapring to the self-energy results *****' );    
    
    % turning off the vector potential
    Opt.magnetic_field = true;
    Opt.magnetic_field_trans_invariant = true;
                        
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance_self_energy = Transport_q( cRibbon, false, true );
    
    
    % creating the Ribbon class representing the twoterminal setup
    cRibbon = Ribbon('width', 2, 'height', height, 'Opt', Opt, 'param', param, 'q', q );    
    conductance = Transport_q( cRibbon, false, false );
    
    checkpoint = norm( conductance - conductance_self_energy );
    if checkpoint > 1e-6
        warning(['EQuUs:Tests:', fncname, ':checkpoint failed with error ', num2str( checkpoint)]);
    end
    
    
%% Transport_q
%> @brief Calculates the transvere momemntum resolved conductance for a given energy
%> @param Energy The energy value.
%> @param B The magnetic field
%> @param selfEnergy Logical value. Set true to use the self energy in the calculations or false to use the surface Green operator.
    function Conductance = Transport_q( cRibbon_loc, gfininvfromHamiltonian, useSelfEnergy )        
        
        % creating funcfion handles for the constant vector potentials
        Aconst = 1;         
        
        % creting the funciton handles of the vector potentials
        hLandauy = @(x,y)([zeros(size(x)), ones(size(x))*Aconst] );
               
        cRibbon_loc.setHandlesForMagneticField('scatter', hLandauy, 'lead', hLandauy );
        
        % seeting the Energy value in the Ribbon class
     cRibbon_loc.setEnergy( 0 )
        
        % Calculates the surface Green operator of the scattering region
        if gfininvfromHamiltonian
            cRibbon_loc.CalcFiniteGreensFunctionFromHamiltonian(); 
        elseif ~gfininvfromHamiltonian
           cRibbon_loc.CalcFiniteGreensFunction();
        end
        
         % creating function handle for the Dyson Eq.
        Dysonfunc = @()cRibbon_loc.CustomDysonFunc( 'constant_channels', false, 'SelfEnergy', useSelfEnergy );
        
        % Evaluate the Dyson Eq.
        cRibbon_loc.FL_handles.DysonEq( 'CustomDyson', Dysonfunc );
        
        % Calculating the Scattering matrix
        cRibbon_loc.FL_handles.SmatrixCalc();
        
        % Calculate the conductance
        Conductance = cRibbon_loc.FL_handles.Conduktance();
        
        Conductance = Conductance(1,2);
        
          %disp( ['E = ', num2str(Energy), ' conductance = ', num2str(Conductance)])   
    
    end
  


end