WICHTIG: Der Betrieb von goMatlab.de wird privat finanziert fortgesetzt. - Mehr Infos...

Mein MATLAB Forum - goMatlab.de

Mein MATLAB Forum

 
Gast > Registrieren       Autologin?   

Partner:




Forum
      Option
[Erweitert]
  • Diese Seite per Mail weiterempfehlen
     


Gehe zu:  
Neues Thema eröffnen Neue Antwort erstellen

Überkreuz-Abhängigkeiten zweier Objekte

 

JackTheRippchen
Forum-Anfänger

Forum-Anfänger


Beiträge: 14
Anmeldedatum: 26.09.17
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 28.04.2020, 15:09     Titel: Überkreuz-Abhängigkeiten zweier Objekte
  Antworten mit Zitat      
Hinweis 1: Am besten Code-Blöcke erstmal ausblenden und Problembeschreibung lesen.

Problemstellung: Ich möchte eine Klassendefinition für eine Rotationsspule, d.h. eine rotationssymmetrische Spule/Drossel, welche auf einer mechanischen Welle mitrotieren kann, schreiben.
Diese besteht aus einer Wicklung (Wickelkörper und Kupferwindungen) und zwei identischen Topfkernen.

Für Wicklung und Topfkern habe ich jeweils eine Klasse geschrieben, welche autark erstmal funktionieren.

Klasse "RotWicklung":

Code:
% Wicklung umfasst Wickelkörper und aufgewickelten Kupferlackdraht

