function []=KraftMoment_test(Eingabe)
% 
% Funktion KraftMoment
% 
% Aufruf: []=KraftMoment()
% 
% 
% 

r=Eingabe.r;
l=Eingabe.l;
D=Eingabe.D;
n=Eingabe.n;
epsilon_verd=Eingabe.epsilon_verd;
alphav_B1=Eingabe.alphav_B1;
delta_alphav_D1=Eingabe.delta_alphav_D1;
Hu=Eingabe.Hu;
Brennstoffver=Eingabe.Brennstoffver;
m1=Eingabe.m1;
m2=Eingabe.m2;
alphav_B2=Eingabe.alphav_B2;
delta_alphav_D2=Eingabe.delta_alphav_D2;
pA=Eingabe.pA;
R=Eingabe.R;
TA=Eingabe.TA;
pLad=Eingabe.pLad;
TLL=Eingabe.TLL;
lambda_a=Eingabe.lambda_a;
dichte_b=Eingabe.dichte_b;
VB=Eingabe.VB;
alpha_open=Eingabe.alpha_open;
alpha_o=Eingabe.alpha_o;
luftsaugend=Eingabe.luftsaugend;
Einlassdrall=Eingabe.Einlassdrall;
C2=Eingabe.C2;
T_alpha_0=Eingabe.T_alpha_0;
Tw=Eingabe.Tw;
K1=Eingabe.K1;
K2=Eingabe.K2;
K3=Eingabe.K3;
Oberflaeche_bei_OT=Eingabe.Oberflaeche_bei_OT;
pKG=Eingabe.pKG;
mo=Eingabe.mo;
epsilon_g=Eingabe.epsilon_g;
Beta1=Eingabe.Beta1;
a=Eingabe.a;
b=Eingabe.b;
mr=Eingabe.mr;
z=Eingabe.z;
Reihenmotor=Eingabe.Reihenmotor;
Boxermotor=Eingabe.Boxermotor;
V_Motor=Eingabe.V_Motor;

gamma_A=Eingabe.gamma_A;
gamma_B=Eingabe.gamma_B;


diagrammf=2;
auswahlf=0;

QBges=VB*dichte_b*Hu;


Schalt_T=1;

% Winkel zum Berechnen von Betapl beim V-Motor
gamma_A1=gamma_A;
gamma_B1=gamma_B;

% halbe V-Winkel in Rad
gamma_A=gamma_A/360*2*pi;
gamma_B=gamma_B/360*2*pi;

% Abstände in m
a=a/100;
b=b/100;



% Hub s in mm 
s=2*r; 

% Durchmesser D in cm umrechnen
D=D/10;

% Kolbenfläche Ak in cm^2 
Ak=(pi*(D^2))/4;

cm=(2*s)/1000*(n/60);

% Hubvolumen Vh in cm^3 
Vh=(s/10)*Ak;
% Verdichunngsraum V0 in cm^3
V0=Vh/(epsilon_verd-1);

% Kurbelwinkel in Rad wird für die Berechnungen benötigt
alpha=(0:pi/180:4*pi);  

% Kurbelwinkel in Grad wird für die grafischen Darstellung benötigt


% Pleulverhältnis
lambdap=r/l;

% Kolbenweg in mm
Weg=r*((1-cos(alpha))+lambdap/4*(1-cos(2*alpha)));

% exaktes Volumen in cm^3
V_ex=V0+Ak.*(Weg/10);

% Volumen in m^3
V=V_ex/1000000;

N=length(alpha);

% Volumen deltaV bestimmen
delta_V=(0:pi/180:4*pi);
delta_V(1)=V(1)-V(720);

for k=2:N
    delta_V(k)=V(k)-V(k-1);
end;


% Volumen V' bestimmen
V_strich=(0:pi/180:4*pi);
V_strich(1)=(V(1)+V(720))/2;

for k=2:N
    V_strich(k)=(V(k)+V(k-1))/2;
end;


% alpha in Grad
alpha=(0:1:720);
N=length(alpha);


ber=alphav_B1+delta_alphav_D1;

% Brennverlauf delta_Q_B1 bestimmen
% alpha in Grad!
delta_Q_B1=(0:pi/180:4*pi);

for k=1:N
    if ber>=alpha(k)
        if alphav_B1<alpha(k)
            delta_Q_B1(k)=1/delta_alphav_D1*QBges*Brennstoffver*...
            6.908*(m1+1)*((alpha(k)-alphav_B1)/delta_alphav_D1)^m1.*...
            exp(-6.908*((alpha(k)-alphav_B1)/delta_alphav_D1).^(m1+1));
        else
          delta_Q_B1(k)=0;
        end;
    else
        delta_Q_B1(k)=0;
    end;
    
end;
       
% Brennverlauf delta_Q_B2 bestimmen
% alpha in Grad!

delta_Q_B2=(0:pi/180:4*pi);

c=alphav_B2+delta_alphav_D2;
for k=1:N
    if c>=alpha(k)
        if alphav_B2<alpha(k)
            delta_Q_B2(k)=1/delta_alphav_D2*QBges*(1-Brennstoffver)*...
            6.908*(m2+1)*((alpha(k)-alphav_B2)/delta_alphav_D2)^m2.*...
            exp(-6.908*((alpha(k)-alphav_B2)/delta_alphav_D2).^(m2+1));
        else
          delta_Q_B2(k)=0;
        end;
    else
        delta_Q_B2(k)=0;
    end;
    
end;


% Summenbrennverlauf aus delta_Q_B1 geteilt durch QBges
Summe_delta_Q_B1_durch_QBges=cumsum(delta_Q_B1)/QBges;



% Summenbrennverlauf aus delta_Q_B2 geteilt durch QBges bestimmen
Summe_delta_Q_B2_durch_QBges=cumsum(delta_Q_B2)/QBges;

% Brennverlauf delta_Q_B1+delta_Q_B2 bestimmen
delta_QB1_plus_delta_Q_B2=(0:pi/180:4*pi);

for k=1:N
    delta_QB1_plus_delta_Q_B2(k)=delta_Q_B1(k)+delta_Q_B2(k);
end;

% Summenbrennverauf aus Summe (delta_QB1)/Qges+(delta_QB2)/Qges
 Erg= Summe_delta_Q_B1_durch_QBges + Summe_delta_Q_B2_durch_QBges;

        
% Wärmeübergangskoeffizient alpha bestimmen
 



% Kurbelwellenwinkel alpha in Rad
alpha_rad=(0:pi/180:4*pi); 

% Pleulverhältnis
lambdap=r/l;

% Kolbenweg
Weg=r*((1-cos(alpha_rad))+lambdap/4*(1-cos(2*alpha_rad)));

% Brennraumoberfläche A in cm^2
A= Oberflaeche_bei_OT+(Weg/10).*(D*pi);



% dQw/dt bestimmen


omega=(2*pi*n)/60;



% -------------------------------
alpha=(0:1:720);
N=length(alpha);
dQw_dt=(0:pi/180:4*pi);
delta_Qw=(0:pi/180:4*pi);



pk=(0:pi/180:4*pi);
for k=1:N
    pk(k)=0.95;
end 

pk1=pk;
pk2=pk1;



% Größen vorinitialisieren

TN=(0:pi/180:4*pi);

for k=1:N
    TN(k)=500;
end 


cv=(0:pi/180:4*pi);
cvg=(0:pi/180:4*pi);
alpha_Temp=(0:pi/180:4*pi);




pkg=(0:pi/180:4*pi);
for k=1:N
    pkg(k)=0.95;
end 


pk1g=pkg;
pk2g=pk1g;

pmf=(0:pi/180:4*pi);


delta_pg=(0:pi/180:4*pi);
pm_geschl=(0:pi/180:4*pi);
Tg=(0:pi/180:4*pi);
delta_p=(0:pi/180:4*pi);
for k=1:N
    Tg(k)=500;
end 

w=(0:pi/180:4*pi);
C1=(0:pi/180:4*pi);



