ThreeTerminalHamiltonians.m

Go to the documentation of this file.

%    Creates Hamiltonians for Three-terminal setup - based on EQuUs v4.9
%    Copyright (C) 2015 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 ThreeTerminalHamiltonians.m
%> @brief Function to create custom Hamiltonians for unit tests on a Three-terminal setup.
%> @Available
%> EQuUs v4.9 or later
%> @}
%
%> @brief Function to create custom Hamiltonians for unit tests on a Three-terminal setup.
%> @param Opt An instance of structure #Opt.
%> @param Opt An instance of structure #param.
%> @param varargin Cell array of optional parameters identical to #Custom_Hamiltonians.LoadHamiltonians.
%> @return [1] Cell array of Hamiltonians of one slab in the leads
%> @return [2] Cell array of overlap integrals of one slab in the leads
%> @return [3] Cell array of couplings between the slabs of the leads
%> @return [4] Cell array of overlap integrals between the slabs of the leads
%> @return [5] Cell array of transverse coupling between the unit cells of the lead
%> @return [6] Cell array of #coordinates of the leads
%> @return [7] Hamiltonian of the scattering region
%> @return [8] Overlap integrals of the scattering region
%> @return [9] Transverse coupling for the scattering region
%> @return [10] Overlap integrals for the transverse coupling in the scattering region
%> @return [11] #coordinates of the scattering region
%> @return [12] Cell array of couplings between the scattering region and the leads
%> @return [13] Cell array of overlap integrals between the scattering region and the leads
    function [H0, S0, H1, S1, H1_transverse, coordinates, Hscatter, Sscatter, Hscatter_transverse, Sscatter_transverse, coordinates_scatter, Hcoupling, Scoupling] = ThreeTerminalHamiltonians( Opt, param, varargin )
        p = inputParser;
        p.addParameter('q', []);
        p.parse(varargin{:});
        
        q = p.Results.q;
        
        % setting lattice type to Squere
        Opt.Lattice_Type = 'Square';
        % turn of the BdG model
        Opt.BdG = false;
        
        % turning off custom Hamiltonians
        Opt.custom_Hamiltonians = [];
        
        % creating structures of physical parameters for the scattering region
        param_scatter_loc = param_Square_scatter();
        param_scatter_loc = param_scatter_loc.CopyParameters( param.scatter );
        param.scatter = param_scatter_loc;
        
        % creating structures of physical parameters for the leads
        for idx = 1:length( param.Leads )
            param_lead_loc = param_Square_Lead();
            param_lead_loc = param_lead_loc.CopyParameters( param.Leads{idx} );
            param.Leads{idx} = param_lead_loc;
        end
      
        
        % Create class to crate the Hamiltonian of the scattering region
        createH = CreateHamiltonians( Opt, param, 'q', q );
        % Creating Hamiltonian for the scattering region
        createH.CreateScatterH();
        % read out Hamiltonian and coordinates
        Hscatter = createH.Read('Hscatter');
        Sscatter = createH.Read('Sscatter');
        coordinates_scatter = createH.Read('coordinates');
        
             
        
        % preallocating arrays for the Hamiltonians of the leads
        coordinates = cell(size(param.Leads));
        H0 = cell(size(param.Leads));
        H1 = cell(size(param.Leads));
        S0 = cell(size(param.Leads));
        S1 = cell(size(param.Leads));
        H1_transverse = cell(size(param.Leads));        
        Leads = cell(size(param.Leads));
        Hscatter_transverse = [];
        Sscatter_transverse = [];
        
        % setting the width of the third lead
        if numel(param.Leads) > 2
            param.Leads{3}.M = param.scatter.shape.width;
        end
        
        % creating Hamiltonians for the leads
        for jdx = 1:length(param.Leads)
            
            % creating class to describe a given lead
            Lead_Orientation = param.Leads{jdx}.Lead_Orientation;            
            Leads{jdx} = CreateLeadHamiltonians( Opt, param, 'Hanyadik_Lead', jdx, 'q', q, 'Lead_Orientation', Lead_Orientation);
            
            % creating the Hamiltonian of a given lead
            Leads{jdx}.CreateHamiltonians();
            
            
            % Read out the Hamiltonians and coordinates
            H0{jdx} = Leads{jdx}.Read('H0');            
            H1{jdx} = Leads{jdx}.Read('H1');            
            S0{jdx} = Leads{jdx}.Read('S0');            
            S1{jdx} = Leads{jdx}.Read('S1');  
            H1_transverse{jdx} = Leads{jdx}.Read('H1_transverse'); 
            coordinates{jdx} = Leads{jdx}.Read('coordinates'); 
            
        end
        
        
        
        
        % preallocating arrays for the Hamiltonians of the interface regions
        Hcoupling = cell(size(param.Leads));
        Scoupling = cell(size(param.Leads));
        
        % creating coupling Hamiltonians
        Hcoupling{1} = sparse( 1:param.Leads{1}.M, 1:param.Leads{1}.M, param.Leads{1}.vargamma_sc, param.Leads{1}.M, size(Hscatter,2));
        Hcoupling{2} = sparse( 1:param.Leads{2}.M, param.scatter.shape.width-param.Leads{2}.M+1:param.scatter.shape.width, param.Leads{2}.vargamma_sc, param.Leads{2}.M, size(Hscatter,2));
        
        if numel(param.Leads) > 2
            Hcoupling{3} = sparse( 1:param.Leads{3}.M, size(Hscatter,1)-param.Leads{3}.M+1:size(Hscatter,1), param.Leads{3}.vargamma_sc, param.Leads{3}.M, size(Hscatter,2));
        end
        
              
        
        
        
                
    end