classdef RotWicklung
    %% Konstanten
    properties (Constant = true, Hidden = true)
        % Standard-Nenndurchmesser des Kupferlackdrahtes; [d_Cu_std] = m
        d_Cu_std = 1e-3;
       
        % Standard-Anzahl Drahwindungen in jede Richtung; [N_std] = 1 (dimensionslos)
        N_std = uint8(2);
       
        % Standard-Dicke des Wicklungskörpers in jede Richtung; [b_std] = m
        b_std = 1e-3;
       
        % Standardwert des inneren Radius des Wicklungskörpers; [r_i_std] = m
        r_i_std = 1e-3;
       
        % Wicklungskörper-Darstellung
        WK_Fuellung_Farbe = [0 0 0.8];
        WK_Fuellung_Transp = 1.0;
           
        % Windungsfenster-Kupfer-Darstellung
        WF_Fuellung_Farbe = [0.8 0.4 0];
        WF_Fuellung_Transp = 1.0;
       
        % Interpreter
        Interpreter = 'tex';
    end
   
    %% Lese-Attribute
    properties (GetAccess = public, SetAccess = protected)
        % Name der Instanz
        Name = '';
    end
   
    %% freie Attribute
    properties (Access = public)
        % Nenndurchmesser des Kupferlackdrahtes; [d_Cu] = m
        d_Cu;
       
        % Anzahl Drahwindungen in axialer Richtung; [N_ax] = 1 (dimensionslos)
        N_ax = uint8(1);
       
        % Anzahl Drahwindungen in radialer Richtung; [N_rad] = 1 (dimensionslos)
        N_rad = uint8(1);
       
        % Dicke des Wicklungskörpers in axialer Richtung; [b_ax] = m
        b_ax;
       
        % Dicke des Wicklungskörpers in radialer Richtung; [b_rad] = m
        b_rad;
       
        % innerer Radius des Wicklungskörpers; [r_i] = m
        r_i = 0;
    end
   
    %% abhängige Attribute
    properties (Dependent)
        % Anzahl Drahtwindungen
        N;
       
        % Länge des Wicklungskörpers in axialer Richtung; [l_ax] = m
        l_ax;
       
        % Länge des Wicklungskörpers in radialer Richtung; [l_rad] = m
        l_rad;
       
        % äußerer Radius des Wicklungskörpers; [r_a] = m
        r_a;
    end
   
    %% abhängige Attribute (intern)
    properties (Dependent, 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;
       
        % Wicklungsfenster-Koordinaten in axiale Richtung; [WF_KO_ax] = m
        WF_KO_ax;
       
        % Wicklungsfenster-Koordinaten in radiale Richtung; [WF_KO_rad] = m
        WF_KO_rad;
    end

    %% Methoden
    methods
        %% Konstruktor
        function obj = RotWicklung(Name)
            obj.Name = Name;
            obj.d_Cu = obj.d_Cu_std;
            obj.N_ax = obj.N_std;
            obj.N_rad = obj.N_std;
            obj.b_ax = obj.b_std;
            obj.b_rad = obj.b_std;
            obj.r_i = obj.r_i_std;
        end
       
        %% Set-Methoden
        function obj = set.d_Cu(obj, d_Cu)
            if d_Cu <= 0
                obj.d_Cu = obj.d_Cu_std;
            else
                obj.d_Cu = d_Cu;
            end
        end
        function obj = set.N_ax(obj, N_ax)
            if N_ax < 1
                obj.N_ax = obj.N_std;
            else
                obj.N_ax = uint8(N_ax);
            end
        end
        function obj = set.N_rad(obj, N_rad)
            if N_rad < 1
                obj.N_rad = obj.N_std;
            else
                obj.N_rad = uint8(N_rad);
            end
        end
        function obj = set.b_ax(obj, b_ax)
            if b_ax <= 0
                obj.b_ax = obj.b_std;
            else
                obj.b_ax = b_ax;
            end
        end
        function obj = set.b_rad(obj, b_rad)
            if b_rad <= 0
                obj.b_rad = obj.b_std;
            else
                obj.b_rad = b_rad;
            end
        end
       
        %% Get-Methoden für Dependent-Attribute
        function N = get.N(obj)
            N = uint16(obj.N_ax) * uint16(obj.N_rad);
        end
        function l_ax = get.l_ax(obj)
            l_ax = 2 * obj.b_ax + double(obj.N_ax) * obj.d_Cu;
        end
        function l_rad = get.l_rad(obj)
            l_rad = obj.b_rad + double(obj.N_rad) * obj.d_Cu;
        end
        function r_a = get.r_a(obj)
            r_a = obj.r_i + obj.l_rad;
        end
       
        %% Get-Methoden für versteckte Dependent-Attribute
        function WK_KO_ax = get.WK_KO_ax(obj)
            WK_KO_ax = [(0) (obj.l_ax) (obj.l_ax) (obj.l_ax - obj.b_ax) (obj.l_ax - obj.b_ax) (0 + obj.b_ax) (0 + obj.b_ax) (0)];
        end
        function WK_KO_rad = get.WK_KO_rad(obj)
            WK_KO_rad = [(obj.r_i) (obj.r_i) (obj.r_a) (obj.r_a) (obj.r_i + obj.b_rad) (obj.r_i + obj.b_rad) (obj.r_a) (obj.r_a)];
        end
        function WF_KO_ax = get.WF_KO_ax(obj)
            WF_KO_ax = [(0 + obj.b_ax) (obj.l_ax - obj.b_ax) (obj.l_ax - obj.b_ax) (0 + obj.b_ax)];
        end
        function WF_KO_rad = get.WF_KO_rad(obj)
            WF_KO_rad = [(obj.r_i) (obj.r_i) (obj.r_a) (obj.r_a)];
        end
       
        %% Darstellungs-Methoden
        function ZeichneQuerschnittPur(obj, Deltaz)
            % Wicklungskörper-Polygone definieren
            WK_Polygon_oben = polyshape(obj.WK_KO_ax - Deltaz, obj.WK_KO_rad);
            WK_Polygon_unten = polyshape(obj.WK_KO_ax - Deltaz, -1 * obj.WK_KO_rad);          
           
            % Figure and Subplot definieren
            fig = figure(1);
            fig.Name = 'ClassDef RotWicklung.m: ZeichneQuerschnitt';
            fig_sp = subplot(1, 1, 1);
            hold(fig_sp, 'on');
            fig_sp.DataAspectRatioMode = 'manual';
            fig_sp.DataAspectRatio = [1 1 1];
           
            % Wicklungskörper zeichnen
            plot(fig_sp, WK_Polygon_oben, 'FaceColor', obj.WK_Fuellung_Farbe, 'FaceAlpha', obj.WK_Fuellung_Transp);
            plot(fig_sp, WK_Polygon_unten, 'FaceColor', obj.WK_Fuellung_Farbe, 'FaceAlpha', obj.WK_Fuellung_Transp);
           
            % Windungen zeichnen
            for i_ax = 0:1:(obj.N_ax - 1)
                for i_rad = 0:1:(obj.N_rad - 1)
                    Cu_oben = [(obj.b_ax + double(i_ax) * obj.d_Cu - Deltaz) (obj.r_i + obj.b_rad + double(i_rad) * obj.d_Cu) (obj.d_Cu) (obj.d_Cu)];
                    Cu_unten = [(obj.b_ax + double(i_ax) * obj.d_Cu - Deltaz) (-1 * (obj.r_i + obj.b_rad) - double(i_rad + 1) * obj.d_Cu) (obj.d_Cu) (obj.d_Cu)];
                    rectangle(fig_sp, 'Position', Cu_oben, 'Curvature', 1, 'FaceColor', [obj.WF_Fuellung_Farbe obj.WF_Fuellung_Transp]);
                    rectangle(fig_sp, 'Position', Cu_unten, 'Curvature', 1, 'FaceColor', [obj.WF_Fuellung_Farbe obj.WF_Fuellung_Transp]);
                end
            end
        end
        function ZeichneQuerschnitt(obj)
            % Wicklungskörper-Polygone definieren
            WK_Polygon_oben = polyshape(obj.WK_KO_ax, obj.WK_KO_rad);
            WK_Polygon_unten = polyshape(obj.WK_KO_ax, -1 * obj.WK_KO_rad);          
           
            % Figure and Subplot definieren
            fig = figure(1);
            fig.Name = 'ClassDef RotWicklung.m: ZeichneQuerschnitt';
            fig_sp = subplot(1, 1, 1);
            hold(fig_sp, 'on');
            fig_sp.DataAspectRatioMode = 'manual';
            fig_sp.DataAspectRatio = [1 1 1];
           
            fig_sp.Title.String = 'Wicklungskoerper';
            fig_sp.Title.Interpreter = obj.Interpreter;
            %fig_sp.Title.Position = [(0.5 * obj.l_ax) (1.2 * fig_sp.YLim(1,2)) 0];
            fig_sp.Title.HorizontalAlignment = 'Center';
            fig_sp.Title.VerticalAlignment = 'Bottom';

            fig_sp.XAxisLocation = 'origin';
            fig_sp.XLabel.String = 'Rotationsachse';
            fig_sp.XLabel.Interpreter = obj.Interpreter;
            fig_sp.XLabel.Position = [(1.1 * obj.l_ax) 0 0];
            fig_sp.XLabel.HorizontalAlignment = 'Left';
            fig_sp.XLabel.VerticalAlignment = 'Middle';
           
            fig_sp.YAxisLocation = 'left';
            fig_sp.YLabel.String = 'Angaben in m';
            fig_sp.YLabel.Interpreter = obj.Interpreter;
           
            % Wicklungskörper zeichnen
            plot(fig_sp, WK_Polygon_oben, 'FaceColor', obj.WK_Fuellung_Farbe, 'FaceAlpha', obj.WK_Fuellung_Transp);
            plot(fig_sp, WK_Polygon_unten, 'FaceColor', obj.WK_Fuellung_Farbe, 'FaceAlpha', obj.WK_Fuellung_Transp);
           
            % Windungen zeichnen
            for i_ax = 0:1:(obj.N_ax - 1)
                for i_rad = 0:1:(obj.N_rad - 1)
                    Cu_oben = [(obj.b_ax + double(i_ax) * obj.d_Cu) (obj.r_i + obj.b_rad + double(i_rad) * obj.d_Cu) (obj.d_Cu) (obj.d_Cu)];
                    Cu_unten = [(obj.b_ax + double(i_ax) * obj.d_Cu) (-1 * (obj.r_i + obj.b_rad) - double(i_rad + 1) * obj.d_Cu) (obj.d_Cu) (obj.d_Cu)];
                    rectangle(fig_sp, 'Position', Cu_oben, 'Curvature', 1, 'FaceColor', [obj.WF_Fuellung_Farbe obj.WF_Fuellung_Transp]);
                    rectangle(fig_sp, 'Position', Cu_unten, 'Curvature', 1, 'FaceColor', [obj.WF_Fuellung_Farbe obj.WF_Fuellung_Transp]);
                end
            end
        end
    end
end


Klasse "RotTopfkern":
Code:
classdef RotTopfkern
    %% Konstanten
    properties (Constant = true, Hidden = true)                
        % Standard-Dicke des inneren axialen Schenkels; [b_ax_i_std] = m
        b_ax_i_std = 3e-3;
       
        % Standardwert des inneren Radius; [r_i_std] = m
        r_i_std = 1e-3;
       
        % Standard-Innenlänge des Topfkerns in axiale Richtung; [l_ax_i_std] = m
        l_ax_i_std = 5e-3;
       
        % Standard-Länge des Wicklungskörpers in radiale Richtung; [l_WK_rad_std] = m
        l_WK_rad_std = 5e-3;
       
        % Standard-Material
        Material_std = 'N96';
       
        % Topfkern-Darstellung
        TK_Fuellung_Farbe = [0.3 0.3 0.3];
        TK_Fuellung_Transp = 1.0;
       
        % Interpreter
        Interpreter = 'tex';
    end
   
    %% Lese-Attribute
    properties (GetAccess = public, SetAccess = protected)
        % Name der Instanz
        Name = '';
    end
   
    %% freie Attribute
    properties (Access = public)
        % innerer Radius des Topfkerns; [r_i] = m
        r_i;
       
        % Dicke des inneren axialen Schenkels; [b_ax_i] = m
        b_ax_i;
       
        % Innenlänge des Topfkerns in axiale Richtung; [l_ax_i] = m
        l_ax_i;
       
        % Höhe des Wicklungskörpers; [h_WK] = m
        l_WK_rad;
       
        % Material
        Material;
    end
   
    %% abhängige Attribute
    properties (Dependent = true)
        % äußerer Radius des inneren axialen Schenkels; [r_i_a] = m
        r_i_a;
       
        % innerer Radius des äußeren axialen Schenkels; [r_a_i] = m
        r_a_i;
       
        % äußerer Radius des Topfkerns; [r_a] = m
        r_a;
       
        % Dicke des äußeren axialen Schenkels; [b_ax_a] = m
        b_ax_a;
       
        % Dicke des radialen Schenkels; [b_rad] = m
        b_rad;
       
        % Länge in axialer Richtung; [l_ax] = m
        l_ax;
       
        % Kreisringfläche der axialen Schenkel; [A_ax] = m^2
        A_ax;
       
        % mittlerer Radius des Magnetflusses im inneren axialen Schenkel; [r_m_i] = m
        r_m_i;
       
        % mittlere magnetische Länge in axiale Richtung; [l_m_ax] = m
        l_m_ax;
    end    

    %% abhängige Attribute (intern)
    properties (Dependent = true, Hidden = false)
        % Topfkern-Koordinaten in axiale Richtung; [TK_KO_ax] = m
        TK_KO_ax;
       
        % Topfkern-Koordinaten in radiale Richtung; [TK_KO_rad] = m
        TK_KO_rad;      
    end
   
    %% Methoden
    methods
        %% Konstruktor
        function obj = RotTopfkern(Name)
            obj.Name = Name;
            obj.r_i = obj.r_i_std;
            obj.b_ax_i = obj.b_ax_i_std;
            obj.l_ax_i = obj.l_ax_i_std;
            obj.l_WK_rad = obj.l_WK_rad_std;
            obj.Material = Ferrit('N96');
        end
       
        %% Set-Methoden
        function obj = set.r_i(obj, r_i)
            if r_i <= 0
                obj.r_i = obj.r_i_std;
            else
                obj.r_i = r_i;
            end
        end
        function obj = set.b_ax_i(obj, b_i)
            if b_i <= 0
                obj.b_ax_i = obj.b_ax_i_std;
            else
                obj.b_ax_i = b_i;
            end
        end
        function obj = set.l_ax_i(obj, l_ax_i)
            if l_ax_i <= 0
                obj.l_ax_i = obj.l_ax_i_std;
            else
                obj.l_ax_i = l_ax_i;
            end
        end
        function obj = set.l_WK_rad(obj, l_WK_rad)
            if l_WK_rad <= 0
                obj.l_WK_rad = obj.l_WK_rad_std;
            else
                obj.l_WK_rad = l_WK_rad;
            end
        end
       
        %% Get-Methoden für Dependent-Attribute
        function r_i_a = get.r_i_a(obj)
            r_i_a = obj.r_i + obj.b_ax_i;
        end
        function r_a_i = get.r_a_i(obj)
            r_a_i = obj.r_i_a + obj.l_WK_rad;
        end
        function r_a = get.r_a(obj)
            r_a = sqrt(obj.r_i_a^2 - obj.r_i^2 + obj.r_a_i^2);
        end
        function b_ax_a = get.b_ax_a(obj)
            b_ax_a = obj.r_a - obj.r_a_i;
        end
        function A_ax = get.A_ax(obj)
            A_ax = pi * (obj.r_i_a^2 - obj.r_i^2);
        end
        function b_rad = get.b_rad(obj)
            b_rad = obj.A_ax / (2 * pi * obj.r_m_i);
        end
        function l_ax = get.l_ax(obj)
            l_ax = obj.l_ax_i + obj.b_rad;
        end
        function r_m_i = get.r_m_i(obj)
            r_m_i = sqrt(0.5 * (obj.r_i_a^2 + obj.r_i^2));
        end
        function l_m_ax = get.l_m_ax(obj)
            l_m_ax = 0.5 * (obj.l_ax_i + obj.l_ax);
        end

        %% Get-Methoden für versteckte Dependent-Attribute
        function TK_KO_ax = get.TK_KO_ax(obj)
            TK_KO_ax = [(0) (obj.l_ax) (obj.l_ax) (obj.l_ax - obj.l_ax_i) (obj.l_ax - obj.l_ax_i) (obj.l_ax) (obj.l_ax) (0)];
        end
        function TK_KO_rad = get.TK_KO_rad(obj)
            TK_KO_rad = [(obj.r_i) (obj.r_i) (obj.r_i_a) (obj.r_i_a) (obj.r_a_i) (obj.r_a_i) (obj.r_a) (obj.r_a)];
        end
        %% Darstellungs-Methoden
        function ZeichneQuerschnittPur(obj, Deltaz, gespiegelt)
            % Topfkern-Polygone definieren          
            if ~gespiegelt
                TK_Polygon_oben = polyshape(obj.TK_KO_ax - Deltaz, obj.TK_KO_rad);
                TK_Polygon_unten = polyshape(obj.TK_KO_ax - Deltaz, -1 * obj.TK_KO_rad);
            else
                TK_Polygon_oben = polyshape(-1 * obj.TK_KO_ax - Deltaz, obj.TK_KO_rad);
                TK_Polygon_unten = polyshape(-1 * obj.TK_KO_ax - Deltaz, -1 * obj.TK_KO_rad);
            end
           
            % Figure and Subplot definieren
            fig = figure(1);
            fig_sp = subplot(1, 1, 1);
            hold(fig_sp, 'on');
            fig_sp.DataAspectRatioMode = 'manual';
            fig_sp.DataAspectRatio = [1 1 1];
           
            % Topfkern zeichnen
            plot(fig_sp, TK_Polygon_oben, 'FaceColor', obj.TK_Fuellung_Farbe, 'FaceAlpha', obj.TK_Fuellung_Transp);
            plot(fig_sp, TK_Polygon_unten, 'FaceColor', obj.TK_Fuellung_Farbe, 'FaceAlpha', obj.TK_Fuellung_Transp);
        end
        function ZeichneQuerschnitt(obj, gespiegelt)
            % Topfkern-Polygone definieren            
            if ~gespiegelt
                TK_Polygon_oben = polyshape(obj.TK_KO_ax, obj.TK_KO_rad);
                TK_Polygon_unten = polyshape(obj.TK_KO_ax, -1 * obj.TK_KO_rad);
            else
                TK_Polygon_oben = polyshape(-1 * obj.TK_KO_ax, obj.TK_KO_rad);
                TK_Polygon_unten = polyshape(-1 * obj.TK_KO_ax, -1 * obj.TK_KO_rad);
            end
           
            % Figure and Subplot definieren
            fig = figure(1);
            fig.Name = 'ClassDef RotTopfkern.m: ZeichneQuerschnitt';
            fig_sp = subplot(1, 1, 1);
            hold(fig_sp, 'on');
            fig_sp.DataAspectRatioMode = 'manual';
            fig_sp.DataAspectRatio = [1 1 1];
           
            fig_sp.Title.String = 'Topfkern';
            fig_sp.Title.Interpreter = obj.Interpreter;
            %fig_sp.Title.Position = [(0.5 * obj.l_ax) (1.2 * fig_sp.YLim(1,2)) 0];
            fig_sp.Title.HorizontalAlignment = 'Center';
            fig_sp.Title.VerticalAlignment = 'Bottom';

            fig_sp.XAxisLocation = 'origin';
            fig_sp.XLabel.String = 'Rotationsachse';
            fig_sp.XLabel.Interpreter = obj.Interpreter;
            if ~gespiegelt
                fig_sp.XLabel.Position = [(1.1 * obj.l_ax) 0 0];
                fig_sp.XLabel.HorizontalAlignment = 'Left';
            else
                fig_sp.XLabel.Position = [(-1.1 * obj.l_ax) 0 0];
                fig_sp.XLabel.HorizontalAlignment = 'Right';
            end            
            fig_sp.XLabel.VerticalAlignment = 'Middle';
           
            if ~gespiegelt
                fig_sp.YAxisLocation = 'Left';
            else
                fig_sp.YAxisLocation = 'Right';
            end
            fig_sp.YLabel.String = 'Angaben in m';
            fig_sp.YLabel.Interpreter = obj.Interpreter;
           
            % Topfkern zeichnen
            plot(fig_sp, TK_Polygon_oben, 'FaceColor', obj.TK_Fuellung_Farbe, 'FaceAlpha', obj.TK_Fuellung_Transp);
            plot(fig_sp, TK_Polygon_unten, 'FaceColor', obj.TK_Fuellung_Farbe, 'FaceAlpha', obj.TK_Fuellung_Transp);            
        end
    end
end


Die Klasse "RotSpule" soll nun jeweils ein Objekt der Klassen "RotWicklung" und "RotTopfkern" besitzen.
Die beiden Objekte besitzen Attribute, deren Wert vom Attributwert der jeweils anderen Klasse abhängig ist.
Beispiel: Der innere Radius des Wickelkörpers ist vom inneren Radius des Topfkerns abhängig.
Wie erreiche ich konsistente Werte bei den Attributen?

Mit den get-Methoden in folgendem Code erzeuge ich eine Endlosschleife:
Code:
% 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


Hinweis 2: Ich bin Elektroingenieur und kein Informatiker. Die Grundlagen der OOP (Attribute, Methoden, Vererbung) kenne ich, aber bei doppelten Pointern oder Begriffen wie "Handles" endet meine Vorstellungskraft schnell. Daher bitte ich ggf. um etwas Nachsicht.

RotSpule.m
 Beschreibung:

Download
 Dateiname:  RotSpule.m
 Dateigröße:  3.84 KB
 Heruntergeladen:  225 mal
RotTopfkern.m
 Beschreibung:

Download
 Dateiname:  RotTopfkern.m
 Dateigröße:  8.43 KB
 Heruntergeladen:  227 mal
Ferrit.m
 Beschreibung:

Download
 Dateiname:  Ferrit.m
 Dateigröße:  1005 Bytes
 Heruntergeladen:  236 mal
RotWicklung.m
 Beschreibung:

Download
 Dateiname:  RotWicklung.m
 Dateigröße:  9.23 KB
 Heruntergeladen:  220 mal
Private Nachricht senden Benutzer-Profile anzeigen


Harald
Forum-Meister

Forum-Meister


Beiträge: 24.425
Anmeldedatum: 26.03.09
Wohnort: Nähe München
Version: ab 2017b
     Beitrag Verfasst am: 28.04.2020, 16:02     Titel:
  Antworten mit Zitat      
Hallo,

ohne mir die Implementierung jetzt im Detail angesehen zu haben:

Zitat:
Die Klasse "RotSpule" soll nun jeweils ein Objekt der Klassen "RotWicklung" und "RotTopfkern" besitzen.

Dann sollte man Aggregation verwenden, d.h. diese Objekte sind selbst properties.

Code:
classdef RotSpule
properties
   rotWicklung % Instanz der Klasse RotWicklung
   rotTopfkern % Instanz der Klasse RotTopfkern
end
end


Zitat:
Die beiden Objekte besitzen Attribute, deren Wert vom Attributwert der jeweils anderen Klasse abhängig ist.
Beispiel: Der innere Radius des Wickelkörpers ist vom inneren Radius des Topfkerns abhängig.

Du verwendest Attribute hier wohl in anderem Kontext als normal in OOP?

Ich würde das im Konstruktor bzw. in der set-Methode dieser neuen Properties regeln. Dann muss ein rotWicklung einen inneren Radius haben, der zum rotTopfkern passt und umgekehrt.

Eine wechselseitige Abhängigkeit ist mit Dependent nicht umsetzbar.

Grüße,
Harald
_________________

1.) Ask MATLAB Documentation
2.) Search gomatlab.de, google.de or MATLAB Answers
3.) Ask Technical Support of MathWorks
4.) Go mad, your problem is unsolvable ;)
Private Nachricht senden Benutzer-Profile anzeigen
 