% Restgasmasse in kg
mRG=(pA*100000*V0/1000000)/(R*TA);


% Frischladungsmasse in kg
mL=(pLad*100000*Vh/1000000)/(R*TLL)*lambda_a;

% Brennstoffmasse in kg
mB=dichte_b*VB*(1/1000000);

alpha_or=(2*pi)/360*alpha_o;

% Vol. Verdichtungsbeginn
V_alpha_0=(V0/1000000)+(Ak/10000)*(r/1000*(1-cos(alpha_or))+l/1000*(1-sqrt(1-lambdap^2*(sin(alpha_or))*sin(alpha_or))));

% Druck bei Verdichtungsbeginn
p_alpha_0=((mRG+mL)*R*T_alpha_0)/(V_alpha_0*100000);

pk(1)=p_alpha_0;
pk1(1)=pA;
pk2(1)=pA;

pkg(1)=p_alpha_0;
pk1g(1)=pA;
pk2g(1)=pA;




for k=1:N
    
%Mitteldruck beim Motor gefeuert und gschleppt
       pmf(k)=pk1(k)+(pk1(k)-pk2(k))/2;
       pm_geschl(k)=pk1g(k)+(pk1g(k)-pk2g(k))/2;
        
   
% Temperatur beim gefeurten Motor TN und beim geschleppten Motor Tg
% berechnen
    if alpha_open>=alpha(k)
         if alpha(k)>alpha_o
            Tg(k)=(pm_geschl(k)*100000*V_strich(k))/((mRG+mL)*R);
             if luftsaugend==1
                 TN(k)=(pmf(k)*100000*V_strich(k))/((mRG+mL+mB*Erg(k))*R);
             else
                 TN(k)=(pmf(k)*100000*V_strich(k))/((mRG+mL)*R);
             end
         else
             TN(k)=TLL;
             Tg(k)=TLL;
         end
     else
         TN(k)=TA;
         Tg(k)=TA;
     end;
     
    if alpha_open>=alpha(k)
        if alpha(k)>alpha_o
            C1(k)=2.28+0.308*Einlassdrall;
        else
            C1(k)=6.18+0.417*Einlassdrall;
        end
    else
        C1(k)=6.18+0.417*Einlassdrall;
    end
     
    w(k)=C1(k)*cm+C2*((Vh/1000000*T_alpha_0)/(p_alpha_0*V_alpha_0))*...
        (pmf(k)-pm_geschl(k));

% Wärmeübergangszahl alpha berechnen 
alpha_Temp(k)=127.93*(D/100)^-0.2*(abs(pmf(k)))^0.8*(w(k))^0.8*(TN(k))^-0.53;


     
    

% dQw/dt berechnen
dQw_dt(k)=alpha_Temp(k)*(A(k)/10000).*(TN(k)-Tw);

% delta_Qw berechnen
delta_Qw(k)=(dQw_dt(k)*(pi/180))/omega;

% Wärmekapazität cv bei Motor gefeuer und Motor geschleppt     
     if Schalt_T==1
        cv(k)=K1+K2*(TN(k)-273)-K3*(TN(k)-273)^2;
        cvg(k)=K1+K2*(Tg(k)-273)-K3*(TN(k)-273)^2;
    else
        cv(k)=0;
        cvg(k)=0;
     end
     

      if alpha_open>=alpha(k)
        if alpha(k)>alpha_o
            delta_pg(k)=(-(1+R/cv(k))*pm_geschl(k)*delta_V(k)+(R/cv(k)*(0-0))/100000)*(1/V_strich(k));
            if luftsaugend==1
                
                delta_p(k)=(-(1+R/cv(k))*pmf(k)*delta_V(k)+...
                ((R/cv(k))*(delta_QB1_plus_delta_Q_B2(k)-delta_Qw(k)))/100000)*(1/V_strich(k))...
                +((R*TN(k)*mB*(delta_QB1_plus_delta_Q_B2(k)/QBges))/100000)*(1/V_strich(k));
            else 
                delta_p(k)=(-(1+R/cv(k))*pmf(k)*delta_V(k)+...
                ((R/cv(k))*(delta_QB1_plus_delta_Q_B2(k)-delta_Qw(k)))/100000)*(1/V_strich(k));
            end
        else
            delta_p(k)=0;
            delta_pg(k)=0;
        end
    else
        delta_p(k)=0;
        delta_pg(k)=0;
      end
    
    
      
    if alpha_open>=alpha(k)
        if alpha(k)>alpha_o
            pk(k)=pk1(k)+delta_p(k);
            pkg(k)=pk1g(k)+delta_pg(k);
        else
            pk(k)=p_alpha_0;
            pkg(k)=p_alpha_0;
            
        end 
    else
        pk(k)=pA;
        pkg(k)=pA;
    end
    
        pk1(k+1)=pk(k);
        pk2(k+1)=pk1(k);
        pk1g(k+1)=pkg(k);
        pk2g(k+1)=pk1g(k);
    
      
    

end




alpha=(0:pi/180:4*pi);




Beta=Beta1*2*pi/360;

% ---------------------------------------------------------------------
% ---------------------------------------------------------------------

% Reihenmotor-------------------------------------------
% Berechnung der freien Massenkräfte  und freien Massenmomente beim
% Reihenmotor, Boxermotor und V-Motor
% Hier werden oszillierende und rotierende freie Massenkräft ermittelt

% Es wird ein Bezugskoordinatensystem verwendet. Dort ist die y-Achse und
% z-Achse relevant. Die z-Achse entspricht der Kolbenbewegungsrichtung
% (beim Reihenmotor). Die y-Achse ist senkrecht zur z-Achse und verläuft in
% Zählrichtung (beim Reihenmotor). Der Urspurung des Koordinatensystems
% liegt im Schwerpunkt S (siehe unten)

% Das Koordinatensystem ist für alle drei Motorbauarten gleich:
% Reihenmotor,Boxermotor, V-Motor
                            

% Matrizen für die beiden osziellierende Kräfte Fo1 und Fo2 erzeugen
% Die oszillierenden Kräfte sind Kräfte die senkrecht zum Kolben wirken
% Die Anzahl der Spalten n entspricht der Anzahl der Zylinder. 

Fo1 = zeros(z, N); 
Fo2= zeros(z,N);
Fo1_x=Fo1;
Fo2_x=Fo2;

% -------------------------------------------------------------
% Freie Massenkräfte und freie Massenmomente beim Reihenmotor
% Beim Reihenmotor wirken die oszillierende Kärfte der ersten und zweiten
% Ordnung Fo1 und Fo2 senkrecht zum Kolben.Sie werden durch oszillierende
% Massen erzeugt. Dann gibt es noch rotierende Massenkräfte Frot,die durch
% rotierende Massen erzeugt werden.


% Matrizen für die beiden osziellierende Kräfte Fo1 und Fo2 erzeugen
% Die oszillierenden Kräfte sind Kräfte die senkrecht zum Kolben wirken
% Die Anzahl der Spalten n entspricht der Anzahl der Zylinder. 


% Wenn man die freien Massenkräfte und freien Massenmomente für einen
% Reihenmotor berechnen will, dann wird Reihenmotor==1 gesetzt.

if Reihenmotor==1

    
% Der Schwerpunkt ist der Mittelpunkt der Kurbelwelle. Dort ist der 
% Nullpunkt bzw der Bezugspunkt S.  
S=(a*(z-1))/2;


% Abstand des ersten Zylinders
abstand(1)=-S;

% Hier wird ermittelt, ob die Zylinderanzahl gerade oder ungerade ist
w=(z-1)/2;

% round(w)==w gibt eine 1 oder eine Null zurück. Wenn eine 1 dann gerade
% Anzahl an Zylindern, wenn 0 dann ungerade Anzahl Zylindern

% Abstände bestimmen
if round(w)==w
    for k=2:z
 
        abstand(k)=abstand(k-1)+a;  
    end

