def sourceVortexPanel_solve(self, Vinduced, evaluationPoint='self'): ''' ''' # Defining collocation Point self.source_collocationPoint = collocationPoint(self.panelStart, self.panelEnd, self.normal) self.vortex_collocationPoint = collocationPoint(self.panelStart, self.panelEnd, -self.normal) # Number of collocation points n = np.shape(self.collocationPoint)[1] # Calculate the RHS - Neumann B.C [normal and tangent] self.sourceVortex_RHS_normal = source2D.RightHandSide(Vinduced, self.normal) self.sourceVortex_RHS_tangent = vortex2D.RightHandSide(Vinduced, self.tangent) # Total RHS self.sourceVortex_RHS = np.concatenate([self.sourceVortex_RHS_normal, self.sourceVortex_RHS_tangent]) # Calculate the influence Matrix # normal self.sourceVortex_A_normal = source2D.solve(self.source_collocationPoint, self.panelStart, self.panelEnd, self.normal) self.sourceVortex_B_normal = vortex2D.solve(self.vortex_collocationPoint, self.panelStart, self.panelEnd, self.normal) # tangent self.sourceVortex_A_tangent = source2D.solve(self.source_collocationPoint, self.panelStart, self.panelEnd, self.tangent) self.sourceVortex_B_tangent = vortex2D.solve(self.vortex_collocationPoint, self.panelStart, self.panelEnd, self.tangent) # Combined influence matrix self.sourceVortex_C = np.zeros((n*2,n*2)) #[[1,2],[3,4]] self.sourceVortex_C[:n,:n] = self.sourceVortex_A_normal # 1 self.sourceVortex_C[:n,n:] = self.sourceVortex_B_normal # 2 self.sourceVortex_C[n:,:n] = self.sourceVortex_A_tangent # 3 self.sourceVortex_C[n:,n:] = self.sourceVortex_B_tangent # 4 #start = time.time() # Solve the panel Menthod, combined B.Cs self.sourceVortex_SigmaGamma = np.linalg.solve(self.sourceVortex_C, self.sourceVortex_RHS) #print 'sourceVortexPanel:' + str(time.time() - start) #self.sourceVortex_SigmaGamma = np.linalg.lstsq(self.sourceVortex_C, self.sourceVortex_RHS) self.sourceVortex_sigma = self.sourceVortex_SigmaGamma[:n] self.sourceVortex_gamma = self.sourceVortex_SigmaGamma[n:] # To show no transpiration if evaluationPoint is 'self': evaluationPoint_source = self.source_collocationPoint evaluationPoint_vortex = self.vortex_collocationPoint else: evaluationPoint_source = evaluationPoint evaluationPoint_vortex = evaluationPoint # Calculate induced velocity on body self.sourceVortex_Vsorc = source2D.evaluate(self.sourceVortex_sigma, evaluationPoint_source, self.panelStart, self.panelEnd) self.sourceVortex_Vvort = vortex2D.evaluate(self.sourceVortex_gamma, evaluationPoint_vortex, self.panelStart, self.panelEnd) self.sourceVortex_V = self.sourceVortex_Vsorc + self.sourceVortex_Vvort
def vortexPanel_solve(self, Vinduced, evaluationPoint = 'self'): ''' Solve potential flow using vortex panels ''' # Defining collocationPoints: slightly inside self.vortex_collocationPoint = collocationPoint(self.panelStart,self.panelEnd, -self.normal) # inside the body # Calculate RHS - zero tangential self.vortex_RHS = vortex2D.RightHandSide(Vinduced, self.tangent) #start = time.time() # Calculate the influence matrix self.vortex_A = vortex2D.solve(self.vortex_collocationPoint, self.panelStart, self.panelEnd, self.tangent) #print 'vortex:' + str(time.time() - start) #start = time.time() # Solve the vortex Method. Ax=RHS self.vortex_gamma = np.linalg.solve(self.vortex_A, self.vortex_RHS) #print 'vortex:' + str(time.time() - start) #start = time.time() # To show no transpiration if evaluationPoint is 'self': evaluationPoint = self.vortex_collocationPoint # Calculate induced velocity on body self.vortex_V = vortex2D.evaluate(self.vortex_gamma, evaluationPoint, self.panelStart, self.panelEnd)
def sourcePanel_solve(self, Vinduced, evaluationPoint='self'): ''' Solve the panel problem ''' # Defining collocationPoint self.source_collocationPoint = collocationPoint(self.panelStart, self.panelEnd, self.normal) # + normal # Calculate RHS - Neumann B.C self.source_RHS = source2D.RightHandSide(Vinduced, self.normal) #start = time.time() # Calculate the influence matrix self.source_A = source2D.solve(self.source_collocationPoint, self.panelStart, self.panelEnd, self.normal) # Solve the panel Method. Equation: Ax = RHS. Solve for x self.source_sigma = np.linalg.solve(self.source_A, self.source_RHS) #print 'sourcePanel:' + str(time.time() - start) # To show no transpiration if evaluationPoint is 'self': evaluationPoint = self.source_collocationPoint start = time.time() # Calculate induced velocity on body self.source_V = source2D.evaluate(self.source_sigma, evaluationPoint, self.panelStart, self.panelEnd) print str(time.time() - start)
def __init__(self,*args): # Extracting initial data # Initializing the lists of variables self.name = [] self.length_geometry = [] self.length_panel = [] # Scanning through the 'args' and getting the data for data in args: # Extracting the global parameters of the body # Extracting initial data from the bodies self.name.append(data['body'].name) # body names self.length_geometry.append(data['body'].noPoints) # number of geometry points self.length_panel.append(data['body'].noPoints-1) # number of panel points # Initializing the arrays for storing all the data [reduce computational load] self.chord = np.zeros(len(args)) # 1-D array of chords self.local_pitch = np.zeros(len(args)) self.global_pitch= np.zeros(len(args)) self.location = np.zeros((2,len(args))) self.geometry = np.zeros((2,sum(self.length_geometry))) # x,y coordinates in row 0 and 1 self.panelStart = np.zeros((2,sum(self.length_panel))) self.panelEnd = np.zeros((2,sum(self.length_panel))) # Storing all the data # Pointer parameters i = 0 start_geometry = 0 start_panel = 0 # Looping through the available data for data in args: # Calculating the shape of 'sub array'. Finding the end point end_geometry = start_geometry + self.length_geometry[i] end_panel = start_panel + self.length_panel[i] # Storing all the data together into an array self.chord[i] = data['body'].chord self.local_pitch[i] = data['body'].local_pitch self.global_pitch[i]= data['global_pitch'] self.location[:,i] = np.array([data['location']]) # Transforming the points and vectors to global coordinates. self.geometry[:,start_geometry:end_geometry] = body2global(data['body'].geometry, self.global_pitch[i], self.location[:,i]) self.panelStart[:,start_panel:end_panel] = self.geometry[:,start_geometry:(end_geometry-1)] # starting points self.panelEnd[:,start_panel:end_panel] = self.geometry[:,(1+start_geometry):end_geometry] # Preparing for the next iteration start_geometry = end_geometry start_panel = end_panel i+=1 self.normal = normalVector(self.panelStart, self.panelEnd) self.tangent = tangentVector(self.panelStart, self.panelEnd) self.collocationPoint = (self.panelStart + self.panelEnd)/2 self.vortex_collocationPoint = collocationPoint(self.panelStart,self.panelEnd, -self.normal) # inside the body self.source_collocationPoint = collocationPoint(self.panelStart,self.panelEnd, self.normal) # inside the body