JackTheRippchen
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 14
Anmeldedatum: 26.09.17
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 28.04.2020, 16:51     Titel:
  Antworten mit Zitat      
Harald hat Folgendes geschrieben:
Ich würde das im Konstruktor bzw. in der set-Methode dieser neuen Properties regeln.

So hatte ich das ursprünglich geschrieben, falls du das so meinst (Auszug):
Code:
       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
            % Aktualisiere Topfkern-Attribute
            obj.TK.r_i = obj.r_Welle + obj.b_Abstandhalter;
           
            % Aktualisiere Wicklungs-Attribute
            obj.W.r_i = obj.TK.r_i_a;
        end


Dann sagt MATLAB:
Zitat:
Code Analyzer has identified a reference to a second property within a set method for a non-Dependent property. If the set method of one property accesses another non-dependent property, initialization of the property can fail because MATLAB does not guarantee the initialization order.


Harald hat Folgendes geschrieben:
Du verwendest Attribute hier wohl in anderem Kontext als normal in OOP?

Ich habe noch nicht soviel Erfahrung in der Anwendung von OOP - wie ist "normal" in diesem Zusammenhang zu verstehen?

Edit/Zusatzfrage:
Wird die set-Methode bereits aufgerufen, wenn ein Attribut im Konstruktor einen Wert zugewiesen bekommt oder nur bei späteren Schreibzugriff auf das Attribut?
Edit 2/Antwort auf Zusatzfrage: Ja, set-Methode wird auch beim Konstruktor-Aufruf ausgeführt.
Private Nachricht senden Benutzer-Profile anzeigen
 