else
    for k=2:z
        abstand(k)=abstand(k-1)+a;
    
        if abstand(k)>=0
            abstand(k)=-abstand(k-1);
            abstand(k)=abstand(k-1)+a;
        end
    
    end
end
        

% Hier werden die ozillierende Kräfte 1 und 2 Ordnung ermittelt

for k=1:z 
    for c=1:N 
        % oszillierende Kräfte in z-Richtung    
        Fo1(k,c)=mo*r/1000*omega^2*cos(alpha(c)+Beta(k)); 
        Fo2(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+Beta(k)));
    end 
end 



% freie Massenmomente bestimmen
% Hier wird in y und z Richtung unterschieden. z-Richtung ist die
% Bewegungsrichtung des Kolbens. Die y-Richtung steht senkrecht dazu.
M1_y=zeros(z,N);
M1_z=zeros(z,N);
M2_y=zeros(z,N);
M2_z=zeros(z,N);


 
% Durch oszillierende (mo) und rotierende (mr) Massen hervorgerufene freie
% Massenmomente erster und zweiter Ordnung
for k=1:z
    for c=1:N
        M1_y(k,c)=(mr+mo)*r/1000*omega^2*cos(alpha(c)+Beta(k))*abstand(k);
        M1_z(k,c)=(mr+mo)*r/1000*omega^2*sin(alpha(c)+Beta(k))*abstand(k);
        M2_y(k,c)=mo*r/1000*omega^2*cos(2*(alpha(c)+Beta(k)))*abstand(k);
        M2_z(k,c)=mo*r/1000*omega^2*sin(2*(alpha(c)+Beta(k)))*abstand(k);
    end
end


% Wenn mehr als ein Motor mit mehr als einem Zylinder, dann entsteht eine
% Matrix, die zeilenweise addiert wird

if z>1
    M1_y=sum(M1_y);
    M1_z=sum(M1_z);
    M2_y=sum(M2_y);
    M2_z=sum(M2_z);
end

M1_y=round(M1_y*1000)/1000;
M1_z=round(M1_z*1000)/1000;
M2_y=round(M2_y*1000)/1000;
M2_z=round(M2_z*1000)/1000;

% Momente in y-Richtung und z-Richtung werden zu einem resultierenden
% Moment M1_ges und M2_ges zusammengefasst
M1_ges=sqrt((M1_y).^2 + (M1_z).^2);
M2_ges=sqrt((M2_y).^2 + (M2_z).^2);


% Runden der Ergebnisse
M1_ges=round(M1_ges*1000)/1000;
M2_ges=round(M2_ges*1000)/1000;



end

% -------------------------------------------------------------------

%  Boxermotor-------------------------------------------
% Freie Massenkräfte und freie Massenmomente beim Boxermotor
% Die Kolben bewegen sich im Gegensatz zum Reihenmotor im gemeinsamen
% Koordinatensystem in y-Richtung

if Boxermotor==1 

for k=1:z 
    for c=1:N 
        if k<=z/2   
            Fo1(k,c)=mo*r/1000*omega^2*cos(alpha(c)+Beta(k)); 
            Fo2(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+Beta(k)));
        else
        if z>1
            Fo1(k,c)=-mo*r/1000*omega^2*cos(alpha(c)+Beta(k)); 
            Fo2(k,c)=-mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+Beta(k)));

        end
        end
    end    
end



% x ist ein Faktor für Zylinderabstand a
x=z/2-1;
% Lage des Schwerpunkts
S=(x*a+b)/2;

% Abstand von benachbarten Zylindern
lz=(a-b);

% Mit zyl wird in der if-Schleife (sieh unten) ermittelt, ob eine gerade
% oder ungerade Anzahl an Zylindern vorliegt. Denn die Anzahl an Zylindern
% beim Boxermotor muss gerade sein
zyl=z/4;

% Der erste Zylinder hat den Abstand -S
abstand1(1)=-S;
for k=2:z/2
    
  if z==2
    abstand1(2)=-abstand1(1);
    
  end  
    
    if round(zyl)==zyl
          if rem(k,2)
              abstand1(k)=abstand1(k-1)+lz;
          else
              abstand1(k)=abstand1(k-1)+b;
          end
    abstand1(z/2)=-(a/2-b/2);
    else
        
    if rem(k,2)
        abstand1(k)=abstand1(k-1)+lz;
    else
        abstand1(k)=abstand1(k-1)+b;
    end
    abstand1(z/2)=-b/2;
   
    end
end

% Negativen Teil des Vektors positiv Spiegeln
abstand1= [abstand1, fliplr(-abstand1)];


% Zuordnung der Kröpfungsabstände gemäß der Zählreihenfolge
vektor=[abstand1(1:2:end),abstand1(2:2:end)];

abstand1=vektor;






% freie Massenmomente bestimmen
% Hier wird in y und z Richtung unterschieden. z-Richtung ist die
% Bewegungsrichtung des Kolbens. Die y-Richtung steht senkrecht dazu.
M1_y=zeros(z,N);
M1_z=zeros(z,N);
M2_y=zeros(z,N);
M2_z=zeros(z,N);


% Durch oszillierende (mo) und rotierende (mr) Massen hervorgerufene freie
% Massenmomente erster und zweiter Ordnung
for k=1:z
    for c=1:N
        if k<=z/2
            M1_y(k,c)=(mr+mo)*r/1000*omega^2*cos(alpha(c)+Beta(k))*abstand1(k);
            M1_z(k,c)=(mr+mo)*r/1000*omega^2*sin(alpha(c)+Beta(k))*abstand1(k);
            M2_y(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+Beta(k)))*abstand1(k);
            M2_z(k,c)=mo*r/1000*omega^2*lambdap*sin(2*(alpha(c)+Beta(k)))*abstand1(k);
        else
            M1_y(k,c)=-(mr+mo)*r/1000*omega^2*cos(alpha(c)+Beta(k))*abstand1(k);
            M1_z(k,c)=-(mr+mo)*r/1000*omega^2*sin(alpha(c)+Beta(k))*abstand1(k);
            M2_y(k,c)=-mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+Beta(k)))*abstand1(k);
            M2_z(k,c)=-mo*r/1000*omega^2*lambdap*sin(2*(alpha(c)+Beta(k)))*abstand1(k);
        end
    end
end

% Wenn mehr als ein Motor mit mehr als einem Zylinder, dann entsteht eine
% Matrix, die zeilenweise addiert wird

if z>1
    M1_y=sum(M1_y);
    M1_z=sum(M1_z);
    M2_y=sum(M2_y);
    M2_z=sum(M2_z);
end

M1_y=round(M1_y*1000)/1000;
M1_z=round(M1_z*1000)/1000;
M2_y=round(M2_y*1000)/1000;
M2_z=round(M2_z*1000)/1000;


% Momente in y-Richtung und z-Richtung werden zu einem resultierenden
% Moment M1_ges und M2_ges zusammengefasst
M1_ges=sqrt((M1_y).^2 + (M1_z).^2);
M2_ges=sqrt((M2_y).^2 + (M2_z).^2);


% Runden der Ergebnisse
M1_ges=round(M1_ges*1000)/1000;
M2_ges=round(M2_ges*1000)/1000;

end
% -----------------------------------------------------------------


% V-Motor---------------------------------------------------

if V_Motor==1


