Merge branch 'Pu_feature_separateBearingAndFitting' into 'master'

Pu_feature_separateBearingAndFitting#3

## Resolves issue #3 
- Tabellen Bearing.xlsx und Lubricants.xlsx werden in Tabelle InputData.xlsx vereint
- InputData.xlsx enthält zusätzlich Tabellenblätter für die Passungen zur Welle und dem Gehäuse sowie Lagerdaten und Normenwerte zu den Passungen
- Materialwerte werden nun in Structs gespeichert, z.B. L.ring.nu
- Zwei unterschiedliche Materialien für Wälzkörper werden unterstützt
- restlicher Code wurde an die Änderungen angepasst.

See merge request pmd_smartbearings/bearimp!6

@BearImp/BearImp.m

@@ -35,6 +35,8 @@ classdef BearImp < handle & matlab.mixin.Copyable
     properties (Access = public)
         % gibt an, ob die Werte vorhanden und aktuell sind
         up2date = struct('L',false,'S',false,'T',false,'R',false,'G',false,'B',false,'H',false,'Z',false)
+        materials
+        inputDataTableFile = 'InputData.xlsx';
     end
     
     properties (Dependent, SetAccess = immutable, GetAccess = public)
@@ -76,6 +78,7 @@ classdef BearImp < handle & matlab.mixin.Copyable
     end
     methods (Access = public)
         setBearing(obj,name)
+        setFitting(obj,shaft,housing)
         setLube   (obj,name)
         calculate (obj)
         calculateContinuous(obj,n)
@@ -241,6 +244,18 @@ classdef BearImp < handle & matlab.mixin.Copyable
                          obj.up2date.L       &&...
                          obj.up2date.S;
         end
+        function materials = get.materials(obj)
+            if ~isstruct(obj.materials)
+                materialTable = readtable(obj.inputDataTableFile,'Sheet','Materials');
+                materialTable = removevars(materialTable,'possible_el_behaviours');
+                for ii = 1:height(materialTable)
+                    materials.(materialTable(ii,:).Material{:}) = table2struct(materialTable(ii,:));
+                end
+                obj.materials = materials;
+            else
+                materials = obj.materials;
+            end
+        end
     end
     
     methods (Access = protected)

@BearImp/calcClear.m

@@ -46,20 +46,20 @@ R.DeltaP_G = R.DeltaD_ue + R.Gprime - R.DeltaD_F + R.DeltaD_T + R.DeltaD_W + R.D
 R.ue_W = R.ue_d - R.DeltaP_W;
 R.ue_G = R.ue_D - R.DeltaP_G;
 if R.ue_W > 0 % Überprüfe, ob Spiel oder Übermaß vorliegt
-    R.sigma_rir = R.ue_W./L.d .* 1./(((1+(L.d./L.d_f).^2)./(1-(L.d./L.d_f).^2)+1./L.nu_ir)./L.E_ir + ...
-                                     ((1+(L.d_i./L.d).^2)./(1-(L.d_i./L.d).^2)-1./L.nu_W )./L.E_W);
+    R.sigma_rir = R.ue_W./L.d .* 1./(((1+(L.d./L.d_f).^2)./(1-(L.d./L.d_f).^2)+1./L.ring .nu)./L.ring .E + ...
+                                     ((1+(L.d_i./L.d).^2)./(1-(L.d_i./L.d).^2)-1./L.shaft.nu)./L.shaft.E);
 else
     R.sigma_rir = 0;
 end
 if R.ue_G > 0
-    R.sigma_rar = R.ue_G./L.D .* 1./(((1+(L.D_f./L.D).^2)./(1-(L.D_f./L.D).^2)-1./L.nu_ar)./L.E_ar + ...
-                                     ((1+(L.D./L.D_G).^2)./(1-(L.D./L.D_G).^2)+1./L.nu_G)./L.E_G);
+    R.sigma_rar = R.ue_G./L.D .* 1./(((1+(L.D_f./L.D).^2)./(1-(L.D_f./L.D).^2)-1./L.ring   .nu)./L.ring   .E + ...
+                                     ((1+(L.D./L.D_G).^2)./(1-(L.D./L.D_G).^2)+1./L.housing.nu)./L.housing.E);
 else
     R.sigma_rar = 0;
 end