Harald
Forum-Meister

Forum-Meister


Beiträge: 24.425
Anmeldedatum: 26.03.09
Wohnort: Nähe München
Version: ab 2017b
     Beitrag Verfasst am: 28.04.2020, 18:04     Titel:
  Antworten mit Zitat      

_________________

1.) Ask MATLAB Documentation
2.) Search gomatlab.de, google.de or MATLAB Answers
3.) Ask Technical Support of MathWorks
4.) Go mad, your problem is unsolvable ;)
Private Nachricht senden Benutzer-Profile anzeigen
 
JackTheRippchen
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 14
Anmeldedatum: 26.09.17
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 11.05.2020, 14:42     Titel:
  Antworten mit Zitat      
Attribute:
Code:
classdef RotSpule
    %% Lese-Attribute
    properties (GetAccess = public, SetAccess = protected)
        % Name der Instanz
        Name(1,:) char = '';
    end
   
    %% freie Attribute
    properties (Access = public)
        % Objekt/Instanz der Klasse "RotWicklung"
        W(1,1) RotWicklung = RotWicklung('Wicklung in RotSpule');
       
        % Objekt/Instanz der Klasse "RotTopfkern"
        TK(1,1) RotTopfkern = RotTopfkern('Topfkern in RotSpule');
       
        % Radius der Welle
        % [r_Welle] = m
        r_Welle(1,1) double {mustBeNonnegative} = 2e-3;
       
        % Dicke des nichtferromagnetischen Abstandhalters zwischen Welle und Topfkernen
        % [b_Abtandhalter] = m
        b_Abstandhalter(1,1) double {mustBeNonnegative} = 1e-3;
       
        % Länge (gesamt) beider Luftspalte in axialer Richtung
        % [l_Luft_ax] = m
        l_Luft_ax(1,1) double {mustBeNonnegative} = 1e-3;                    
    end