% % Oszillierende Massenkräfte zerlegt in x und y Richtung
% 
% for k=1:z 
%     for c=1:N 
%         if k<=z/2   
%             Fo1(k,c)=mo*r/1000*omega^2*cos(alpha(c)+gamma_A+Beta(k)).*cos(gamma_A);    
%             Fo2(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+gamma_A+Beta(k))).*cos(gamma_A);    
%             Fo1_x(k,c)=mo*r/1000*omega^2*cos(alpha(c)+gamma_A+Beta(k)).*sin(gamma_A);    
%             Fo2_x(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+gamma_A+Beta(k))).*sin(gamma_A);  
%         else
%             Fo1(k,c)=mo*r/1000*omega^2*cos(alpha(c)-gamma_B+Beta(k)).*cos(gamma_B);
%             Fo2(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)-gamma_B+Beta(k))).*cos(gamma_B);
%             Fo1_x(k,c)=-mo*r/1000*omega^2*cos(alpha(c)-gamma_B+Beta(k)).*sin(gamma_B); 
%             Fo2_x(k,c)=-mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)-gamma_B+Beta(k))).*sin(gamma_B);
%         end
%     end    
% end
% 
% 
% 
% 
% Fo1_ges=sum(Fo1);
% Fo1_ges_x=sum(Fo1_x);
% Fo2_ges=sum(Fo2);
% Fo2_ges_x=sum(Fo2_x);
% 
% 
% Fo1_ges=round(Fo1_ges*1000)/1000;
% Fo1_ges_x=round(Fo1_ges_x*1000)/1000;
% Fo2_ges=round(Fo2_ges*1000)/1000;
% Fo2_ges_x=round(Fo2_ges_x*1000)/1000;
% 
% 
% 
% 
% 
% 
% 
% % x ist ein Faktor für Zylinderabstand a
% x=z/2-1;
% % Lage des Schwerpunkts
% S=(x*a+b)/2;
% 
% % Abstand von benachbarten Zylindern
% lz=(a-b);
% % Ermittlung des Lage der Schwerpunktes
% zyl=z/4;
% 
% abstand1(1)=-S;
% for k=2:z/2
%     
%   if z==2
%     abstand1(2)=-abstand1(1);
%     
%   end  
%     
%     if round(zyl)==zyl
%           if rem(k,2)
%             abstand1(k)=abstand1(k-1)+lz;
%           else abstand1(k)=abstand1(k-1)+b;
%           end
%         abstand1(z/2)=-(a/2-b/2);
%     else
%         
%           if rem(k,2)
%             abstand1(k)=abstand1(k-1)+lz;
%           else abstand1(k)=abstand1(k-1)+b;
%           end
%         abstand1(z/2)=-b/2;
%    
%     end
% end
% 
% % Negativen Teil des Vektors positiv Spiegeln
% abstand1= [abstand1, fliplr(-abstand1)];
% 
% 
% 
% vektor=[abstand1(1:2:end),abstand1(2:2:end)];
% 
% abstand1=vektor;
% 
% 
% 
% % freie Massenmomente bestimmen
% % Hier wird in y und z Richtung unterschieden. z-Richtung ist die
% % Bewegungsrichtung des Kolbens. Die y-Richtung steht senkrecht dazu.
% M1_y=zeros(z,N);
% M1_z=zeros(z,N);
% M2_y=zeros(z,N);
% M2_z=zeros(z,N);
% 
% 
% 
% 
% % Durch oszillierende (mo) und rotierende (mr) Massen hervorgerufene freie
% % Massenmomente erster und zweiter Ordnung
% for k=1:z
%     for c=1:N
%         M1_z(k,c)=Fo1_x(k,c)*abstand1(k);
%         M1_y(k,c)=Fo1(k,c)*abstand1(k);
%         M2_z(k,c)=Fo2_x(k,c)*abstand1(k);
%         M2_y(k,c)=Fo2(k,c)*abstand1(k);
%     end
% end
% 
% 
% 
% % Wenn mehr als ein Motor mit mehr als einem Zylinder, dann entsteht eine
% % Matrix, die zeilenweise addiert wird
% 
% if z>1
%     M1_y=sum(M1_y);
%     M1_z=sum(M1_z);
%     M2_y=sum(M2_y);
%     M2_z=sum(M2_z);
% end
% 
% % Momente in y-Richtung und z-Richtung werden zu einem resultierenden
% % Moment M1_ges und M2_ges zusammengefasst
% M1_ges=sqrt((M1_y).^2 + (M1_z).^2);
% M2_ges=sqrt((M2_y).^2 + (M2_z).^2);
% 
% % Runden der Werte
% M1_ges=round(M1_ges*1000)/1000;
% M2_ges=round(M2_ges*1000)/1000;

EingabeG=evalin('base','EingabeG');


[Fo1,Fo2,Fo1_x,Fo2_x,...
          M1_y,M1_z,M2_y,M2_z,...
          M1_ges,M2_ges,Mo,Fosz1,Fosz2]=osz_Kraft_Vmotor(EingabeG);



end




N=length(alpha);






% ----------------------------------------------------------------------
% ----------------------------------------------------------------------
% Berechnungen zu Kräften und Momenten am Reihenmotor,Boxermotor und
% V-Motor


% ----------------------------------------------------------------
% Kräfte und Momente am Reihenmotor

if Reihenmotor==1 

    
FGass=Ak/10000*(pk*100000-pKG*100000);
FGas=zeros(z,N);
for k=1:z
    FGas(k,:)=circshift(FGass',-Beta1(k));
end
    
    
    
% Kolbenkraft
Fk= zeros(z, N);

for k=1:z
    for c=1:N
        Fk(k,c)=FGas(k,c)-(Fo1(k,c)+Fo2(k,c));
    end
end



% Pleulwinkel in Rad

Betapl= zeros(z, N);


for k=1:z
    for c=1:N
        Betapl(k,c)=asin(lambdap*sin(alpha(c)+Beta(k)));
    end
end


% Pleulkraft

Fp=zeros(z, N);

for k=1:z
    for c=1:N
        Fp(k,c)=Fk(k,c)/cos(Betapl(k,c));
    end
end





% Normalkraft
FN=Fk.*tan(Betapl);


% Gastangentialkraft FTG

FTG=zeros(z,N);
for k=1:z 
    for c=1:N
        FTG(k,c)= FGas(k,c)*(sin(alpha(c)+Beta(k)))/cos(Betapl(k,c));
    end 
end

% Tangentialkraft FTosz durch die oszillierende Massenkraft 
FTosz=zeros(z,N);
for k=1:z 
    for c=1:N
        FTosz(k,c)= (Fo1(k,c)+Fo2(k,c))*(sin(alpha(c)+Beta(k)))/cos(Betapl(k,c));
    end 
end


% Wenn Boxermotor dann Fo1_x=Fo1 und Fo2_x=Fo2 



% exakt oszilierendes Moment Reihenmotor
Mo= zeros(z, N);

for k=1:z 
    for c=1:N
        Mo(k,c)=-r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)+Betapl(k,c)))/cos(Betapl(k,c)));
    end 
end


% Gasmoment

MGas= zeros(z, N);

for k=1:z
    MGas(k,:)=r/1000*FGas(k,:).*(sin(alpha+Beta(k)+Betapl(k,:))./cos(Betapl(k,:)));
end


% gesamtes Moment
Mges=Mo+MGas;


Fy= zeros(z, N);
Fz= zeros(z, N);

% Die freien Massenkräfte setzen sich aus den Anteilen der oszillierenden
% Massenkraft 1 und 2 Ordnung, sowie der rotierenden Massenkraft, zusammen
for k=1:z
    for c=1:N
        Fy(k,c)=mr*omega^2*r/1000*sin(alpha(c)+Beta(k));
        Fz(k,c)=r/1000*omega^2*(mr*cos(alpha(c)+Beta(k))+mo*cos(alpha(c)+Beta(k))+...
                mo*lambdap*cos(2*(alpha(c)+Beta(k))));
    end
end






if z>1
    FGas=sum(FGas);
    Fk=sum(Fk);
    Fp=sum(Fp);
    FN=sum(FN);
    Mo=sum(Mo);
    MGas=sum(MGas);
    Mges=sum(Mges);
    Fy=sum(Fy);
    Fz=sum(Fz);
    FTG=sum(FTG);
    FTosz=sum(FTosz);
end

Fy=round(Fy*1000)/1000;
Fz=round(Fz*1000)/1000;





end
% ----------------------------------------------------------------


% ----------------------------------------------------------------
% Kräfte und Momente am Boxermotor

if Boxermotor==1 
 
FGass=Ak/10000*(pk*100000-pKG*100000);
FGas=zeros(z,N);


