def n_getForces(XsecArr, vPhA, vPhB, vPhC, Ia, Ib, Ic, Lenght=1):
'''
this experimental functions will calcuate the fore vector for each phase
in given geometry and currents values.
Inputs:
vPhA/B/C - elements vectors of the each phase geometry as delivered by n_arrayVectorize
Ia/b/c - current value in each phase in [A]
'''
def sumVecList(list):
sumV = v2(0, 0)
for v in list:
sumV = sumV + v
return sumV
mi0_o2pi = 2e-7
# Memorizing each phaze elements count
lPh = (len(vPhA), len(vPhB), len(vPhC))
Iph = (Ia / len(vPhA), Ib / len(vPhB), Ic / len(vPhC))
# One vector for all phases
vPhAll = np.concatenate((vPhA, vPhB, vPhC), axis=0)
totalForceVec = []
for this in vPhAll:
forceVec = v2(0, 0) # initial reset for this element force
for other in vPhAll:
if this[0] != other[0] or this[1] != other[1]:
distV = v2(other[2]-this[2], other[3]-this[3])
direction = distV.normalize()
distance = distV.norm() * 1e-3 # to convert into [m]
Ithis = Iph[int(XsecArr[int(this[0])][int(this[1])])-1]
Iother = Iph[int(XsecArr[int(other[0])][int(other[1])])-1]
forceVec += Lenght * \
(mi0_o2pi * Iother * Ithis / distance) * direction
totalForceVec.append(forceVec)
ForceA = sumVecList(totalForceVec[:lPh[0]])
ForceB = sumVecList(totalForceVec[lPh[0]: lPh[0] + lPh[1]])
ForceC = sumVecList(totalForceVec[lPh[0] + lPh[1]:])
ForceMagVect = [force.norm() for force in totalForceVec]
return ForceA, ForceB, ForceC, ForceMagVect, totalForceVec
def sumVecList(list):
sumV = v2(0, 0)
for v in list:
sumV = sumV + v
return sumV
def forcesAnalysis(self):
# reading input data frm gui
self.readSettings()
self.Fa, self.Fb, self.Fc, self.ForcesMag2,\
self.ForcesVec = csd.n_getForces(XsecArr=self.XsecArr,
vPhA=self.vPhA,
vPhB=self.vPhB,
vPhC=self.vPhC,
Ia=self.Icw[0]*1e3,
Ib=self.Icw[1]*1e3,
Ic=self.Icw[2]*1e3,
Lenght=self.L*1e-3)
# Reversing the Y component sign to make it more 'natural'
self.Fa = v2(self.Fa[0], -self.Fa[1])
self.Fb = v2(self.Fb[0], -self.Fb[1])
self.Fc = v2(self.Fc[0], -self.Fc[1])
# Preparing the force density plot matrix
self.ForcesMag2 = [
abs(x / (self.dXmm * self.dYmm)) for x in self.ForcesMag2
]
self.resultsArray =\
csd.n_recreateresultsArray(elementsVector=self.elementsVector,
resultsVector=self.ForcesMag2,
initialGeometryArray=self.XsecArr)
self.console('Electrodynamic Forces:')
self.console('Fa(x,y):({0[0]:.0f},{0[1]:.0f})[N]'.format(self.Fa))
self.console('Fb(x,y):({0[0]:.0f},{0[1]:.0f})[N]'.format(self.Fb))
self.console('Fc(x,y):({0[0]:.0f},{0[1]:.0f})[N]'.format(self.Fc))
print('Forces: \nA:{}\nB:{}\nC:{}'.format(self.Fa, self.Fb, self.Fc))
# Cecking the area in array that is used by geometry to limit the disp.
min_row = int(np.min(self.elementsVector[:, 0]))
max_row = int(np.max(self.elementsVector[:, 0]) + 1)
min_col = int(np.min(self.elementsVector[:, 1]))
max_col = int(np.max(self.elementsVector[:, 1]) + 1)
self.resultsArray = self.resultsArray[min_row:max_row, min_col:max_col]
plotWidth = (self.resultsArray.shape[1]) * self.dXmm
plotHeight = (self.resultsArray.shape[0]) * self.dYmm
fig = plt.figure('Forces Vectors')
fig.clear()
ax = plt.axes()
my_cmap = matplotlib.cm.get_cmap('jet')
my_cmap.set_under('w')
im = ax.imshow(self.resultsArray,
cmap=my_cmap,
interpolation='none',
vmin=0.8 * np.min(self.ForcesMag2),
extent=[0, plotWidth, plotHeight, 0])
fig.colorbar(im,
ax=ax,
orientation='vertical',
label='Force Density [N/mm$^2$]',
alpha=0.5,
fraction=0.046)
plt.axis('scaled')
bbox_props = dict(boxstyle="round,pad=0.3",
fc="white",
ec="black",
lw=2)
position = list(csd.n_getPhasesCenters(self.vPhA, self.vPhB,
self.vPhC))
self.forces = [self.Fa, self.Fb, self.Fc]
for k, p in enumerate(['A', 'B', 'C']):
if (max_col - min_col >= max_row - min_row):
x = position[k][0] - min_col * self.dXmm
y = -(max_row - min_row) * self.dYmm
ha = "center"
va = "bottom"
scale_units = 'height'
bigger_size = (max_col - min_col) * self.dXmm
else:
y = position[k][1] - min_row * self.dYmm
x = -1.5 * (max_col - min_col) * self.dYmm
ha = "right"
va = "center"
scale_units = 'width'
bigger_size = (max_row - min_row) * self.dYmm
ax.text(x,
y,
"Phase {1}\n({0[0]:.0f},{0[1]:.0f})[N]".format(
self.forces[k], p),
ha=ha,
va=va,
rotation=0,
size=10,
bbox=bbox_props)
X = [position[i][0] - min_col * self.dXmm for i in range(3)]
Y = [position[i][1] - min_row * self.dYmm for i in range(3)]
U = [self.forces[i][0] for i in range(3)]
V = [self.forces[i][1] for i in range(3)]
maxForce = max([f.norm() for f in self.forces])
plt.quiver(X,
Y,
U,
V,
edgecolor='none',
facecolor='red',
linewidth=.5,
scale=2 * maxForce,
scale_units=scale_units,
width=.0001 * bigger_size)
conductors, total, phCon = csd.n_getConductors(XsecArr=self.XsecArr,
vPhA=self.vPhA,
vPhB=self.vPhB,
vPhC=self.vPhC)
bars = []
for bar in range(1, total + 1):
temp = csd.n_arrayVectorize(inputArray=conductors,
phaseNumber=bar,
dXmm=self.dXmm,
dYmm=self.dYmm)
bars.append(temp)
Fx_array = [x[0] for x in self.ForcesVec]
Fy_array = [-x[1] for x in self.ForcesVec]
resultsFx =\
csd.n_recreateresultsArray(elementsVector=self.elementsVector,
resultsVector=Fx_array,
initialGeometryArray=self.XsecArr)
resultsFy =\
csd.n_recreateresultsArray(elementsVector=self.elementsVector,
resultsVector=Fy_array,
initialGeometryArray=self.XsecArr)
for i, bar in enumerate(bars):
x, y = csd.n_getCenter(bar)
x -= min_col * self.dXmm
y -= min_row * self.dYmm
ax.text(x, y, '[{}]'.format(i), horizontalalignment='center')
Fx = 0
Fy = 0
for element in bar:
Fx += resultsFx[int(element[0]), int(element[1])]
Fy += resultsFy[int(element[0]), int(element[1])]
# Calculating bar perymiter - just for test nod needed in forces
perymiter = csd.n_perymiter(bar, self.XsecArr, self.dXmm,
self.dYmm)
print('Bar {0:02d}: F(x,y): ({1:06.2f}, {2:06.2f}) [N] pre: {3}'.
format(i, Fx, Fy, perymiter))
plt.show()