Konstruktor:
Code:
       %% Konstruktor
        function obj = RotSpule(Name)
            switch nargin
                case 1
                    obj.Name = Name;
                otherwise
                    obj.Name = 'RotSpule';
            end
           
            obj.AktualisiereAttrRad;
            obj.AktualisiereAttrAx;
        end


Methoden:
Code:
       function AktualisiereAttrRad(obj)
            obj.TK.r_i = obj.r_Welle + obj.b_Abstandhalter;          
            obj.W.r_i = obj.TK.r_i_a;
            obj.TK.l_W_rad = obj.W.l_rad;
        end
        function AktualisiereAttrAx(obj)
            obj.TK.l_ax_i = 0.5 * obj.W.l_ax - 0.25 * obj.l_Luft_ax;
        end


Wenn ich innerhalb der Methode "AktualisiereAttrRad" per disp-Befehl die Attributwerte von W und TK anzeigen lasse, sind sie richtig.
Nach Ausführen der Methode, also quasi "außerhalb", sind dann auf einmal wieder die Standardwerte vorhanden.
Private Nachricht senden Benutzer-Profile anzeigen
 
Harald
Forum-Meister

Forum-Meister


Beiträge: 24.425
Anmeldedatum: 26.03.09
Wohnort: Nähe München
Version: ab 2017b
     Beitrag Verfasst am: 11.05.2020, 15:07     Titel:
  Antworten mit Zitat      
