Custom_Hamiltonians.m

Go to the documentation of this file.

%%   Eotvos Quantum Transport Utilities - Custom_Hamiltonians
%    Copyright (C) 2015-2016 Peter Rakyta, Ph.D., David Visontai, 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 basic Basic Functionalities
%> @{
%> @file Custom_Hamiltonians.m
%> @brief A class to import custom Hamiltonians provided by other codes or created manually
%> @} 
%> @brief A class to import custom Hamiltonians provided by other codes or created manually
%> @Available
%> EQuUs v4.8 or later
%%
classdef Custom_Hamiltonians < handle & Messages

properties (Access = protected )
    %> An instance of structure param
    param
    %> Cell array of Hamiltonians of one slab in the leads
    H0 = []; 
    %> Cell array of couplings between the slabs of the leads
    H1 = []; 
    %> Cell array of transverse coupling between the unit cells of the lead
    H1_transverse = [];
    %> Hamiltonian of the scattering region
    Hscatter = []; 
    %> transverse coupling for the scattering region
    Hscatter_transverse = [];
    %> Cell array of couplings between the scattering region and the leads
    Hcoupling = []; 
    %> Cell array of overlap integrals of one slab in the leads
    S0 = []; 
    %> Cell array of overlap integrals between the slabs of the leads
    S1 = []; 
    %> overlap integrals for the transverse coupling between the unit cells of the lead
    S1_transverse = [];
    %> Overlap integrals of the scattering region
    Sscatter = []; 
    %> overlap integrals for the transverse coupling in the scattering region
    Sscatter_transverse = [];
    %> Cell array of overlap integrals between the scattering region and the leads
    Scoupling = []; 
    %> Cell array of coordinates of the leads
    coordinates = []; 
    %> coordinates of the scattering region
    coordinates_scatter = []; 
    %> logical value: true if Hamiltonians are loaded, false otherwise.
    Hamiltonians_loaded = false;
    %> The Fermi energy
    EF
    %> Function Handle for the custom Hamiltonians with identical input values as #LoadHamiltonians, and output values described in the example #Hamiltonians.
    CustomHamiltoniansHandle
    %> list of optional parameters (see #InputParsing for details)
    varargin    
end



methods (Access = public )
    
    
%% Constructor of the class
%> @brief Constructor of the class.
%> @param Opt An instance of the structure #Opt.
%> @param param An instance of structure #param.
%> @param varargin Cell array of optional parameters. For details see #InputParsing.
%> @return An instance of the class
function obj = Custom_Hamiltonians( Opt, param, varargin )
    obj = obj@Messages( Opt );
    obj.param = param;
    obj.varargin = varargin;
    
    obj.Initialize();        
    
end


%% LoadHamiltonians
%> @brief Obtain the Hamiltonians from the external source
%> @param varargin Cell array of optional parameters (https://www.mathworks.com/help/matlab/ref/varargin.html):
%> @param 'q' The transverse momentum quantum number.
% @param 'Extmol' The transverse momentum quantum number.
% @param 'GollumInput' The transverse momentum quantum number.
% @param 'WorkingDir' The transverse momentum quantum number.
function LoadHamiltonians(obj, varargin)
    
    if strcmpi( obj.Opt.custom_Hamiltonians, 'siesta' )
        
        p = inputParser;
        p.addParamValue('q', [1]);
        p.addParamValue('Filename', 'HSX');
        p.addParamValue('WorkingDir', pwd);
        p.parse(varargin{:});
        q = p.Results.q;

        %Filename = p.Results.Filename;
        % Coordinatzes needs to be determined : TODO
        [obj.H0, obj.S0, obj.H1, obj.S1, obj.coordinates, ...
            obj.Hscatter, obj.Sscatter, obj.coordinates_scatter, ...
            obj.H1_transverse, obj.S1_transverse, ...
            obj.Hscatter_transverse, obj.Sscatter_transverse, ...
            obj.Hcoupling, obj.Scoupling, obj.EF] = Siesta_Interface(obj.Opt.WorkingDir, obj.param, q );
       
        %obj.H1_transverse = cell(size(obj.H0));
        obj.Hamiltonians_loaded = true;

    %% Yaehmop TB hamiltonian
    elseif strcmpi( obj.Opt.custom_Hamiltonians, 'yaehmop' )
        
                p = inputParser;
        p.addParamValue('q', [1]);
        p.addParamValue('Filename', 'HS');
        p.addParamValue('WorkingDir', pwd);
        p.parse(varargin{:});
        q = p.Results.q;

        % Coordinatzes needs to be determined : TODO
        [obj.H0, obj.S0, obj.H1, obj.S1, obj.coordinates, ...
            obj.Hscatter, obj.Sscatter, obj.coordinates_scatter, obj.Hcoupling, obj.Scoupling, obj.EF] = Yaehmop_Interface(obj.Opt.WorkingDir, obj.param );
       
        obj.H1_transverse = cell(size(obj.H0));
        obj.Hamiltonians_loaded = true;
        
    % Custom created Hamiltonians
    elseif strcmpi( obj.Opt.custom_Hamiltonians, 'custom' )
        
        if isempty(obj.CustomHamiltoniansHandle)
            error(['EQuUs:', class(obj), ':LoadHamiltonians'], 'Undefinied function handle for the custom Hamiltonians')
        end
        
        [obj.H0, obj.S0, obj.H1, obj.S1, obj.H1_transverse, obj.coordinates, ...
            obj.Hscatter, obj.Sscatter, obj.Hscatter_transverse, obj.Sscatter_transverse, ...
            obj.coordinates_scatter, obj.Hcoupling, obj.Scoupling] = obj.CustomHamiltoniansHandle();
        
    else
        error(['EQuUs:', class(obj), ':LoadHamiltonians'], 'Undefinied option of the attribute Opt.custom_Hamiltonians')
        
    end
   
    
    % transform Hamiltonians into grand canonical potential
    if ~isempty( obj.EF )        
        for idx = 1:length( obj.S0 )
            if ~isempty( obj.S0{idx} )
                obj.H0{idx} = obj.H0{idx} - obj.EF*obj.S0{idx};
                obj.H1{idx} = obj.H1{idx} - obj.EF*obj.S1{idx};
            else
                obj.H0{idx} = obj.H0{idx} - obj.EF*speye(size(obj.H0{idx}));
            end
        end  
        
        for idx = 1:length( obj.Scoupling )
            if ~isempty( obj.Scoupling{idx} )
                obj.Hcoupling{idx} = obj.Hcoupling{idx} - obj.EF*obj.Scoupling{idx};
            end            
        end
        
        if ~isempty(obj.Sscatter)
            obj.Hscatter = obj.Hscatter - obj.EF*obj.Sscatter;      
        else            
            obj.Hscatter = obj.Hscatter - obj.EF*speye(size(obj.Hscatter));      
        end
    end
    
    
    obj.Hamiltonians_loaded = true;
    
end





%% Reset
%> @brief Resets all elements in the object.
    function Reset( obj )
        
        if strcmpi( class(obj), 'Custom_Hamiltonians' )
            meta_data = metaclass(obj);
            
            for idx = 1:length(meta_data.PropertyList)
                prop_name = meta_data.PropertyList(idx).Name;
                if strcmp(prop_name, 'Opt') || strcmp( prop_name, 'param') || strcmp(prop_name, 'varargin')
                    continue
                end
                obj.Clear( prop_name ); 
            end   
        end 
        
        obj.Initialize();    
    end



%% Write
%> @brief Sets the value of an attribute in the class.
%> @param MemberName The name of the attribute to be set.
%> @param input The value to be set.
    function Write( obj, MemberName, input)
        
        if strcmp(MemberName, 'param')
            obj.param = input;
            obj.Reset();
            return
        elseif strcmp(MemberName, 'Opt')
            obj.Opt = input;
            obj.Reset();           
        else
               try
               obj.(MemberName) = input;
               catch
                    error(['EQuUs:', class(obj), ':Read'], ['No property to write with name: ',  MemberName]);
               end
        end        
    end
%% Read
%> @brief Query for the value of an attribute in the class.
%> @param MemberName The name of the attribute to be set.
%> @return Returns with the value of the attribute.
    function ret = Read(obj, MemberName)
        try
          ret = obj.(MemberName);
          catch
               error(['EQuUs:', class(obj), ':Read'], ['No property to read with name: ',  MemberName]);
          end 
    end
%% Clear
%> @brief Clears the value of an attribute in the class.
%> @param MemberName The name of the attribute to be cleared.
    function Clear(obj, MemberName)
        try
          obj.(MemberName) = [];
          catch
               error(['EQuUs:', class(obj), ':Clear'], ['No property to clear with name: ',  MemberName]);
          end  
        
    end

end % methods public


methods ( Access = private ) 
    
%% Initialize
%> @brief Initializes object properties.
    function Initialize(obj)
        
        obj.Hamiltonians_loaded = false;
        obj.EF = 0;
        
        obj.InputParsing( obj.varargin{:} )        
    end            
  
%% InputParsing
%> @brief Parses the optional parameters for the class constructor.
%> @param varargin Optional parameters, see the web documantation.
%> @param 'EF' The Fermi energy.
%> @param 'CustomHamiltoniansHandle' A function handle for the custom Hamiltonians with identical input values as #LoadHamiltonians, and output values described in the example #Hamiltonians.
    function InputParsing( obj, varargin )
    
        p = inputParser;
        p.addParameter('EF', []);
        p.addParameter('CustomHamiltoniansHandle', []);
        
        p.parse(varargin{:});

       
        obj.EF       = p.Results.EF;
        obj.CustomHamiltoniansHandle = p.Results.CustomHamiltoniansHandle;
                
        
    end
    

end % methods private

end