% for k=1:z
%     for c=1:N
%         if k<=z/2
%             FGas(k,:)=circshift(FGass',-Beta1(k));
%         else
%             FGas(k,:)=circshift(FGass',-Beta1(k));
%         end
%     end
%    
% end   


for k=1:z
    if k<=z/2
        FGas(k,:)=circshift(FGass',-(round(Beta1(k))));
    else
        FGas(k,:)=circshift(FGass',-(round(Beta1(k))));
    end
end     


    
    
% Kolbenkraft
Fk= zeros(z, N);

for k=1:z
    for c=1:N
        Fk(k,c)=FGas(k,c)-(Fo1(k,c)+Fo2(k,c));
    end
end

% Fk=FGas -(Fo1+Fo2);




% Pleulwinkel in Rad

% Betapl= zeros(z, N);
% 
% 
% for k=1:z
%     for c=1:N
%         if k<=z/2
%         Betapl(k,c)=asin(lambdap*sin(alpha(c)+Beta(k)));
%         else
%         Betapl(k,c)=asin(lambdap*sin(alpha(c)+Beta(k)));   
%         end
%     end
% end

% Pleulwinkel in Rad
Betapl= zeros(z, N);


for k=1:z
    for c=1:N
        if k<=z/2
            Betapl(k,c)=asin(lambdap*sin(alpha(c)+gamma_A+Beta(k)));
        else
            Betapl(k,c)=asin(lambdap*sin(alpha(c)-gamma_B+Beta(k)));
        end
    end
end








% Betrag des Pleulwinkels ermitteln

% Pleulkraft

Fp=zeros(z, N);

for k=1:z
    for c=1:N
        Fp(k,c)=Fk(k,c)/cos(Betapl(k,c));
    end
end





% Normalkraft
FN=Fk.*tan(Betapl);


% % Gastangentialkraft FTG
% 
% FTG=zeros(z,N);
% for k=1:z 
%     for c=1:N
%         FTG(k,c)= FGas(k,c)*(sin(alpha(c)+Beta(k)))/cos(Betapl(k,c));
%     end 
% end
% 
% % Tangentialkraft FTosz durch die oszillierende Massenkraft 
% FTosz=zeros(z,N);
% for k=1:z 
%     for c=1:N
%         FTosz(k,c)= (Fo1(k,c)+Fo2(k,c))*(sin(alpha(c)+Beta(k)))/cos(Betapl(k,c));
%     end 
% end

% Gastangentialkraft FTG

FTG=zeros(z,N);
for k=1:z 
    for c=1:N
        if k<=z/2
            FTG(k,c)= FGas(k,c)*(sin(alpha(c)+gamma_A+Beta(k)))/cos(Betapl(k,c));
        else
            FTG(k,c)= FGas(k,c)*(sin(alpha(c)-gamma_B+Beta(k)))/cos(Betapl(k,c));
        end
    end
end

% Tangentialkraft FTosz durch die oszillierende Massenkraft 
FTosz=zeros(z,N);
for k=1:z 
    for c=1:N
        if k<=z/2
            FTosz(k,c)= (Fo1(k,c)+Fo2(k,c))*(sin(alpha(c)+gamma_A+Beta(k)))/cos(Betapl(k,c));
        else
            FTosz(k,c)= (Fo1(k,c)+Fo2(k,c))*(sin(alpha(c)-gamma_B+Beta(k)))/cos(Betapl(k,c));
        end 
    end
end

FT=FTosz+FTG;






% Wenn Boxermotor dann Fo1_x=Fo1 und Fo2_x=Fo2 

% % exakt oszilierendes Moment Reihenmotor
% Mo= zeros(z, N);
% 
% for k=1:z 
%     for c=1:N
%         if k<=z/2
%             Mo(k,c)=-r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)+Betapl(k,c)))/cos(Betapl(k,c)));
%         else
%             Mo(k,c)=-r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)+Betapl(k,c)))/cos(Betapl(k,c)));
%         end
%            
%     end 
% end

% exakt oszilierendes Moment Reihenmotor
Mo= zeros(z, N);

for k=1:z 
    for c=1:N
        if k<=z/2
             Mo(k,c)=r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)+Betapl(k,c)))/cos(Betapl(k,c)));
                    
         else
              Mo(k,c)=r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)+Betapl(k,c)))/cos(Betapl(k,c)));
                     

        end 
    end
end


% Gasmoment

% MGas= zeros(z, N);
% 
% for k=1:z
%     for c=1:N
%         if k<=z/2
%             MGas(k,c)=r/1000*FGas(k,c)*(sin(alpha(c)+Beta(k)+Betapl(k,c))/cos(Betapl(k,c)));
%         else
%             MGas(k,c)=r/1000*FGas(k,c)*(sin(alpha(c)+Beta(k)+Betapl(k,c))/cos(Betapl(k,c)));
%         end
%     end
% end

MGas= zeros(z, N);

for k=1:z
    for c=1:N
        if k<=z/2
            MGas(k,c)=r/1000*FGas(k,c)*(sin(alpha(c)+Beta(k)+gamma_A+Betapl(k,c))/cos(Betapl(k,c)));
        else
            MGas(k,c)=r/1000*FGas(k,c)*(sin(alpha(c)+Beta(k)-gamma_B+Betapl(k,c))/cos(Betapl(k,c)));

        end
    end
end







% gesamtes Moment
Mges=Mo+MGas;


Fy= zeros(z, N);
Fz= zeros(z, N);


% Freie Massenkräfte aufgeteilt in y-Richtung und z-Richtung
% Die Formeln beinhalten sowohl die osziliierenden als auch rotierende
% Massenkräfte



for k=1:z
    for c=1:N
        Fz(k,c)=Fo1_x(k,c)+Fo2_x(k,c)+mo*r/1000*(omega)^2*mr*sin(alpha(c)+Beta(k));
        Fy(k,c)=(Fo1(k,c)+Fo2(k,c))+mo*r/1000*(omega)^2*mr*cos(alpha(c)+Beta(k));
    end
end




if z>1
    
    FGas=sum(FGas);
    Fk=sum(Fk);
    Fp=sum(Fp);
    FN=sum(FN);
    Mo=sum(Mo);
    MGas=sum(MGas);
    Mges=sum(Mges);
    Fy=sum(Fy);
    Fz=sum(Fz);
    FTG=sum(FTG);
    FTosz=sum(FTosz);
end

Fy=round(Fy*1000)/1000;
Fz=round(Fz*1000)/1000;

end



% --------------------------------------------------------------------
% Kräfte und Momente bei einem V-Motor

if V_Motor ==1

FGass=Ak/10000*(pk*100000-pKG*100000);

% Gaskraft an den Zündabstand anpassen
FGas=zeros(z,N);
for k=1:z
    if k<=z/2
        FGas(k,:)=circshift(FGass',-(round(Beta1(k))));
    else
        FGas(k,:)=circshift(FGass',-(round(Beta1(k))));
    end
end     







% Pleulwinkel in Rad
Betapl= zeros(z, N);


for k=1:z
    for c=1:N
        if k<=z/2
            Betapl(k,c)=asin(lambdap*sin(alpha(c)+gamma_A+Beta(k)));
        else
            Betapl(k,c)=asin(lambdap*sin(alpha(c)-gamma_B+Beta(k)));
        end
    end
end

% Oszillierende Kraft eines V-Motors in Richtung des Kolbens
% Das heißt parallel zu der Bewegung des Kolbens angeordnet

% Fosz1= zeros(z, N);
% Fosz2=Fosz1;
% 
% for k=1:z
%     for c=1:N
%         if k<=z/2
%             Fosz1(k,c)=mo*r/1000*omega^2*cos(alpha(c)+gamma_A+Beta(k));
%             Fosz2(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)+gamma_A+Beta(k)));
%         else
%             Fosz1(k,c)=mo*r/1000*omega^2*cos(alpha(c)-gamma_B+Beta(k));
%             Fosz2(k,c)=mo*r/1000*omega^2*lambdap*cos(2*(alpha(c)-gamma_B+Beta(k)));
%         end
%     end
% end

  