Hallo,

zunächst mal noch den zerschossenen Beitrag:
Zitat:
Ich habe noch nicht soviel Erfahrung in der Anwendung von OOP - wie ist "normal" in diesem Zusammenhang zu verstehen?

dependent ist z.B. ein attribute. Siehe hier:
https://www.mathworks.com/help/matl...../property-attributes.html

Eine Alternative zur set-Methode kann sein, bei der Eigenschaft Access = private zu setzen und für den Zugriff von außen eine Methode update_r_Welle zu schreiben, die quasi denselben Inhalt hat.

Zur momentanen Frage: ein Problem dürfte sein, dass du obj nicht zurückgibst.
obj = ... (sowohl in der Deklaration als auch im Aufruf)

Grüße,
Harald
_________________

1.) Ask MATLAB Documentation
2.) Search gomatlab.de, google.de or MATLAB Answers
3.) Ask Technical Support of MathWorks
4.) Go mad, your problem is unsolvable ;)
Private Nachricht senden Benutzer-Profile anzeigen
 
JackTheRippchen
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 14
Anmeldedatum: 26.09.17
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 11.05.2020, 15:20     Titel: Heureka!
  Antworten mit Zitat      
Harald hat Folgendes geschrieben:
Zur momentanen Frage: ein Problem dürfte sein, dass du obj nicht zurückgibst.
obj = ... (sowohl in der Deklaration als auch im Aufruf)

