def readSettings(self):
self.L = float(self.lenght.get())
self.Icw = self.Icw_txt.get().split(';')
self.Icw = [float(x) for x in self.Icw]
self.desc_L.config(text='lenght: {:.0f} [mm]'.format(self.L))
self.desc_IcwA.config(text='Ia: {0[0]:.2f} [kA]'.format(self.Icw))
self.desc_IcwB.config(text='Ib: {0[1]:.2f} [kA]'.format(self.Icw))
self.desc_IcwC.config(text='Ic: {0[2]:.2f} [kA]'.format(self.Icw))
self.vPhA = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=1,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.vPhB = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=2,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.vPhC = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=3,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.elementsVector = np.concatenate((self.vPhA, self.vPhB, self.vPhC),
axis=0)
def readSettings(self):
# lets workout the current in phases as is defined
self.in_Ia = float(self.I[0]) * np.cos(
float(self.I[1]) * np.pi / 180) + float(self.I[0]) * np.sin(
float(self.I[1]) * np.pi / 180) * 1j
print("in Ia: {}".format(self.in_Ia))
self.in_Ib = float(self.I[2]) * np.cos(
float(self.I[3]) * np.pi / 180) + float(self.I[2]) * np.sin(
float(self.I[3]) * np.pi / 180) * 1j
print("in Ib: {}".format(self.in_Ib))
self.in_Ic = float(self.I[4]) * np.cos(
float(self.I[5]) * np.pi / 180) + float(self.I[4]) * np.sin(
float(self.I[5]) * np.pi / 180) * 1j
print("in Ic: {}".format(self.in_Ic))
self.vPhA = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=1,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.vPhB = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=2,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.vPhC = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=3,
dXmm=self.dXmm,
dYmm=self.dYmm)
# Lets put the all phases together
self.elementsPhaseA = len(self.vPhA)
self.elementsPhaseB = len(self.vPhB)
self.elementsPhaseC = len(self.vPhC)
if self.elementsPhaseA != 0 and self.elementsPhaseB != 0 and self.elementsPhaseC != 0:
self.elementsVector = np.concatenate(
(self.vPhA, self.vPhB, self.vPhC), axis=0)
elif self.elementsPhaseA == 0:
if self.elementsPhaseB == 0:
self.elementsVector = self.vPhC
elif self.elementsPhaseC == 0:
self.elementsVector = self.vPhB
else:
self.elementsVector = np.concatenate((self.vPhB, self.vPhC),
axis=0)
else:
if self.elementsPhaseB == 0 and self.elementsPhaseC == 0:
self.elementsVector = self.vPhA
elif self.elementsPhaseC == 0:
self.elementsVector = np.concatenate((self.vPhA, self.vPhB),
axis=0)
else:
self.elementsVector = np.concatenate((self.vPhA, self.vPhC),
axis=0)
def readSettings(self):
self.f = float(self.Freq_txt.get())
self.t = float(self.Temp_txt.get())
self.desc_f.config(text='Frequency: {:.2f} [Hz]'.format(self.f))
self.desc_t.config(text='Temperature: {:.2f} [degC]'.format(self.t))
self.vPhA = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=1,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.vPhB = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=2,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.vPhC = csd.n_arrayVectorize(inputArray=self.XsecArr,
phaseNumber=3,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.elementsPhaseA = len(self.vPhA)
self.elementsPhaseB = len(self.vPhB)
self.elementsPhaseC = len(self.vPhC)
if self.elementsPhaseA != 0 and self.elementsPhaseB != 0 and self.elementsPhaseC != 0:
self.elementsVector = np.concatenate(
(self.vPhA, self.vPhB, self.vPhC), axis=0)
elif self.elementsPhaseA == 0:
if self.elementsPhaseB == 0:
self.elementsVector = self.vPhC
elif self.elementsPhaseC == 0:
self.elementsVector = self.vPhB
else:
self.elementsVector = np.concatenate((self.vPhB, self.vPhC),
axis=0)
else:
if self.elementsPhaseB == 0 and self.elementsPhaseC == 0:
self.elementsVector = self.vPhA
elif self.elementsPhaseC == 0:
self.elementsVector = np.concatenate((self.vPhA, self.vPhB),
axis=0)
else:
self.elementsVector = np.concatenate((self.vPhA, self.vPhC),
axis=0)
def vectorizeTheArray(*arg):
"""
This function analyse the cross section array and returns vector of all set
(equal to 1) elements. This allows to minimize the size of further calculation
arrays only to active elements.
and for te moment do the all math for calculations.
"""
global elementsVector, resultsArray, resultsCurrentVector, frequency, powerLosses, resultsArrayPower, powerLossesVector
# Read the setup params from GUI
setParameters()
# lets check if there is anything in the xsection geom array
if np.sum(XSecArray) > 0:
# We get vectors for each phase`
elementsVectorPhA = csd.n_arrayVectorize(inputArray=XSecArray,
phaseNumber=1,
dXmm=dXmm,
dYmm=dYmm)
elementsVectorPhB = csd.n_arrayVectorize(inputArray=XSecArray,
phaseNumber=2,
dXmm=dXmm,
dYmm=dYmm)
elementsVectorPhC = csd.n_arrayVectorize(inputArray=XSecArray,
phaseNumber=3,
dXmm=dXmm,
dYmm=dYmm)
# From here is the rest of calulations
perymeterA = csd.n_perymiter(elementsVectorPhA, XSecArray, dXmm, dYmm)
perymeterB = csd.n_perymiter(elementsVectorPhB, XSecArray, dXmm, dYmm)
perymeterC = csd.n_perymiter(elementsVectorPhC, XSecArray, dXmm, dYmm)
# memorize the number of elements in each phase
elementsPhaseA = elementsVectorPhA.shape[0]
elementsPhaseB = elementsVectorPhB.shape[0]
elementsPhaseC = elementsVectorPhC.shape[0]
# Lets put the all phases togethrt
if elementsPhaseA != 0 and elementsPhaseB != 0 and elementsPhaseC != 0:
elementsVector = np.concatenate(
(elementsVectorPhA, elementsVectorPhB, elementsVectorPhC),
axis=0)
elif elementsPhaseA == 0:
if elementsPhaseB == 0:
elementsVector = elementsVectorPhC
elif elementsPhaseC == 0:
elementsVector = elementsVectorPhB
else:
elementsVector = np.concatenate(
(elementsVectorPhB, elementsVectorPhC), axis=0)
else:
if elementsPhaseB == 0 and elementsPhaseC == 0:
elementsVector = elementsVectorPhA
elif elementsPhaseC == 0:
elementsVector = np.concatenate(
(elementsVectorPhA, elementsVectorPhB), axis=0)
else:
elementsVector = np.concatenate(
(elementsVectorPhA, elementsVectorPhC), axis=0)
print(elementsVector.shape)
admitanceMatrix = np.linalg.inv(
csd.n_getImpedanceArray(
csd.n_getDistancesArray(elementsVector),
freq=frequency,
dXmm=dXmm,
dYmm=dYmm,
temperature=temperature,
))
# Let's put here some voltage vector
vA = np.ones(elementsPhaseA)
vB = np.ones(elementsPhaseB) * (-0.5 + (np.sqrt(3) / 2) * 1j)
vC = np.ones(elementsPhaseC) * (-0.5 - (np.sqrt(3) / 2) * 1j)
voltageVector = np.concatenate((vA, vB, vC), axis=0)
# Lets calculate the currebt vector as U = ZI >> Z^-1 U = I
# and Y = Z^-1
# so finally I = YU - as matrix multiplication goes
currentVector = np.matmul(admitanceMatrix, voltageVector)
# And now we need to get solution for each phase to normalize it
currentPhA = currentVector[0:elementsPhaseA]
currentPhB = currentVector[elementsPhaseA:elementsPhaseA +
elementsPhaseB:1]
currentPhC = currentVector[elementsPhaseA + elementsPhaseB:]
# Normalize the solution vectors fr each phase
currentPhA = currentPhA / csd.n_getComplexModule(np.sum(currentPhA))
currentPhB = currentPhB / csd.n_getComplexModule(
np.sum(currentPhB)) # *(-0.5 + (np.sqrt(3)/2)*1j))
currentPhC = currentPhC / csd.n_getComplexModule(
np.sum(currentPhC)) # *(-0.5 - (np.sqrt(3)/2)*1j))
# Print out he results currents in each phase
print("sumy: " + str(csd.n_getComplexModule(np.sum(currentPhA))) +
" : " + str(csd.n_getComplexModule(np.sum(currentPhB))) + " : " +
str(csd.n_getComplexModule(np.sum(currentPhC))) + " : ")
print("sumy: " + str((np.sum(currentPhA))) + " : " +
str((np.sum(currentPhB))) + " : " + str((np.sum(currentPhC))) +
" : ")
print("Current vector:")
print(currentVector.shape)
print("Current vector elements module:")
getMod = np.vectorize(csd.n_getComplexModule)
resultsCurrentVector = np.concatenate(
(currentPhA, currentPhB, currentPhC), axis=0)
resultsCurrentVector = getMod(resultsCurrentVector)
resistanceVector = csd.n_getResistanceArray(elementsVector,
dXmm=dXmm,
dYmm=dYmm,
temperature=temperature)
resultsCurrentVector *= curentRMS
powerLossesVector = resistanceVector * resultsCurrentVector**2
powerLosses = np.sum(powerLossesVector)
# Power losses per phase
powPhA = np.sum(powerLossesVector[0:elementsPhaseA])
powPhB = np.sum(powerLossesVector[elementsPhaseA:elementsPhaseA +
elementsPhaseB:1])
powPhC = np.sum(powerLossesVector[elementsPhaseA + elementsPhaseB:])
print("power losses: {} [W] \n phA: {}[W]\n phB: {}[W]\n phC: {}[W]".
format(powerLosses, powPhA, powPhB, powPhC))
print("Phases perymeters:\nA: {}mm\nB: {}mm\nC: {}mm\n".format(
perymeterA, perymeterB, perymeterC))
powerLosses = [powerLosses, powPhA, powPhB, powPhC]
# Converting results to form of density
powerLossesVector /= dXmm * dYmm
# Converting resutls to current density
resultsCurrentVector /= dXmm * dYmm
# Recreating the solution to form of cross section array
resultsArray = csd.n_recreateresultsArray(
elementsVector=elementsVector,
resultsVector=resultsCurrentVector,
initialGeometryArray=XSecArray,
)
resultsArrayPower = csd.n_recreateresultsArray(
elementsVector=elementsVector,
resultsVector=powerLossesVector,
initialGeometryArray=XSecArray,
)
# Showing the results
showResults()
def powerAnalysis(self):
self.readSettings()
admitanceMatrix = np.linalg.inv(
csd.n_getImpedanceArray(csd.n_getDistancesArray(
self.elementsVector),
freq=self.f,
dXmm=self.dXmm,
dYmm=self.dYmm,
temperature=self.t,
lenght=self.lenght))
# Let's put here some voltage vector
Ua = complex(1, 0)
Ub = complex(-0.5, np.sqrt(3) / 2)
Uc = complex(-0.5, -np.sqrt(3) / 2)
vA = np.ones(self.elementsPhaseA) * Ua
vB = np.ones(self.elementsPhaseB) * Ub
vC = np.ones(self.elementsPhaseC) * Uc
voltageVector = np.concatenate((vA, vB, vC), axis=0)
# Initial solve
# Main equation solve
currentVector = np.matmul(admitanceMatrix, voltageVector)
# And now we need to get solution for each phase to normalize it
currentPhA = currentVector[0:self.elementsPhaseA]
currentPhB = currentVector[self.elementsPhaseA:self.elementsPhaseA +
self.elementsPhaseB]
currentPhC = currentVector[self.elementsPhaseA + self.elementsPhaseB:]
# Bringin each phase current to the assumer Irms level
Ia = np.sum(currentPhA)
Ib = np.sum(currentPhB)
Ic = np.sum(currentPhC)
# expected Ia Ib Ic as symmetrical ones
exIa = self.in_Ia
exIb = self.in_Ib
exIc = self.in_Ic
# print('***VOLTAGES****')
# print(Ua, Ub, Uc)
# ratios of currents will give us new voltages for phases
Ua = Ua * (exIa / Ia)
Ub = Ub * (exIb / Ib)
Uc = Uc * (exIc / Ic)
# for debug:
print('***recalculated votages****')
print(Ua, Ub, Uc)
print('***XXXXX****')
# So we have now new volatges, lets solve again with them
vA = np.ones(self.elementsPhaseA) * Ua
vB = np.ones(self.elementsPhaseB) * Ub
vC = np.ones(self.elementsPhaseC) * Uc
voltageVector = np.concatenate((vA, vB, vC), axis=0)
# Initial solve
# Main equation solve
currentVector = np.matmul(admitanceMatrix, voltageVector)
# And now we need to get solution for each phase to normalize it
currentPhA = currentVector[0:self.elementsPhaseA]
currentPhB = currentVector[self.elementsPhaseA:self.elementsPhaseA +
self.elementsPhaseB]
currentPhC = currentVector[self.elementsPhaseA + self.elementsPhaseB:]
# Bringin each phase current to the assumer Irms level
Ia = np.sum(currentPhA)
Ib = np.sum(currentPhB)
Ic = np.sum(currentPhC)
# end of second solve!
# for debug:
print('***pre calibration current results****')
print(Ia, Ib, Ic)
print(Ia + Ib + Ic)
print('***XXXXX****')
# Now we normalize up to the expecter self.I - just a polish
# as we are almost there with the previous second solve for new VOLTAGES
modIa = np.abs(Ia)
modIb = np.abs(Ib)
modIc = np.abs(Ic)
# for debug:
# print(modIa, modIb, modIc)
currentPhA *= (self.in_Ia / modIa)
currentPhB *= (self.in_Ib / modIb)
currentPhC *= (self.in_Ic / modIc)
Ia = np.sum(currentPhA)
Ib = np.sum(currentPhB)
Ic = np.sum(currentPhC)
getMod = np.vectorize(csd.n_getComplexModule)
resultsCurrentVector = np.concatenate(
(currentPhA, currentPhB, currentPhC), axis=0)
# for debug
# print(resultsCurrentVector)
#
resultsCurrentVector = getMod(resultsCurrentVector)
resistanceVector = csd.n_getResistanceArray(self.elementsVector,
dXmm=self.dXmm,
dYmm=self.dYmm,
temperature=self.t,
lenght=self.lenght)
# This is the total power losses vector
powerLossesVector = resistanceVector * resultsCurrentVector**2
# This are the total power losses
powerLosses = np.sum(powerLossesVector)
# Power losses per phase
powPhA = np.sum(powerLossesVector[0:self.elementsPhaseA])
powPhB = np.sum(
powerLossesVector[self.elementsPhaseA:self.elementsPhaseA +
self.elementsPhaseB:1])
powPhC = np.sum(powerLossesVector[self.elementsPhaseA +
self.elementsPhaseB:])
self.console(
'power losses: {:.2f} [W] \n phA: {:.2f}[W]\n phB: {:.2f}[W]\n phC: {:.2f}[W]'
.format(powerLosses, powPhA, powPhB, powPhC))
self.powerLosses = [powerLosses, powPhA, powPhB, powPhC]
# Doing analysis per bar
# Checking for the pabrs - separate conductor detecton
conductors, total, self.phCon = csd.n_getConductors(
XsecArr=self.XsecArr,
vPhA=self.vPhA,
vPhB=self.vPhB,
vPhC=self.vPhC)
# self.phCon is the list of number of conductors per phase
print(self.phCon)
# Going thru the detected bars and preparing the arrays for each of it
self.bars = []
for bar in range(1, total + 1):
temp = csd.n_arrayVectorize(inputArray=conductors,
phaseNumber=bar,
dXmm=self.dXmm,
dYmm=self.dYmm)
self.bars.append(temp)
# Converting resutls to current density
self.resultsCurrentVector = resultsCurrentVector / (self.dXmm *
self.dYmm)
# Recreating the solution to form of cross section array
self.resultsArray = csd.n_recreateresultsArray(
elementsVector=self.elementsVector,
resultsVector=self.resultsCurrentVector,
initialGeometryArray=self.XsecArr)
self.powerResultsArray = csd.n_recreateresultsArray(
elementsVector=self.elementsVector,
resultsVector=powerLossesVector,
initialGeometryArray=self.XsecArr)
self.isSolved = True
# Calculationg the eqivalent single busbar representative object parameters
# This will be moved to a separate function place in the future
# Getting the data:
perymeterA = csd.n_perymiter(self.vPhA, self.XsecArr, self.dXmm,
self.dYmm)
perymeterB = csd.n_perymiter(self.vPhB, self.XsecArr, self.dXmm,
self.dYmm)
perymeterC = csd.n_perymiter(self.vPhC, self.XsecArr, self.dXmm,
self.dYmm)
# temperature coeff of resistance
alfa = 0.004
# assuming the thickness of equivalent bar is a=10mm
a = 10
b_phA = (perymeterA - 2 * a) / 2
b_phB = (perymeterB - 2 * a) / 2
b_phC = (perymeterC - 2 * a) / 2
# calculating equivalent gamma in 20C - to get the same power losses in DC calculations RI^2
gamma_phA = (1 + alfa * (self.t - 20)) * 1 * float(
self.I[0])**2 / (a * 1e-3 * b_phA * 1e-3 * powPhA)
gamma_phB = (1 + alfa * (self.t - 20)) * 1 * float(
self.I[2])**2 / (a * 1e-3 * b_phB * 1e-3 * powPhB)
gamma_phC = (1 + alfa * (self.t - 20)) * 1 * float(
self.I[4])**2 / (a * 1e-3 * b_phC * 1e-3 * powPhC)
print('Equivalent bars for DC based thermal analysis: \n')
print('Eqivalent bar phA is: {}mm x {}mm at gamma: {}'.format(
a, b_phA, gamma_phA))
print('Eqivalent bar phB is: {}mm x {}mm at gamma: {}'.format(
a, b_phB, gamma_phB))
print('Eqivalent bar phC is: {}mm x {}mm at gamma: {}'.format(
a, b_phC, gamma_phC))
print('({},{},1000, gamma={})'.format(a, b_phA, gamma_phA))
print('({},{},1000, gamma={})'.format(a, b_phB, gamma_phB))
print('({},{},1000, gamma={})'.format(a, b_phC, gamma_phC))
# solving the temperatures
self.calcTempRise()
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()