% Kolbenkraft
Fk= zeros(z, N);

for k=1:z
    for c=1:N
        Fk(k,c)=FGas(k,c)-(Fosz1(k,c)+Fosz2(k,c));
    end
end


% Pleulkraft Fp

Fp=zeros(z, N);

for k=1:z
    for c=1:N
        Fp(k,c)=Fk(k,c)/cos(Betapl(k,c));
    end
end

% Normalkraft
FN=Fk.*tan(Betapl);


% Gastangentialkraft FTG

FTG=zeros(z,N);
for k=1:z 
    for c=1:N
        if k<=z/2
            FTG(k,c)= FGas(k,c)*(sin(alpha(c)+gamma_A+Beta(k)))/cos(Betapl(k,c));
        else
            FTG(k,c)= FGas(k,c)*(sin(alpha(c)-gamma_B+Beta(k)))/cos(Betapl(k,c));
        end
    end
end

% Tangentialkraft FTosz durch die oszillierende Massenkraft 
FTosz=zeros(z,N);
for k=1:z 
    for c=1:N
        if k<=z/2
            FTosz(k,c)= (Fo1(k,c)+Fo2(k,c))*(sin(alpha(c)+gamma_A+Beta(k)))/cos(Betapl(k,c));
        else
            FTosz(k,c)= (Fo1(k,c)+Fo2(k,c))*(sin(alpha(c)-gamma_B+Beta(k)))/cos(Betapl(k,c));
        end 
    end
end

FT=FTosz+FTG;


% % exakt oszilierendes Moment Reihenmotor
% Mo= zeros(z, N);
% 
% for k=1:z 
%     for c=1:N
%         if k<=z/2
%              Mo(k,c)=-r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)+gamma_A+Betapl(k,c)))/cos(Betapl(k,c)));
%                     
%          else
%               Mo(k,c)=-r/1000*(Fo1(k,c)+Fo2(k,c))*((sin(alpha(c)+Beta(k)-gamma_B+Betapl(k,c)))/cos(Betapl(k,c)));
%                      
% 
%         end 
%     end
% end

% Gasmoment MGas

MGas= zeros(z, N);

for k=1:z
    for c=1:N
        if k<=z/2
            MGas(k,c)=r/1000*FGas(k,c)*(sin(alpha(c)+Beta(k)+gamma_A+Betapl(k,c))/cos(Betapl(k,c)));
        else
            MGas(k,c)=r/1000*FGas(k,c)*(sin(alpha(c)+Beta(k)-gamma_B+Betapl(k,c))/cos(Betapl(k,c)));

        end
    end
end

% for k=1:z
%     for c=1:N
%         MGas(k,c)=FTG(k,c)*r/1000;
%     end
% end



% gesamtes Moment
Mges=Mo+MGas;




Fy= zeros(z, N);
Fz= zeros(z, N);


% Die freien Massenkräfte setzen sich aus den Anteilen der oszillierenden
% Massenkraft 1 und 2 Ordnung, sowie der rotierenden Massenkraft, zusammen
for k=1:z
    for c=1:N
        if k>=z/2
            Fz(k,c)=mr*r/1000*omega^2*cos(alpha(c)+Beta(k)+gamma_A)+Fo1(k,c)+Fo2(k,c);
            Fy(k,c)=mr*r/1000*omega^2*sin(alpha(c)+Beta(k)+gamma_A)+Fo1_x(k,c)+Fo2_x(k,c);
        else
            Fz(k,c)=mr*r/1000*omega^2*cos(alpha(c)+Beta(k)+gamma_B)+Fo1(k,c)+Fo2(k,c);
            Fy(k,c)=mr*r/1000*omega^2*sin(alpha(c)+Beta(k)+gamma_B)+Fo1_x(k,c)+Fo2_x(k,c);
        end
    end
end


% Aus dem Buch Kräfte, Momente und deren Ausgleich
% for k=1:z/2
%     for c=1:N
%         Fz(k,c)=-r/1000*omega^2*(mr*cos(alpha(c)+Beta(k))+mo*(1+cos(2*gamma_A))*cos(alpha(c)+Beta(k))+...
%                 mo*lambdap*(cos(gamma_A)+cos(3*(2*gamma_A)/2))*cos(2*(alpha(c)+Beta(k))));
%         Fy(k,c)=-r/1000*omega^2*(mr*sin(alpha(c)+Beta(k))+mo*(1-cos(2*gamma_A))*sin(alpha(c)+Beta(k))+...
%                 mo*lambdap*(cos(gamma_A)-cos(3*(2*gamma_A)/2))*sin(2*(alpha(c)+Beta(k))));
%     end
% end
    


if z>1
    
    FGas=sum(FGas);
    Fk=sum(Fk);
    Fp=sum(Fp);
    FN=sum(FN);
    Mo=sum(Mo);
    MGas=sum(MGas);
    Mges=sum(Mges);
    Fy=sum(Fy);
    Fz=sum(Fz);
    FTG=sum(FTG);
    FTosz=sum(FTosz);
end

Fy=round(Fy*1000)/1000;
Fz=round(Fz*1000)/1000;


end
% ------------------------------------------------------------------



% ------------------------------------------------------------------
% ------------------------------------------------------------------



% Wenn Zylinderanzahl größer wie 1 ist, dann entsteht eine Matrix, die
% Zeilenweise addiert wird

if Reihenmotor==1

    if z>1
        Fo1=sum(Fo1);
        Fo2=sum(Fo2);
        Fo1=round(Fo1*1000)/1000;
        Fo2=round(Fo2*1000)/1000;
    end

% Runden der Ergebnisse
    if z==1
        Fo1=round(Fo1*1000)/1000;
        Fo2=round(Fo2*1000)/1000;
    end

% gesamte oszillierende Kraft 
Fo=Fo1+Fo2;

end



if Boxermotor==1
% Wenn Zylinderanzahl größer wie 1 ist, dann entsteht eine Matrix, die
% Zeilenweise addiert wird
    if z>1
        Fo1=sum(Fo1);
        Fo2=sum(Fo2);
        Fo1=round(Fo1*1000)/1000;
        Fo2=round(Fo2*1000)/1000;
    end

% Runden der Ergebnisse
    if z==1
        Fo1=round(Fo1*1000)/1000;
        Fo2=round(Fo2*1000)/1000;
    end

% gesamte oszillierende Kraft 
Fo=Fo1+Fo2;


Fo=round(Fo*1000)/1000;
FGas=round(FGas*1000)/1000;
Fk=round(Fk*1000)/1000;




end



if V_Motor==1
    Fo1=sum(Fo1);
    Fo1_x=sum(Fo1_x);
    Fo2=sum(Fo2);
    Fo2_x=sum(Fo2_x);


    Fo1=round(Fo1*1000)/1000;
    Fo1_x=round(Fo1_x*1000)/1000;
    Fo2=round(Fo2*1000)/1000;
    Fo2_x=round(Fo2_x*1000)/1000;
    
% gesamte oszillierende Kraft 
    Fo_ges=Fo1+Fo2;
    Fo_ges_x=Fo1_x+Fo2_x;
    
end;



% Titelüberschriften der Diagramme automatisch anpassen 
if Reihenmotor==1
name = 'Reihenmotor';
end

if Boxermotor==1
    name='Boxermotor';
end

if V_Motor==1
    name='V-Motor';
end
    



alpha=(0:1:720);



% Ploteinstellungen