Das ist die Lösung - VIELEN DANK!

Ich dachte die Notation "obj.[...]" sei so etwas wie ein Pointer, und dass der Wert dann gleich im zugehörigen Speicherbereich überschrieben wird.
Private Nachricht senden Benutzer-Profile anzeigen
 
Harald
Forum-Meister

Forum-Meister


Beiträge: 24.425
Anmeldedatum: 26.03.09
Wohnort: Nähe München
Version: ab 2017b
     Beitrag Verfasst am: 11.05.2020, 15:54     Titel:
  Antworten mit Zitat      
Hallo,

das ist nur der Fall, wenn du von handle vererbst.
Solange du das nicht machst, immer obj = bei Deklaration oder Aufruf von Methoden, die das Objekt verändern.

Grüße,
Harald
_________________

1.) Ask MATLAB Documentation
2.) Search gomatlab.de, google.de or MATLAB Answers
3.) Ask Technical Support of MathWorks
4.) Go mad, your problem is unsolvable ;)
Private Nachricht senden Benutzer-Profile anzeigen
 
Neues Thema eröffnen Neue Antwort erstellen



Einstellungen und Berechtigungen
Beiträge der letzten Zeit anzeigen:

Du kannst Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
Du kannst Dateien in diesem Forum posten
Du kannst Dateien in diesem Forum herunterladen
.





 Impressum  | Nutzungsbedingungen  | Datenschutz | FAQ | goMatlab RSS Button RSS

Hosted by:


Copyright © 2007 - 2024 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks

MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.