-R.e_ir = 2000 .* L.d./L.E_ir .* (L.d./L.d_f)./(1-(L.d./L.d_f).^2) .* R.sigma_rir .* 1e-3;
-R.e_ar = 2000 .* L.D./L.E_ar .* (L.D_f./L.D)./(1-(L.D_f./L.D).^2) .* R.sigma_rar .* 1e-3;
-R.e_t = L.alpha_t .* L.d_m .* 5; % aktuell mit fix Detla_t = 5 implementiert
+R.e_ir = 2000 .* L.d./L.ring.E .* (L.d./L.d_f)./(1-(L.d./L.d_f).^2) .* R.sigma_rir .* 1e-3;
+R.e_ar = 2000 .* L.D./L.ring.E .* (L.D_f./L.D)./(1-(L.D_f./L.D).^2) .* R.sigma_rar .* 1e-3;
+R.e_t = L.ring.alpha_t .* L.d_m .* 5; % aktuell mit fix Detla_t = 5 implementiert
 R.P_d = L.c - R.e_ir + R.e_ar - R.e_t + 0; % aktuelle mit fix e_L = 0 implementiert
 
 %% Attribute ändern

@BearImp/calcFilm.m

@@ -22,8 +22,8 @@ L = obj.L; S = obj.S; T = obj.T; G = obj.G; B = obj.B; T_Oil = obj.T_Oil; n = ob
 H = struct;
 
 %% Berechnung
-H.b(1,:) = (6*G.fraktE_i.*B.Q.*G.R_si  ./  (pi*G.k_i.*G.E_redi)).^(1/3);
-H.b(2,:) = (6*G.fraktE_a.*B.Q.*G.R_sa  ./  (pi*G.k_a.*G.E_reda)).^(1/3);
+H.b(1,:) = (6*G.fraktE_i.*B.Q.*G.R_si  ./  (pi*G.k_i.*G.E_red)).^(1/3);
+H.b(2,:) = (6*G.fraktE_a.*B.Q.*G.R_sa  ./  (pi*G.k_a.*G.E_red)).^(1/3);
 H.a = bsxfun(@times,[G.k_i;G.k_a],H.b);
 H.A = pi*H.a.*H.b;
 H.p = bsxfun(@rdivide,B.Q,H.A);

@BearImp/calcGeo.m

@@ -20,9 +20,7 @@ L = obj.L; R = obj.R; F_a = obj.F_a;
 G = struct;
 
 %% Berechnung
-G.E_redi = 2  ./  ((1-L.nu_wk.^2)./L.E_wk + (1-L.nu_ir.^2)/L.E_ir);
-G.E_reda = 2  ./  ((1-L.nu_wk.^2)./L.E_wk + (1-L.nu_ar.^2)/L.E_ar);
-G.E_red = [G.E_redi;G.E_reda];
+G.E_red = 2  ./  ((1-L.RE_A.nu.^2)./L.RE_A.E + (1-L.ring.nu.^2)/L.ring.E);
 G.B_m = L.f_a + L.f_i - 1;
 if F_a
     if R.P_d > 0

@BearImp/setBearing.m

 function setBearing(obj,name)
 %setBearing       -> öffnet ein Auswahlmenü, um ein Lager auszuwählen
 %setBearing(name) -> lädt das angegebene Lager
-%Voraussetzung: 'Lager.xlsx' im Suchpfad
 
 %    pmd Berechnungstool Lagerimpedanz
 %    Version: 1.0.0
-%    Stand: 12.05.2021
+%    Stand: 17.06.2021
 %    Autor: Steffen Puchtler
 
     arguments
         obj
         name char = ''
     end