% -------------------------------------------------------
% Alle Diagramme auf einmal einzeln plotten
if diagrammf==1
    if Reihenmotor==1 || Boxermotor==1
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Fo,'b','LineWidth',1.5)
        hold
        plot(alpha,FGas,'m','LineWidth',1.5)
        plot(alpha,Fk,'g','LineWidth',1.5)
        hold off
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Schrittweite auf der y-Achse auf 5000N festlegen
        MaxSteps = 10; 
        Low = -10000; 
        High = 100000; 
        Step = (High - Low) / MaxSteps; 
        RoundStep = 10^(ceil(log10(Step)) - 1); 
        set(gca,'Ytick',-100000:RoundStep:1000000)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fo [N]','Location','NE','FGas [N]','Location','NE','Fk [N]',...
       'Location','NE')

    end
    
    if V_Motor==1
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Fo_ges,'b','LineWidth',1.5)
        hold
        plot(alpha,Fo_ges_x,'k','LineWidth',1.5)
        plot(alpha,FGas,'m','LineWidth',1.5)
        plot(alpha,Fk,'g','LineWidth',1.5)
        hold off

        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Schrittweite auf der y-Achse automatisch anpassen
        MaxSteps = 10; 
        Low = -10000; 
        High = 100000; 
        Step = (High - Low) / MaxSteps; 
        RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
        set(gca,'Ytick',-100000:RoundStep:1000000)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fo_z [N]','Location','NE','Fo_y [N]','Location','NE','FGas [N]','Location','NE','Fk [N]',...
               'Location','NE')
    end


    figure('NumberTitle','off','Name','Diagramm F, M') 
    plot(alpha,Fy,'m','LineWidth',1.5)
    hold
    plot(alpha,Fz,'b','LineWidth',1.5)
    hold off

    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    t1=title(['freie Massenkräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Schrittweite auf der y-Achse automatisch anpassen
    MaxSteps = 10; 
    Low = -10000; 
    High = 100000; 
    Step = (High - Low) / MaxSteps; 
    RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
    set(gca,'Ytick',-100000:RoundStep:1000000)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Kraft F [N]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Fy [N]','Location','BestOutside','Fz [N]','Location','BestOutside')



    figure('NumberTitle','off','Name','Diagramm F, M') 
    plot(alpha,Mo,'b','LineWidth',1.5)
    hold
    plot(alpha,MGas,'m','LineWidth',1.5)
    plot(alpha,Mges,'g','LineWidth',1.5)
    hold off

    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    t1=title(['Momente beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Schrittweite auf der y-Achse automatisch anpassen
    MaxSteps = 10; 
    Low = -10000; 
    High = 100000; 
    Step = (High - Low) / MaxSteps; 
    RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
    set(gca,'Ytick',-100000:RoundStep:1000000)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Moment M [Nm]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Mo [Nm]','Location','NE','MGas [Nm]','Location','NE',...
        'Mges [Nm]','Location','NE')


    figure('NumberTitle','off','Name','Diagramm F, M') 
    plot(Fy,Fz,'b','LineWidth',1.5)

    % Intervall der x-Achse festlegen
    grid
    t1=title(['freie Massenkräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)   
    % Schrittweite auf der y-Achse automatisch anpassen
    MaxSteps = 10; 
    Low = -10000; 
    High = 100000; 
    Step = (High - Low) / MaxSteps; 
    RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
    set(gca,'Ytick',-100000:RoundStep:1000000)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Fy [N]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Fz [N]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')


    figure('NumberTitle','off','Name','Diagramm F, M') 
    plot(alpha,Fp,'b','LineWidth',1.5)
    hold
    plot(alpha,FN,'m','LineWidth',1.5)
    hold off

    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Schrittweite auf der y-Achse automatisch anpassen
    MaxSteps = 10; 
    Low = -10000; 
    High = 100000; 
    Step = (High - Low) / MaxSteps; 
    RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
    set(gca,'Ytick',-100000:RoundStep:1000000)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Kraft F [N]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Fp [N]','Location','BestOutside','FN [N]','Location','BestOutside')


    figure('NumberTitle','off','Name','freie Massenmomente')
    plot(alpha,M1_y,'m-.','LineWidth',1.5)
    hold
    plot(alpha,M1_z,'b-.','LineWidth',1.5)
    plot(alpha,M1_ges,'r','LineWidth',1.5)
    plot(alpha,M2_y,'c--','LineWidth',1.5)
    plot(alpha,M2_z,'y--','LineWidth',1.5)
    plot(alpha,M2_ges,'g','lineWidth',1.5)
    hold off
    t1=title(['freie Massenmomente 1 und 2 Ordnung beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)
    xlabel('Kurbelwellenwinkel[°]');
    legend ('M1_y','Location','BestOutside',...
        'M1_z','Location','BestOutside','M1res','Location','BestOutside',...
        'M2_y','Location','BestOutside', 'M2_z','Location','BestOutside',...
        'M2res','Location','BestOutside')
    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Schrittweite auf der y-Achse automatisch anpassen
    MaxSteps = 10; 
    Low = -10000; 
    High = 100000; 
    Step = (High - Low) / MaxSteps; 
    RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
    set(gca,'Ytick',-100000:RoundStep:1000000)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel(' M1 und M2 [Nm]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')


end


% ---------------------------------------------------------------
% Alle Diagramme auf einmal in einem Plot plotten
if diagrammf==2

    if Reihenmotor==1 || Boxermotor==1
        figure('NumberTitle','off','Name','Diagramm F, M') 
        subplot(3,2,1,'Position', [.07 .73 .3 .23])
        plot(alpha,Fo,'b','LineWidth',1.5)
        hold;
        plot(alpha,FGas,'m','LineWidth',1.5)
        plot(alpha,Fk,'g','LineWidth',1.5)
        hold off
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fo [N]','Location','NE','FGas [N]','Location','NE','Fk [N]',...
               'Location','NE')

    end

    if V_Motor==1
        figure('NumberTitle','off','Name','Diagramm F, M')
        subplot(3,2,1,'Position', [.07 .73 .3 .23])
        plot(alpha,Fo_ges,'b','LineWidth',1.5)
        hold;
        plot(alpha,Fo_ges_x,'k','LineWidth',1.5)
        plot(alpha,FGas,'m','LineWidth',1.5)
        plot(alpha,Fk,'g','LineWidth',1.5)
        hold off
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' '  num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fo_z [N]','Location','NE','Fo_y [N]','Location','NE','FGas [N]','Location','NE','Fk [N]',...
               'Location','NE')
    end


    subplot(3,2,2,'Position', [.55 .73 .5 .23])
    plot(alpha,Fy,'m','LineWidth',1.5)
    hold
    plot(alpha,Fz,'b','LineWidth',1.5)
    hold off
    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    t1=title(['freie Massenkräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Kraft F [N]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Fy [N]','Location','BestOutside','Fz [N]','Location','BestOutside')



    subplot(3,2,3,'Position', [.07 .4 .3 .23])
    plot(alpha,Mo,'b','LineWidth',1.5)
    hold;
    plot(alpha,MGas,'m','LineWidth',1.5)
    plot(alpha,Mges,'g','LineWidth',1.5)
    hold off
    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    t1=title(['Momente beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Moment M [Nm]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Mo [Nm]','Location','NE','MGas [Nm]','Location','NE',...
        'Mges [Nm]','Location','NE')


    
    subplot(3,2,4,'Position', [.55 .4 .3 .23])
    plot(Fy,Fz,'b','LineWidth',1.5)

    % Intervall der x-Achse festlegen
    grid
    t1=title(['freie Massenkräfte' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    y1=xlabel('Fy [N]');
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Fz [N]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Fz [N]','Location','NE')



    subplot(3,2,5,'Position', [.07 .07 .3 .23])
    plot(alpha,Fp,'b','LineWidth',1.5)
    hold;
    plot(alpha,FN,'m','LineWidth',1.5)
    hold off
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks'));
    set(gca,'YTick', yticks, 'YTickLabel',yticks_strings )
    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('Kraft F [N]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
    % Legende setzen
    legend ('Fp [N]','Location','NE','FN [N]','Location','NE')


    subplot(3,2,6,'Position', [.55 .07 .5 .23])
    plot(alpha,M1_y,'m-.','LineWidth',1.5)
    hold;
    plot(alpha,M1_z,'b-.','LineWidth',1.5)
    plot(alpha,M1_ges,'r','LineWidth',1.5)
    plot(alpha,M2_y,'c--','LineWidth',1.5)
    plot(alpha,M2_z,'y--','LineWidth',1.5)
    plot(alpha,M2_ges,'g','lineWidth',1.5)
    hold off 
    t1=title(['freie Massenmomente 1 und 2 Ordnung beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)
    xlabel('Kurbelwellenwinkel[°]');
    legend ('M1_y','Location','BestOutside',...
        'M1_z','Location','BestOutside','M1res','Location','BestOutside',...
        'M2_y','Location','BestOutside', 'M2_z','Location','BestOutside',...
        'M2res','Location','BestOutside')
    % Intervall der x-Achse festlegen
    xlim([0,720])
    grid
    % Schriftgröße des Titels ändern
    set(t1,'FontSize',14)    
    % Schrittweite auf der x-Achse auf 90° festlegen
    set(gca,'Xtick',0:90:720)
    % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
    yticks=get(gca,'YTick'); 
    yticks_strings = cellstr(num2str(yticks')); 
    set(gca,'YTickLabel',yticks_strings );
    y1=xlabel('Kurbelwellenwinkel[°]');
    % Titel der x-Achse "fett machen"
    set(y1,'FontWeight','bold')
    y2=ylabel('M1 und M2 [Nm]');
    % Titel der y-Achse "fett machen"
    set(y2,'FontWeight','bold')
    % Titelfarbe auf rot ändern
    set(t1,'color','r')
end





% --------------------------------------------------------
% Nur ausgewählte Diagramme plotten
if diagrammf==3

if auswahlf==1
    if Reihenmotor==1 || Boxermotor==1
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Fo,'b','LineWidth',1.5)
        hold
        plot(alpha,FGas,'m','LineWidth',1.5)
        plot(alpha,Fk,'g','LineWidth',1.5)
        hold off

        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fo [N]','Location','NE','FGas [N]','Location','NE','Fk [N]',...
               'Location','NE')
    end
    
    if V_Motor==1
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Fo_ges,'b','LineWidth',1.5)
        hold
        plot(alpha,Fo_ges_x,'k','LineWidth',1.5)
        plot(alpha,FGas,'m','LineWidth',1.5)
        plot(alpha,Fk,'g','LineWidth',1.5)
        hold off

        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Schrittweite auf der y-Achse automatisch anpassen
        MaxSteps = 10; 
        Low = -10000; 
        High = 100000; 
        Step = (High - Low) / MaxSteps; 
        RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
        set(gca,'Ytick',-100000:RoundStep:1000000)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fo_z [N]','Location','NE','Fo_y [N]','Location','NE','FGas [N]','Location','NE','Fk [N]',...
               'Location','NE')
    end

end

    if auswahlf==2
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Fy,'m','LineWidth',1.5)
        hold
        plot(alpha,Fz,'b','LineWidth',1.5)
        hold off
         % Schrittweite auf der y-Achse automatisch anpassen
        MaxSteps = 10; 
        Low = -10000; 
        High = 100000; 
        Step = (High - Low) / MaxSteps; 
        RoundStep = 10^(ceil(log10(Step)) - 1); % Oder ROUND
        set(gca,'Ytick',-100000:RoundStep:1000000)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['freie Massenkräfte beim' ' '  num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
%         set(gca,'Ytick',-50000:1000:80000)
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fy [N]','Location','BestOutside','Fz [N]','Location','BestOutside')
    end

    if auswahlf==3
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Mo,'b','LineWidth',1.5)
        hold
        plot(alpha,MGas,'m','LineWidth',1.5)
        plot(alpha,Mges,'g','LineWidth',1.5)
        hold off

        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Momente beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Moment M [Nm]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Mo [Nm]','Location','NE','MGas [Nm]','Location','NE',...
            'Mges [Nm]','Location','NE')
    end

    if auswahlf==4
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(Fy,'b','LineWidth',1.5)
        hold
        plot(Fz,'r','LineWidth',1.5)
        hold off
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        % Intervall der x-Achse festlegen
        grid
        t1=title(['freie Massenkräfte beim' ' '  num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        legend ('Fy [N]','Location','BestOutside','Fz [N]','Location','BestOutside')
%         set(gca,'Ytick',-50000:1000:50000)
        y1=xlabel('Fy [N]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Fz [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')    
    end

    if auswahlf==5
        figure('NumberTitle','off','Name','Diagramm F, M') 
        plot(alpha,Fp,'b','LineWidth',1.5)
        hold
        plot(alpha,FN,'m','LineWidth',1.5)
        hold off

        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        t1=title(['Kräfte beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name]);
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Kraft F [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
        % Legende setzen
        legend ('Fp [N]','Location','BestOutside','FN [N]','Location','BestOutside')
    end

    if auswahlf==6 
    
        figure('NumberTitle','off','Name','freie Massenmomente')
        plot(alpha,M1_y,'m-.','LineWidth',1.5)
        hold
        plot(alpha,M1_z,'b-.','LineWidth',1.5)
        plot(alpha,M1_ges,'r','LineWidth',1.5)
        plot(alpha,M2_y,'c--','LineWidth',1.5)
        plot(alpha,M2_z,'y--','LineWidth',1.5)
        plot(alpha,M2_ges,'g','lineWidth',1.5)
        hold off

        t1=title(['freie Massenmomente 1 und 2 Ordnung beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)
        xlabel('Kurbelwellenwinkel[°]');
        legend ('M1_y','Location','BestOutside',...
            'M1_z','Location','BestOutside','M1res','Location','BestOutside',...
            'M2_y','Location','BestOutside', 'M2_z','Location','BestOutside',...
            'M2res','Location','BestOutside')
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('M1 und M2 [Nm]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
    end

    if auswahlf==7
       
    if Reihenmotor==1 || Boxermotor==1    
        figure('NumberTitle','off','Name','freie Massenkräfte')    
        plot(alpha,Fo1,'r','LineWidth',1.5)
        hold
        plot(alpha,Fo2,'b','LineWidth',1.5)
        t1=title(['oszillierende Kräfte 1 und 2 Ordnung beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)
        xlabel('Kurbelwellenwinkel[°]');
        legend ('Fo1','Location','BestOutside',...
        'Fo2','Location','BestOutside')
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Fo1 und Fo2 [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
    end
    
    if V_Motor==1
       
        
        figure('NumberTitle','off','Name','freie Massenkräfte')
        plot(alpha,Fo1,'r','LineWidth',1.5)
        hold
        plot(alpha,Fo2,'b','LineWidth',1.5)
        plot(alpha,Fo1_x,'m','LineWidth',1.5)
        plot(alpha,Fo2_x,'g','LineWidth',1.5)
        t1=title(['oszillierende Kräfte 1 und 2 Ordnung beim' ' ' num2str(z) ' ' 'Zylinder' ' ' name] );
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)
        xlabel('Kurbelwellenwinkel[°]');
        legend ('Fo1 (z-Richtung)','Location','BestOutside',...
            'Fo2 (z-Richtung)','Location','BestOutside','Fo1 (y-Richtung)','Location','BestOutside','Fo2 (y-Richtung)','Location','BestOutside')
        % Intervall der x-Achse festlegen
        xlim([0,720])
        grid
        % Schriftgröße des Titels ändern
        set(t1,'FontSize',14)    
        % Schrittweite auf der x-Achse auf 90° festlegen
        set(gca,'Xtick',0:90:720)
        % Zahlenformat der y-Achse ändern von exponentiell zu dezimal
        yticks=get(gca,'YTick'); 
        yticks_strings = cellstr(num2str(yticks')); 
        set(gca,'YTickLabel',yticks_strings );
        y1=xlabel('Kurbelwellenwinkel[°]');
        % Titel der x-Achse "fett machen"
        set(y1,'FontWeight','bold')
        y2=ylabel('Fo1z, Fo2z, Fo1y, Fo2y [N]');
        % Titel der y-Achse "fett machen"
        set(y2,'FontWeight','bold')
        % Titelfarbe auf rot ändern
        set(t1,'color','r')
    end

    end  

  
end