1716.sagews

Maschen-Strom Verfahren

Uq1=10;
Uq2=1;
Iq3=4;
R=(1,20,24,50,80,65,35,80,75,99,68); #Element 0 willkürlich auf 1 gesetzt, für korrekte indizes

R10_6 = (1/R[10]+1/R[6])^(-1);
print R10_6.n();
Uq3=Iq3*R[3];
print Uq3.n();

23.1067961165049 200.000000000000

RD = matrix([
[R[2]+R10_6+R[8],0,0,0,0],
[0,R[9]+R[5]+R10_6+R[8]+R[7],0,0,0],
[0,0,R[1]+R[5]+R10_6+R[8]+R[7],0,0],
[0,0,0,R[4]+R[5]+R10_6,0],
[0,0,0,0,R[3]+R[8]+R[7]]
]);

RL = matrix([
[0,(R10_6+R[8]),(R10_6+R[8]),R10_6,R[8]],
[0,0,(R[5]+R10_6+R[8]+R[7]),(R[5]+R10_6),(R[8]+R[7])],
[0,0,0,(R[5]+R10_6),(R[8]+R[7])],
[0,0,0,0,(0)],
[0,0,0,0,0]
]);

RM = RD+RL+RL.transpose();
print RM.n(digits=5);

[ 122.11 98.107 98.107 23.107 75.000] [ 98.107 342.11 243.11 88.107 155.00] [ 98.107 243.11 263.11 88.107 155.00] [ 23.107 88.107 88.107 168.11 0.00000] [ 75.000 155.00 155.00 0.00000 205.00]

RM == (RM.inverse()).inverse();

True

U = vector([Uq2,0,-Uq1,-Uq1,-Uq3]);
print U;

(1, 0, -10, -10, -200)

I=RM.inverse()*U;
print I.n(digits=5);

(0.36957, 0.32351, 1.1014, -0.85707, -2.1881)

Gesuchte Werte ermitteln

I_R2=I[0];
print "I_R2: ", abs((I_R2*10^3).n(digits = 9)),"[mA]";
U_R2=I_R2*R[2];
print "U_R2: ", abs(U_R2.n(digits = 9)),"[V]";

I_R2: 369.571931 [mA] U_R2: 8.86972634 [V]

I_R9=I[1];
print "I_R9: ", abs((I_R9*10^3).n(digits = 9)),"[mA]";
U_R9=I_R9*R[9];
print "U_R9: ", abs(U_R9.n(digits = 9)),"[V]";

I_R9: 323.505225 [mA] U_R9: 32.0270173 [V]

I_R4=I[3];
print "I_R4: ", abs((I_R4*10^3).n(digits = 9)),"[mA]";
U_R4=I_R4*R[4];
print "U_R4: ", abs(U_R4.n(digits = 9)),"[V]";

I_R4: 857.069027 [mA] U_R4: 68.5655221 [V]

Knoten-Potential Verfahren

#leitwerte Rechnen
G = list();
for i in range(0,11):
    G.append( 1/R[i] );

Iq2 = Uq2/R[2];

GM = matrix([
[G[4]+G[6]+G[10]+G[3]+G[8],-G[6]-G[10],-G[3],-G[8]],
[-G[6]-G[10],G[5]+G[6]+G[10]+G[2],0,-G[2]],
[-G[3],0,G[1]+G[9]+G[3]+G[7],-G[7]],
[-G[8],-G[2],-G[7],G[2]+G[7]+G[8]]
]);
GM.n(digits = 4);

[ 0.08911 -0.04328 -0.02000 -0.01333] [-0.04328 0.1003 0.0000 -0.04167] [-0.02000 0.0000 0.09260 -0.01250] [-0.01333 -0.04167 -0.01250 0.06750]

GM == GM.transpose();

True

I2 = vector([-Iq3,Iq2-Uq1*G[5],Iq3-Uq1*G[9],-Iq2]);
I2.n(digits=5);

(-4.0000, -0.11218, 3.8990, -0.041667)

U2=GM.inverse()*I2;
U2.n(digits=6);

(-68.5655, -46.9062, 22.0270, -39.0364)

Gesuchte Werte ermitteln

U_R2_2 = (U2[1]-U2[3]-Uq2);
I_R2_2 = U_R2_2 * G[2];

print "U_R2: ",(abs(U_R2_2).n(digits=6)),"[V]";
print "I_R2: ",(abs(I_R2_2*10^3).n(digits=6)),"[mA]";

U_R2: 8.86973 [V] I_R2: 369.572 [mA]

print "U_R9: ",(abs((U2[2]+Uq1)).n(digits=6)),"[V]";
print "I_R9: ",(abs((U2[2]+Uq1)*G[9]*10^3).n(digits=6)),"[mA]";

U_R9: 32.0270 [V] I_R9: 323.505 [mA]

print "U_R4: ",(abs((U2[0])).n(digits=6)),"[V]";
print "I_R4: ",(abs((U2[0])*G[4]*10^3).n(digits=6)),"[mA]";

U_R4: 68.5655 [V] I_R4: 857.069 [mA]

#Test ob beide Verfahren das selbe Ergebnis für die R2 Werte liefern
print "Maschen-Strom-Verfahren:\t", abs(I_R2);
print "Knoten-Potential-Verfahren:\t", abs(I_R2_2);
print "Differenz: ", (abs(I_R2)-abs(I_R2_2)).n(digits=20);
print "Gleicher Wert: ", (abs(I_R2) == abs(I_R2_2));

Maschen-Strom-Verfahren: 4970095949/13448250616 Knoten-Potential-Verfahren: 4970095949/13448250616 Differenz: 0.00000000000000000000 Gleicher Wert: True