-    bearingTable = readtable('Bearings.xlsx');
+    if numel(obj) > 1
+        for ii = 1:numel(obj) % TODO: not working with matrices
+            obj(ii).setBearing(name);
+        end
+        return
+    end
+    bearingTable = readtable(obj.inputDataTableFile,'Sheet','Bearings');
     if isempty(name)    % kein Lager gegeben
         [selection, ok] = listdlg('ListString',bearingTable.Labelling,'SelectionMode','Single','Name','Lagerauswahl','PromptString','Wählen Sie ein Lager: ');
         if ~ok, return, end
@@ -25,5 +30,73 @@ function setBearing(obj,name)
             L = table2struct(bearingTable(index,:));
         end
     end
+    
+    L = cutTrailingNumbers(L);
+    
+    for diameterString = 'dD'
+        L = setTolerances(L, diameterString);
+    end
+    
+    % materials
+    L.ring = obj.materials.(L.material_ring);
+    L.RE_A = obj.materials.(L.material_RE_A);
+    if isempty(L.material_RE_B)
+        L = rmfield(L,{'RE_order'});
+    else
+        L.RE_B = obj.materials.(L.material_RE_B);
+    end
+    L = rmfield(L,{'material_RE_A','material_RE_B','material_ring'});
+
+    L.d_m = (L.d + L.D)/2;
+
+    L = orderfields(L);
     obj.set('L',L)
+    obj.setFitting('drawing')
+end
+
+function L = setTolerances(L, diameterString)
+    
+    tolerance = str2double(L.(['fitting_' diameterString]));
+    if isnan(tolerance)
+        [lower, upper] = getTolerance(L,diameterString);
+    else
+        lower = tolerance;
+        upper = tolerance;
+    end
+    switch diameterString
+        case 'd'
+            L.EI_d = lower;
+            L.ES_d = upper;
+        case 'D'
+            L.ei_D = lower;
+            L.es_D = upper;
+    end
+end
+
+function [lower, upper] = getTolerance(L,diameterString)
+    switch diameterString
+        case 'd'
+            sheetName = 'DIN 620-2 inner';
+        case 'D'
+            sheetName = 'DIN 620-2 outer';
+    end
+    toleranceData = readtable('InputData.xlsx','Sheet',sheetName);
+    toleranceClass = L.(['fitting_' diameterString]);
+    
+    diameter = L.(diameterString);
+    index = find(toleranceData.([diameterString '_above']) >= diameter,1) - 1;
+    
+    lower = toleranceData(index,:).([toleranceClass '_lower']);
+    upper = toleranceData(index,:).([toleranceClass '_upper']);
+end
+
+function strct = cutTrailingNumbers(strct)
+    fields = fieldnames(strct);
+    for ii = 1:numel(fields)
+        fieldname = fields{ii};
+        if double(fieldname(end)) <= 57 % 9
+            strct.(fieldname(1:end-1)) = strct.(fieldname);
+            strct = rmfield(strct,fieldname);
+        end
+    end
 end

@BearImp/setFitting.m

