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()