% Rotationsspule besteht aus einer Wicklung und zwei geometrisch identischen Topfkernen mit Luftspalt

classdef RotSpule
    %% Konstanten
    properties (Constant = true, Hidden = true)
        % Standard-Radius der Welle
        % [r_Welle_std] = m
        r_Welle_std = 2e-3;
        
        % Standard-Dicke des nichtferromagnetischen Abstandhalters zwischen Welle und Topfkernen
        % [b_Abtandhalter_std] = m
        b_Abstandhalter_std = 1e-3;
        
        % Standard-Länge (gesamt) beider Luftspalte in axialer Richtung
        % [l_Luft_ax_std] = m
        l_Luft_ax_std = 1e-3;        
    end
    %% Lese-Attribute
    properties (GetAccess = public, SetAccess = protected)
        % Name der Instanz
        Name = '';
    end
    
    %% freie Attribute
    properties (Access = public)
        % Radius der Welle
        % [r_Welle] = m
        r_Welle;
        
        % Dicke des nichtferromagnetischen Abstandhalters zwischen Welle und Topfkernen
        % [b_Abtandhalter] = m
        b_Abstandhalter;
        
        % Länge (gesamt) beider Luftspalte in axialer Richtung
        % [l_Luft_ax] = m
        l_Luft_ax;
        
        % Objekt/Instanz der Klasse "RotWicklung"
        W;
        
        % Objekt/Instanz der Klasse "RotTopfkern"
        TK;               
    end
    
    %% abhängige Attribute
    properties (Dependent = true)
        % axiale Länge
        % [l_ax] = m
        l_ax;
        
        % äußerer Radius
        % [r_a] = m
        r_a;
    end
    
    %% abhängige Attribute (intern)
    properties (Dependent = true, Hidden = true)
        % Wicklungskörper-Koordinaten in axiale Richtung; [WK_KO_ax] = m
        WK_KO_ax;
        
        % Wicklungskörper-Koordinaten in radiale Richtung; [WK_KO_rad] = m
        WK_KO_rad;
        
    end
    
    %% Methoden
    methods
        %% Konstruktor
        function obj = RotSpule(Name)
            obj.Name = Name;
            obj.r_Welle = obj.r_Welle_std;
            obj.b_Abstandhalter = obj.b_Abstandhalter_std;
            obj.l_Luft_ax = obj.l_Luft_ax_std;
            obj.W = RotWicklung('Wicklung in RotSpule');
            obj.TK = RotTopfkern('Topfkern in RotSpule');
        end
        
        %% Set-Methoden
        function obj = set.r_Welle(obj, r_Welle)
            if r_Welle <= 0
                obj.r_Welle = obj.r_Welle_std;
            else
                obj.r_Welle = r_Welle;
            end
        end
        function obj = set.b_Abstandhalter(obj, b_Abstandhalter)
            if b_Abstandhalter <= 0
                obj.b_Abstandhalter = obj.b_Abstandhalter_std;
            else
                obj.b_Abstandhalter = b_Abstandhalter;
            end
        end
        function obj = set.l_Luft_ax(obj, l_Luft_ax)
            if l_Luft_ax < 0
                obj.l_Luft_ax = obj.l_Luft_ax_std;
            else
                obj.l_Luft_ax = l_Luft_ax;
            end
        end
        
        %% Get-Methoden
        function W = get.W(obj)
            % Aktualisierung des inneren Radius der Wicklung
            obj.W.r_i = obj.TK.r_i_a;
            
            % Ausgabe
            W = obj.W;
        end
        function TK = get.TK(obj)
            % Aktualisierung des inneren Radius der Topfkerne
            obj.TK.r_i = obj.r_Welle + obj.b_Abstandhalter;
            
            % Aktualisierung der inneren axialen Länge der Topfkerne
            obj.TK.l_ax_i = 0.5 * obj.W.l_ax - 0.25 * obj.l_Luft_ax;
            
            % Ausgabe
            TK = obj.TK;
        end
        
        %% Get-Methoden für Dependent-Attribute
        function l_ax = get.l_ax(obj)
            l_ax = 2 * obj.TK.l_ax + 0.5 * obj.l_Luft_ax;
        end
        function r_a = get.r_a(obj)
            r_a = obj.TK.r_a;
        end
    end
end