+function setFitting(obj,shaft,housing)
+%setFitting                -> öffnet Auswahlmenüs, um Welle und Gehäuse auszuwählen
+%setFitting('drawing')     -> lädt die in der Zeichnung angegebenen Werte
+%setFitting(shaft,housing) -> lädt die angegebene Welle & Gehäuse
+
+%    pmd Berechnungstool Lagerimpedanz
+%    Version: 1.0.0
+%    Stand: 17.06.2021
+%    Autor: Steffen Puchtler
+
+    arguments
+        obj
+        shaft char = ''
+        housing char = ''
+    end
+    if numel(obj) > 1
+        for ii = 1:numel(obj) % TODO: not working with matrices
+            obj(ii).setFitting(shaft,housing);
+        end
+        return
+    end
+    if nargin == 2 && strcmp(shaft,'drawing')
+        housing = 'drawing';
+    end
+    
+    fittingTable = readtable(obj.inputDataTableFile,'Sheet','Fittings');
+    if isempty(shaft)    % keine Welle gegeben
+        [index, ok] = listdlg('ListString',fittingTable.Shaft,'SelectionMode','Single','Name','Auswahl Welle','PromptString','Wählen Sie eine Welle: ');
+        if ~ok, return, end
+        setShaftTolerances(obj,fittingTable,index)
+    else                 % Welle gegeben
+        if strcmp(shaft,'drawing')
+            shaft = [num2str(obj.L.d*1e3) ' drawing'];
+        end
+        index = strcmp(shaft,fittingTable.Shaft);
+        if ~any(index)
+            error('Wellenbezeichnung nicht gefunden')
+        else
+            setShaftTolerances(obj,fittingTable,index)
+        end
+    end
+    assert(fittingTable(index,:).d == obj.L.d,'Welle passt nicht zum Lager')
+    obj.L.shaft   = obj.materials.(fittingTable(index,:).material_shaft{:});
+                                                    % TODO: Redundanz beseitigen ########
+    if isempty(housing)    % kein Gehäuse gegeben
+        [index, ok] = listdlg('ListString',fittingTable.Housing,'SelectionMode','Single','Name','Auswahl Gehäuse','PromptString','Wählen Sie ein Gehäuse: ');
+        if ~ok, return, end
+        setHousingTolerances(obj,fittingTable,index)
+    else                   % Welle gegeben
+        if strcmp(housing,'drawing')
+            housing = [num2str(obj.L.D*1e3) ' drawing'];
+        end
+        index = strcmp(housing,fittingTable.Housing);
+        if ~any(index)
+            error('Gehäusebezeichnung nicht gefunden')
+        else
+            setHousingTolerances(obj,fittingTable,index)
+        end
+    end
+    assert(fittingTable(index,:).D == obj.L.D,'Gehäuse passt nicht zum Lager')
+    obj.L.housing = obj.materials.(fittingTable(index,:).material_housing{:});
+    obj.L = orderfields(obj.L);
+end
+
+function setShaftTolerances(obj,fittingTable,index)
+    obj.L.ei_d = fittingTable(index,:).Delta_lower_shaft;
+    obj.L.es_d = fittingTable(index,:).Delta_upper_shaft;
+    obj.L.d_i  = fittingTable(index,:).d_i;
+end
+
+function setHousingTolerances(obj,fittingTable,index)
+    obj.L.EI_D = fittingTable(index,:).Delta_lower_housing;
+    obj.L.ES_D = fittingTable(index,:).Delta_lower_housing;
+    obj.L.D_G  = fittingTable(index,:).D_G;
+end
+    
\ No newline at end of file

@BearImp/setLube.m

 function setLube(obj,name)
 %setLube       -> öffnet ein Auswahlmenü, um einen Schmierstoff auszuwählen
 %setLube(name) -> lädt den angegebenen Schmierstoff
-%Voraussetzung: 'Schmierstoffe.xlsx' im Suchpfad
 
 %    pmd Berechnungstool Lagerimpedanz
 %    Version: 1.0.0
-%    Stand: 12.05.2021
+%    Stand: 16.06.2021
 %    Autor: Steffen Puchtler
 
     arguments
         obj
         name char = ''
     end
-    lubeTable = readtable('Lubricants.xlsx');
+    
+    if numel(obj) > 1
+        for ii = 1:numel(obj) % TODO: not working with matrices
+            obj(ii).setLube(name);
+        end
+        return
+    end
+    
+    lubeTable = readtable(obj.inputDataTableFile,'Sheet','Lubricants');
     if isempty(name)    % kein Schmierstoff gegeben
         [selection, ok] = listdlg('ListString',lubeTable.Labelling,'SelectionMode','Single','Name','Schmierstoffauswahl','PromptString','Wählen Sie einen Schmierstoff: ');
         if ~ok, return, end
@@ -25,5 +32,5 @@ function setLube(obj,name)
             S = table2struct(lubeTable(index,:));
         end
     end
-    obj.set('S',S);
+    obj.S = S;
 end
\ No newline at end of file