def knnClassifier(train, test, k, kdtree=False, weight=naiveWeight):
predictions = test
probs = []
kdTreeKnn = None
kNeighbors = None
kWeights = None
if kdtree:
kdTreeKnn = KdTree(train)
for i in range(len(test)):
for j in range(len(test[0])):
predictions[i][j] = test[i][j]
if kdtree:
kdTreeKnn.knn(k, predictions[i])
kNeighbors = kdTreeKnn.knnResults
kWeights = kdTreeKnn.knnDistances
else:
kNeighbors, kWeights = knn_naive(k, train, predictions[i])
kWeights = weight(kWeights)
sumWeights = 0
sumPred = 0
for j in range(k):
sumWeights += kWeights[j]
sumPred += kWeights[j] * kNeighbors[j][-1]
predictions[i][-1] = round(sumPred / sumWeights)
probs.append(list(predictions[i]))
probs[i][-1] = sumPred / sumWeights
return (predictions, probs)
def test_is_fully_contained(self):
"""Test if all the leafs of a region is being returned"""
region_x_1 = [None, None]
region_y_1 = [None, None]
self.assertFalse(
KdTree._is_fully_contained(self.kd_tree_even, region_x_1,
region_y_1, self.query_x, self.query_y))
region_x_2 = [2, 3]
region_y_2 = [2, None]
self.assertFalse(
KdTree._is_fully_contained(self.kd_tree_even, region_x_2,
region_y_2, self.query_x, self.query_y))
region_x_3 = [2, 3]
region_y_3 = [2, 5]
self.assertFalse(
KdTree._is_fully_contained(self.kd_tree_even, region_x_3,
region_y_3, self.query_x, self.query_y))
region_x_4 = [2, 3]
region_y_4 = [2, 3]
self.assertTrue(
KdTree._is_fully_contained(self.kd_tree_even, region_x_4,
region_y_4, self.query_x, self.query_y))
def test_get_index_median(self):
"""Test if the median returned is correct"""
# ODD CASE
self.assertEqual(
KdTree._get_index_median(self.kd_tree_odd, self.points_odd), 3)
# EVEN CASE
self.assertEqual(
KdTree._get_index_median(self.kd_tree_even, self.points_even), 2)
def test_sort_points(self):
"""Test if the sorted list is like expected"""
# ODD CASE
result_odd_x, result_odd_y = KdTree._sort_points(
self.kd_tree_odd, self.points_odd)
self.assertListEqual(self.points_odd_sorted_x, result_odd_x)
self.assertListEqual(self.points_odd_sorted_y, result_odd_y)
# EVEN CASE
result_even_sorted_x, result_even_sorted_y = KdTree._sort_points(
self.kd_tree_even, self.points_even)
self.assertListEqual(self.points_even_sorted_x, result_even_sorted_x)
self.assertListEqual(self.points_even_sorted_y, result_even_sorted_y)
class NearestNeighbor:
def train(self, X, y):
self.tree = KdTree(X, y)
self.X = X
self.y = y
def predict(self, X, k=5, method='tree'):
count = 0
yPredict = np.zeros(X.shape[0])
for i in range(X.shape[0]):
if method == 'tree':
values = self.tree.kNN(X[i], k)
c = Counter([pair[0].value for pair in values]).most_common()
yPredict[i] = c[0][0]
else:
a = np.abs(self.X - X[i])
s = np.sum(a, axis=1)
y_idxs = np.argsort(s)[:k]
c = Counter(self.y[y_idxs]).most_common()
yPredict[i] = c[0][0]
count += 1
print('{:}: {:,}/28,000'.format(yPredict[i], count))
return yPredict
def test_report_sub_tree(self):
"""Test if the points returned from a region are correct"""
expected_tree = [[3, 1], [1, 2], [4, 5], [2, 6], [5, 7]]
result = KdTree._report_sub_tree(self.kd_tree_even,
self.node_level_1_1)
self.assertListEqual(result, expected_tree)
def buildNodalTree(self, sNodes):
log.info("---start buildNodalTree---")
raise Exception('DEPRECATED...buildNodalTree in mapLoads.py')
sys.stdout.flush()
#print "type(aCentroids)=%s type(sCentroids)=%s" %(type(aCentroids), type(sCentroids))
self.nodalTree = KdTree('node', sNodes, nClose=self.nCloseNodes)
log.info("---finish buildNodalTree---")
sys.stdout.flush()
def buildCentroidTree(self, sCentroids):
"""
sCentroids - dict of structural centroids
id: element id
"""
log.info("---start buildCentroidTree---")
sys.stdout.flush()
#print "type(aCentroids)=%s type(sCentroids)=%s" %(type(aCentroids), type(sCentroids))
msg = 'Element '
for (id,sCentroid) in sorted(iteritems(sCentroids)):
msg += "%s " % id
log.info(msg + '\n')
self.centroidTree = KdTree('element', sCentroids, nClose=self.nCloseElements)
log.info("---finish buildCentroidTree---")
sys.stdout.flush()
def test_build(self):
"""Test if we are building correctly the Kd-Tree"""
kd_tree_generated_by_function = KdTree(self.points)
kd_tree_generated_by_hand = self.kd_tree
self.validate_node(kd_tree_generated_by_function.root_node,
kd_tree_generated_by_hand.root_node)
def main():
number_of_points = 1000
points = generate_points(number_of_points)
kd_tree = KdTree(points)
# Query to search points
query_x = [400, 500]
query_y = [300, 400]
region_x = [None, None]
region_y = [None, None]
search_result = kd_tree.search(query_x, query_y, region_x, region_y)
print("The query:")
print("X = [%d, %d]" % (query_x[0], query_x[1]))
print("Y = [%d, %d]" % (query_y[0], query_y[1]))
print("Returns:")
print(search_result)
print("######################################################################################################\n")
def test_search(self):
"""Test if the search result is correct"""
region_x_1 = [None, None]
region_y_1 = [None, None]
query_x_1 = [1, 6]
query_y_1 = [1, 4]
expected_result_1 = [[3, 1], [1, 2], [6, 3]]
result_1 = KdTree.search(self.kd_tree, query_x_1, query_y_1,
region_x_1, region_y_1)
self.assertListEqual(result_1, expected_result_1)
region_x_2 = [None, None]
region_y_2 = [None, None]
query_x_2 = [2, 8]
query_y_2 = [4, 8]
expected_result_2 = [[4, 5], [2, 6], [5, 7], [8, 4], [7, 8]]
result_2 = KdTree.search(self.kd_tree, query_x_2, query_y_2,
region_x_2, region_y_2)
self.assertListEqual(result_2, expected_result_2)
def group_tweets_by_state(tweets):
"""Return a dictionary that aggregates tweets by their nearest state center.
The keys of the returned dictionary are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> len(two_tweets_by_state)
2
>>> california_tweets = two_tweets_by_state['CA']
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
center_state_dict = {}
centers = []
for state, polygons in us_states.items():
center = find_state_center(polygons)
centers.append(center)
center_state_dict[center] = state
state_centers = KdTree(centers)
tweets_by_state = {}
for tweet in tweets:
location = tweet_location(tweet)
nearest_state_center = state_centers.nearest_neigbour(
location).location
nearest_state = center_state_dict[nearest_state_center]
if nearest_state not in tweets_by_state:
tweets_by_state[nearest_state] = []
tweets_by_state[nearest_state].append(tweet)
return tweets_by_state
def test_has_intersection(self):
"""Test if a point has intersection with a query"""
point_1 = 3
query = [1, 3]
self.assertFalse(
KdTree._has_intersection(self.kd_tree_even, point_1, query))
point_2 = 2
query = [1, 3]
self.assertTrue(
KdTree._has_intersection(self.kd_tree_even, point_2, query))
point_3 = 1
query = [1, 3]
self.assertTrue(
KdTree._has_intersection(self.kd_tree_even, point_3, query))
point_4 = 0
query = [1, 3]
self.assertFalse(
KdTree._has_intersection(self.kd_tree_even, point_4, query))
def test_split_points(self):
"""Test if the splitted list is like expected"""
# ODD CASE CUT BY X ON THE SORTED Y LIST
left_points_1 = [[3, -3], [1, 2], [2, 4], [-1, 5]]
right_points_1 = [[6, 1]]
result_left_points_odd_1, result_right_points_odd_1 = \
KdTree._split_points(self.kd_tree_odd, self.points_odd_sorted_y, [3, -3], 0)
self.assertListEqual(result_left_points_odd_1, left_points_1)
self.assertListEqual(result_right_points_odd_1, right_points_1)
# EVEN CASE CUT BY X ON THE SORTED Y LIST
left_points_2 = [[1, 2], [2, 4], [-1, 5]]
right_points_2 = [[3, -3]]
result_left_points_even_1, result_right_points_even_1 = \
KdTree._split_points(self.kd_tree_even, self.points_even_sorted_y, [2, 4], 0)
self.assertListEqual(result_left_points_even_1, left_points_2)
self.assertListEqual(result_right_points_even_1, right_points_2)
# ODD CASE CUT BY Y ON THE SORTED X LIST
left_points_3 = [[1, 2], [2, 4], [3, -3], [6, 1]]
right_points_3 = [[-1, 5]]
result_left_points_odd_2, result_right_points_odd_2 = \
KdTree._split_points(self.kd_tree_odd, self.points_odd_sorted_x, [2, 4], 1)
self.assertListEqual(result_left_points_odd_2, left_points_3)
self.assertListEqual(result_right_points_odd_2, right_points_3)
# EVEN CASE CUT BY Y ON THE SORTED X LIST
left_points_4 = [[1, 2], [2, 4], [3, -3]]
right_points_4 = [[-1, 5]]
result_left_points_even_2, result_right_points_even_2 = \
KdTree._split_points(self.kd_tree_even, self.points_even_sorted_x, [2, 4], 1)
self.assertListEqual(result_left_points_even_2, left_points_4)
self.assertListEqual(result_right_points_even_2, right_points_4)
def test_is_valid_leaf(self):
"""Test if a node is a valid leaf"""
node_1 = Node()
node_1.point = [2, 4]
node_2 = Node()
node_2.point = [3, -3]
node_3 = Node()
node_3.point = [3, 4]
node_4 = Node()
node_4.point = [-1, 6]
self.assertTrue(
KdTree._is_valid_leaf(self.kd_tree_even, node_1, self.query_x,
self.query_y))
self.assertFalse(
KdTree._is_valid_leaf(self.kd_tree_even, node_2, self.query_x,
self.query_y))
self.assertTrue(
KdTree._is_valid_leaf(self.kd_tree_even, node_3, self.query_x,
self.query_y))
self.assertFalse(
KdTree._is_valid_leaf(self.kd_tree_even, node_4, self.query_x,
self.query_y))
class LoadMapping(object):
def __init__(self, aeroModel, structuralModel, configpath='', workpath=''):
self.nCloseElements = 30
self.configpath = configpath
self.workpath = workpath
self.aeroModel = aeroModel
self.structuralModel = structuralModel
self.mappingMatrix = {}
self.mapfile = 'mapfile.in'
self.bdffile = 'fem.bdf'
self.Sref = 1582876. # inches
self.Lref = 623. # inch
self.xref = 268.
#@entryExit
def setOutput(self,bdffile='fem.bdf', loadCase=1):
self.bdffile = bdffile
self.loadCase = loadCase
#@entryExit
def set_flight_condition(self, pInf=499.3, qInf=237.885):
self.pInf = pInf
self.qInf = qInf #1.4/2.*pInf*Mach**2.
#@entryExit
def loadMappingMatrix(self):
infile = open(self.mapfile,'r')
self.mappingMatrix = cPickle.loads(infile)
infile.close()
#@entryExit
def save_mapping_matrix(self):
outString = cPickle.dumps(self.mappingMatrix)
outfile = open(self.mapfile, 'wb')
outfile.write(outString)
outfile.close()
#@entryExit
def getPressure(self, Cp):
"""
Caculates the pressure based on:
Cp = (p-pInf)/qInf
"""
p = Cp * self.qInf + self.pInf
#p = Cp*self.qInf # TODO: for surface with atmospheric pressure inside
return p
#@entryExit
def mapLoads(self):
"""
Loops thru the unitLoad mappingMatrix and multiplies by the
total force F on each panel to calculate the PLOAD that will be
printed to the output file.
Also, performs a sum of Forces & Moments to verify the aero loads.
"""
log.info("---starting mapLoads---")
self.bdf = open(self.bdffile, 'wb')
#self.buildMappingMatrix()
log.info("self.loadCase = %s" % self.loadCase)
self.loadCases = {self.loadCase:{}}
#self.loadCases = {self.loadCase={}, }
momentCenter = array([self.xref, 0., 0.])
sumMoments = array([0., 0., 0.])
sumForces = array([0., 0., 0.])
sys.stdout.flush()
for aEID, distribution in iteritems(self.mappingMatrix):
#print "aEID = ",aEID
#print "***distribution = ", distribution
sumLoad = 0.
area = self.aeroModel.Area(aEID)
normal = self.aeroModel.Normal(aEID)
Cp = self.aeroModel.Cp(aEID)
#print "Cp = ",Cp
#print "area[%s]=%s" % (aEID, area)
p = self.getPressure(Cp)
centroid = self.aeroModel.Centroid(aEID)
r = momentCenter - centroid
F = area * p
Fn = F * normal
sumMoments += cross(r, Fn)
sumForces += Fn
for sNID, percentLoad in sorted(iteritems(distribution)):
sumLoad += percentLoad
Fxyz = Fn * percentLoad # negative sign is to be consistent with nastran
self.addForce(sNID, Fxyz)
#print("Fxyz = ",Fxyz)
#print("type(structuralModel) = ", type(self.structuralModel))
#comment = 'percentLoad=%.2f' % percentLoad
#self.structuralModel.writeLoad(self.bdf, self.loadCase, sNID,
# Fxyz[0], Fxyz[1], Fxyz[2], comment)
#msg = '$ End of aEID=%s sumLoad=%s p=%s area=%s F=%s normal=%s\n' % (aEID, sumLoad, p, area, F, normal)
#self.bdf.write(msg)
self.writeLoads() # short version of writing loads...
self.bdf.close()
log.info("pInf=%g [psi]; qInf= %g [psi]" % (self.pInf, self.qInf))
log.info("sumForcesFEM [lb] = %s" % ListPrint(sumForces))
log.info("sumMomentsFEM [lb-ft] = %s" % ListPrint(sumMoments/12.)) # divided by 12 to have moments in lb-ft
Cf = sumForces /(self.Sref * self.qInf)
log.info("Cf = %s" % ListPrint(Cf))
Cm = sumMoments / (self.Sref * self.qInf * self.Lref)
log.info("Cm = %s" % ListPrint(Cm*12.)) # multiply by 12 to nondimensionalize ??? maybe 144...
#self.bdf.write('$***********\n')
log.info("wrote loads to %r" % self.bdffile)
log.info("---finished mapLoads---")
#@entryExit
def writeLoads(self):
"""writes the load in BDF format"""
log.info("---starting writeLoads---")
self.bdf.write('$ ***writeLoads***\n')
self.bdf.write('$ nCloseElements=%s\n' % self.nCloseElements)
for loadCase, loads in sorted(iteritems(self.loadCases)):
log.info(" loadCase = %s" % loadCase)
for (sNID, Fxyz) in sorted(iteritems(loads)):
self.structuralModel.write_load(self.bdf, loadCase, sNID, *Fxyz)
log.info("finished writeLoads---")
def addForce(self, sNID, Fxyz):
try:
self.loadCases[self.loadCase][sNID] += Fxyz
except KeyError:
self.loadCases[self.loadCase][sNID] = Fxyz
#@entryExit
def buildCentroids(self, model, eids=None):
centroids = {}
if eids is None:
eids = model.ElementIDs()
for eid in eids:
centroid = model.Centroid(eid)
if centroid is not None:
centroids[eid] = centroid
return centroids
#@entryExit
def buildNodalTree(self, sNodes):
log.info("---start buildNodalTree---")
raise Exception('DEPRECATED...buildNodalTree in mapLoads.py')
sys.stdout.flush()
#print "type(aCentroids)=%s type(sCentroids)=%s" %(type(aCentroids), type(sCentroids))
self.nodalTree = KdTree('node', sNodes, nClose=self.nCloseNodes)
log.info("---finish buildNodalTree---")
sys.stdout.flush()
#@entryExit
def buildCentroidTree(self, sCentroids):
"""
sCentroids - dict of structural centroids
id: element id
"""
log.info("---start buildCentroidTree---")
sys.stdout.flush()
#print "type(aCentroids)=%s type(sCentroids)=%s" %(type(aCentroids), type(sCentroids))
msg = 'Element '
for (id,sCentroid) in sorted(iteritems(sCentroids)):
msg += "%s " % id
log.info(msg + '\n')
self.centroidTree = KdTree('element', sCentroids, nClose=self.nCloseElements)
log.info("---finish buildCentroidTree---")
sys.stdout.flush()
#@entryExit
def parseMapFile(self, mapFilename='mappingMatrix.new.out'):
"""
This is used for rerunning an analysis quickly (cuts out building the mapping matrix ~1.5 hours).
1 {8131: 0.046604568185355716, etc...}
"""
log.info("---starting parseMapFile---")
mappingMatrix = {}
log.info('loading mapFile=%r' % mapFilename)
mapFile = open(mapFilename,'r')
lines = mapFile.readlines()
mapFile.close()
for (i, line) in enumerate(lines[1:]): # dont read the first line, thats a header line
line = line.strip()
#print "line = %r" % line
(aEID, dictLine) = line.split('{') # splits the dictionary from the aEID
aEID = int(aEID)
#assert i == int(aEID)
# time to parse a dictionary with no leading brace
distribution = {}
mapSline = dictLine.strip('{}, ').split(',')
for pair in mapSline:
(sEID, weight) = pair.strip(' ').split(':')
sEID = int(sEID)
weight = float(weight)
distribution[sEID] = weight
mappingMatrix[aEID] = distribution
#log.info("mappingKeys = %s" %(sorted(mappingMatrix.keys())))
self.runMapTest(mappingMatrix)
log.info("---finished parseMapFile---")
return mappingMatrix
#@entryExit
def runMapTest(self, mappingMatrix, mapTestFilename='mapTest.out'):
"""
Checks to see what elements loads were mapped to.
Ideally, all elements would have a value of 1.0, given equal area.
Instead, each element should have a value of area[i].
"""
mapTest = {}
for (aEID, distribution) in sorted(iteritems(mappingMatrix)):
for (sEID,weight) in distribution.items():
if sEID in mapTest:
mapTest[sEID] += weight
else:
mapTest[sEID] = weight
mapOut = open(mapTestFilename, 'wb')
mapOut.write('# sEID weight\n')
for sEID, weight in sorted(iteritems(mapTest)):
mapOut.write("%s %s\n" % (sEID, weight))
mapOut.close()
def map_loads_mp_func(self, aEID, aModel):
aElement = aModel.Element(aEID)
(aArea, aCentroid, aNormal) = aModel.get_element_properties(aEID)
percentDone = i / nAeroElements * 100
pSource = aCentroid
distribution = self.pierce_elements(aCentroid, aEID, pSource, aNormal)
#distribution = self.poorMansMapping(aCentroid, aEID, pSource, aNormal)
self.mappingMatrix[aEID] = distribution
#@entryExit
def build_mapping_matrix(self, debug=False):
"""
Skips building the matrix if it already exists
A mapping matrix translates element ID to loads on the nearby
strucutral nodes.
eid,distribution
"""
if self.mappingMatrix != {}:
return self.mappingMatrix
log.info("---starting buildMappingMatrix---")
#print "self.mappingMatrix = ",self.mappingMatrix
if os.path.exists('mappingMatrix.new.out'):
self.mappingMatrix = self.parseMapFile('mappingMatrix.new.out')
log.info("---finished buildMappingMatrix based on mappingMatrix.new.out---")
sys.stdout.flush()
return self.mappingMatrix
log.info("...couldn't find 'mappingMatrix.new.out' in %r, so going to make it..." % os.getcwd())
# this is the else...
log.info("creating...")
aModel = self.aeroModel
sModel = self.structuralModel
#aNodes = aModel.getNodes()
#sNodes = sModel.getNodes()
#treeObj = Tree(nClose=5)
#tree = treeObj.buildTree(aNodes,sNodes) # fromNodes,toNodes
aElementIDs = aModel.ElementIDs() # list
sElementIDs = sModel.getElementIDsWithPIDs() # list
sElementIDs2 = sModel.ElementIDs() # list
msg = "there are no internal elements in the structural model?\n ...len(sElementIDs)=%s len(sElementIDs2)=%s" % (len(sElementIDs), len(sElementIDs2))
assert sElementIDs != sElementIDs2, msg
log.info("maxAeroID=%s maxStructuralID=%s sElements=%s" % (max(aElementIDs), max(sElementIDs),len(sElementIDs2)))
log.info("buildCentroids - structural")
sCentroids = self.buildCentroids(sModel, sElementIDs)
self.buildCentroidTree(sCentroids)
#self.buildNodalTree(sNodes)
log.info("buildCentroids - aero")
aCentroids = self.buildCentroids(aModel)
mapFile = open('mappingMatrix.out', 'wb')
mapFile.write('# aEID distribution (sEID: weight)\n')
t0 = time()
nAeroElements = float(len(aElementIDs))
log.info("---start piercing---")
if debug:
log.info("nAeroElements = %s" % nAeroElements)
tEst = 1.
tLeft = 1.
percent_done = 0.
if 1:
num_cpus = 4
pool = mp.Pool(num_cpus)
result = pool.imap(self.map_loads_mp_func, [(aEID, aModel) for aEID in aElementIDs ])
for j, return_values in enumerate(result):
aEID, distribution = return_values
#self.mappingMatrix[aEID] = distribution
mapFile.write('%s %s\n' % (aEID, distribution))
pool.close()
pool.join()
else:
for (i, aEID) in enumerate(aElementIDs):
if i % 1000 == 0 and debug:
log.debug(' piercing %sth element' % i)
log.debug("tEst=%g minutes; tLeft=%g minutes; %.3f%% done" %(tEst, tLeft, percent_done))
sys.stdout.flush()
aElement = aModel.Element(aEID)
(aArea, aCentroid, aNormal) = aModel.get_element_properties(aEID)
percentDone = i / nAeroElements * 100
if debug:
log.info('aEID=%s percentDone=%.2f aElement=%s aArea=%s aCentroid=%s aNormal=%s' %(aEID,percentDone,aElement,aArea,aCentroid,aNormal))
pSource = aCentroid
(distribution) = self.pierce_elements(aCentroid, aEID, pSource, aNormal)
#(distribution) = self.poorMansMapping(aCentroid, aEID, pSource, aNormal)
self.mappingMatrix[aEID] = distribution
mapFile.write('%s %s\n' % (aEID, distribution))
dt = (time() - t0) / 60.
tEst = dt * nAeroElements / (i + 1) # dtPerElement*nElements
tLeft = tEst - dt
percent_done = dt / tEst * 100.
mapFile.close()
log.info("---finish piercing---")
self.runMapTest(self.mappingMatrix)
#print "mappingMatrix = ", self.mappingMatrix
log.info("---finished buildMappingMatrix---")
sys.stdout.flush()
return self.mappingMatrix
def poor_mans_mapping(self, aCentroid, aEID, pSource, normal):
"""
distributes load without piercing elements
based on distance
"""
(sElements, sDists) = self.centroidTree.getCloseElementIDs(aCentroid)
log.debug("aCentroid = %s" % aCentroid)
log.debug("sElements = %s" % sElements)
log.debug("sDists = %s" % ListPrint(sDists))
setNodes = set([])
sModel = self.structuralModel
for sEID in sElements:
sNodes = sModel.get_element_nodes(sEID)
setNodes.union(set(sNodes))
nIDs = list(setNodes)
sNodes = sModel.getNodeIDLocations(nIDs)
weights = self.get_weights(closePoint, sNodes)
distribution = self.create_distribution(nIDs, weights)
return distribution
def pierce_elements(self, aCentroid, aEID, pSource, normal):
"""
Pierces *1* element with a ray casted from the centroid/pSource
in the direction of the normal vector of an aerodynamic triangle
A 1
\/ \
/ * \
2---\-3
\
B
*P = A+(B-A)*t
"""
#direction = -1. # TODO: direction of normal...?
(sElements, sDists) = self.centroidTree.getCloseElementIDs(aCentroid)
log.info("aCentroid = %s" % aCentroid)
log.info("sElements = %s" % sElements)
log.info("sDists = %s" % ListPrint(sDists))
#(nearbySElements, nearbyDistances) = sElements
piercedElements = []
for sEID, sDist in zip(sElements, sDists):
#print "aEID=%s sEID=%s" % (aEID, sEID)
(sArea, sNormal, sCentroid) = self.structuralModel.get_element_properties(sEID)
sNodes = self.structuralModel.get_element_nodes(sEID)
nNodes = len(sNodes)
pEnd = pSource + normal * 10.
#pEnd2 = pSource - normal * 10.
if nNodes == 3: # TODO: is this enough of a breakdown?
(sA, sB, sC) = sNodes
#pEnd = pSource+normal*10.
tuv = pierce_plane_vector(sA, sB, sC, pSource, pEnd, piercedElements)
#tuv2= pierce_plane_vector(sA, sB, sC, pSource, pEnd2, piercedElements)
elif nNodes == 4:
(sA, sB, sC, sD) = sNodes
tuv = pierce_plane_vector(sA, sB, sC, pSource, pEnd, piercedElements)
#tuv2= pierce_plane_vector(sA, sB, sC, pSource, pEnd2, piercedElements)
#self.pierceTriangle(sA, sB, sC, sCentroid, sNormal, piercedElements)
#self.pierceTriangle(sA, sC, sD, sCentroid, sNormal, piercedElements)
else:
raise RuntimeError('invalid element; nNodes=%s' % nNodes)
t1, u1, v1 = tuv
#t2, u2, v2 = tuv2
isInside = False
#if self.isInside(u1, v1) or self.isInside(u2, v2):
if self.is_inside(u1, v1):
isInside = True
#pIntersect = pSource + (pEnd - pSource) * t1
pIntersect = pEnd * t1 +pSource * (1 - t1)
#P = A + (B - A) * t
tuv = pierce_plane_vector(sA, sB, sC, pSource, pIntersect, piercedElements)
#print "t,u,v=", tuv
piercedElements.append([sEID, pIntersect, u1, v1, sDist])
#t = min(t1, t2)
#print "t1=%6.3g t2=%6.3g" % (t1, t2)
#if isInside:
#print "*t[%s]=%6.3g u1=%6.3g v1=%6.3g u2=%6.3g v2=%6.3g" %(sEID,t,u1,v1,u2,v2)
#else:
#print " t[%s]=%6.3g u1=%6.3g v1=%6.3g u2=%6.3g v2=%6.3g" %(sEID,t,u1,v1,u2,v2)
#if isInside:
#print "*t[%s]=%6.3g u1=%6.3g v1=%6.3g d=%g" %(sEID,t1,u1,v1,sDist)
#else:
#print " t[%s]=%6.3g u1=%6.3g v1=%6.3g d=%g" %(sEID,t1,u1,v1,sDist)
log.info("avgDist = %g" % mean(sDists))
(piercedElements, nPiercings) = self.fix_piercings(sElements, piercedElements)
distribution = self.distribute_unit_load(aEID, piercedElements, nPiercings)
return (distribution)
def fix_piercings(self, sElements, piercedElements):
if len(piercedElements) == 0:
piercedElements = sElements
#for sEID in sElements:
#piercedElements.append([sEID, None]) # TODO: why a None?
nPiercings = 0
else:
dists = []
for element in piercedElements:
log.info("element = %s" % element)
dist = element[-1]
log.info("dist = %s\n" % dist)
dists.append(dist)
iSort = argsort(dists)
#print "iSort = ", iSort
piercedElements2 = []
for iElement in iSort:
piercedElements2.append(piercedElements[iElement])
#piercedElements = piercedElements[iSort]
#for element in piercedElements:
#print "element = ",element
#print "dist = ",dist, '\n'
nPiercings = len(piercedElements)
return (piercedElements, nPiercings)
def is_inside(self, u, v):
if (0.<=u and u<=1.) and (0.<=v and v<=1.):
return True
return False
def create_distribution(self, nIDs, weights):
"""
Maps alist of structural nodes, and weights for a given aero element
Takes the weights that are applied to a node and distributes them to the
structural nodes
"""
distribution = {}
for nid,weight in zip(nIDs, weights):
distribution[nid] = weight
return distribution
def get_weights(self, closePoint, nodes):
# TODO: new weights?
#(n1, n2, n3) = list(setNodes)
#n = piercedPoint
#(w1, w2, w3) = getTriangleWeights(n, n1, n2, n3)
weights = shepard_weight(closePoint, nodes)
return weights
def distribute_unit_load(self, aEID, piercedElements, nPiercings):
"""
distribute unit loads to nearby nodes
piercedElements is a list of piercings
piercing = [sEID,P,u,v] or [sEID]
where
sEID - the structural element ID
P - point p was pierced
u - u coordinate
v - v coordinate
if nPiercings==0, all the nearby nodes will recieve load
"""
aModel = self.aeroModel
sModel = self.structuralModel
#print("piercedElements = ", piercedElements)
nIDs = []
if nPiercings == 0:
#assert len(nPiercings)==1,'fix me...'
#print("nPiercings=0 distributing load to closest nodes...u=%g v=%g" %(-1,-1))
log.debug("nPiercings=0 distributing load to closest nodes...")
for sEID in piercedElements:
nIDs += sModel.get_element_node_ids(sEID)
#print "nIDs1 = ",nIDs
nIDs = list(set(nIDs))
log.debug("nIDs2 = %s" % nIDs)
aCentroid = aModel.Centroid(aEID)
nodes = sModel.getNodeIDLocations(nIDs)
#print "nodes = ", nodes
weights = self.get_weights(aCentroid, nodes)
distribution = self.create_distribution(nIDs, weights)
log.debug("element aEID=%s sEID=%s weights=%s" % (aEID, sEID, ListPrint(weights)))
#print("distribution = ", distribution)
#print("nIDs = ", nIDs)
#print("weights = ", weights)
#print("nodes = ", nodes)
#print("nPiercings = ", nPiercings)
else:
log.info("mapping load to actual element...")
nClose = 3 # number of elements to map to
closeElements = piercedElements[:nClose]
setCloseNodes = set([])
for closeElement in reversed(closeElements):
log.info("closeElement = %s" % closeElement)
#sEID, pIntersect, u1, v1, sDist
(sEID, P, u, v, sDist) = closeElement # TODO: bug here...???
#closePoint = closeElement[1]
#closeElement = sEID
closePoint = P
# get list of nearby structural nodes
setElementNodes = set(sModel.get_element_node_ids(sEID))
setCloseNodes = setCloseNodes.union(setElementNodes)
# setup for weighted average
nIDs = list(setCloseNodes)
sNodes = sModel.getNodeIDLocations(nIDs)
weights = self.get_weights(closePoint, sNodes)
distribution = self.create_distribution(nIDs, weights)
log.info("element aEID=%s sEID=%s weights=%s" %(aEID, sEID, ListPrint(weights)))
log.info("-------------------------\n")
sys.stdout.flush()
return (distribution)
def Normal(self, A, B, C):
a = B - A
b = C - A
normal = Normal(a, b)
return normal
def train(self, X, y):
self.tree = KdTree(X, y)
self.X = X
self.y = y
def setUp(self):
"""This is called immediately before calling every test method"""
# ODD CASE
self.points_odd = [[2, 4], [-1, 5], [3, -3], [6, 1], [1, 2]]
self.points_odd_sorted_x = [[-1, 5], [1, 2], [2, 4], [3, -3], [6, 1]]
self.points_odd_sorted_y = [[3, -3], [6, 1], [1, 2], [2, 4], [-1, 5]]
self.kd_tree_odd = KdTree(self.points_odd)
# EVEN CASE
self.points_even = [[2, 4], [-1, 5], [3, -3], [1, 2]]
self.points_even_sorted_x = [[-1, 5], [1, 2], [2, 4], [3, -3]]
self.points_even_sorted_y = [[3, -3], [1, 2], [2, 4], [-1, 5]]
self.kd_tree_even = KdTree(self.points_even)
# QUERY TO SEARCH IN THE KD-TREE
self.query_x = [1, 3]
self.query_y = [2, 4]
# BUILDING A KD-TREE
# LEVEL 4 KD_TREE
self.node_level_4_1 = Node()
self.node_level_4_1.type = NodeType.LEAF
self.node_level_4_1.level = 4
self.node_level_4_1.cut = None
self.node_level_4_1.point = [3, 1]
self.node_level_4_1.left_child = None
self.node_level_4_1.right_child = None
self.node_level_4_2 = Node()
self.node_level_4_2.type = NodeType.LEAF
self.node_level_4_2.level = 4
self.node_level_4_2.cut = None
self.node_level_4_2.point = [1, 2]
self.node_level_4_2.left_child = None
self.node_level_4_2.right_child = None
# LEVEL 3 KD_TREE
self.node_level_3_1 = Node()
self.node_level_3_1.type = NodeType.INTERNAL
self.node_level_3_1.level = 3
self.node_level_3_1.cut = 1
self.node_level_3_1.point = None
self.node_level_3_1.left_child = self.node_level_4_1
self.node_level_3_1.right_child = self.node_level_4_2
self.node_level_3_2 = Node()
self.node_level_3_2.type = NodeType.LEAF
self.node_level_3_2.level = 3
self.node_level_3_2.cut = None
self.node_level_3_2.point = [4, 5]
self.node_level_3_2.left_child = None
self.node_level_3_2.right_child = None
self.node_level_3_3 = Node()
self.node_level_3_3.type = NodeType.LEAF
self.node_level_3_3.level = 3
self.node_level_3_3.cut = None
self.node_level_3_3.point = [2, 6]
self.node_level_3_3.left_child = None
self.node_level_3_3.right_child = None
self.node_level_3_4 = Node()
self.node_level_3_4.type = NodeType.LEAF
self.node_level_3_4.level = 3
self.node_level_3_4.cut = None
self.node_level_3_4.point = [5, 7]
self.node_level_3_4.left_child = None
self.node_level_3_4.right_child = None
self.node_level_3_5 = Node()
self.node_level_3_5.type = NodeType.LEAF
self.node_level_3_5.level = 3
self.node_level_3_5.cut = None
self.node_level_3_5.point = [6, 3]
self.node_level_3_5.left_child = None
self.node_level_3_5.right_child = None
self.node_level_3_6 = Node()
self.node_level_3_6.type = NodeType.LEAF
self.node_level_3_6.level = 3
self.node_level_3_6.cut = None
self.node_level_3_6.point = [8, 4]
self.node_level_3_6.left_child = None
self.node_level_3_6.right_child = None
self.node_level_3_7 = Node()
self.node_level_3_7.type = NodeType.LEAF
self.node_level_3_7.level = 3
self.node_level_3_7.cut = None
self.node_level_3_7.point = [7, 8]
self.node_level_3_7.left_child = None
self.node_level_3_7.right_child = None
self.node_level_3_8 = Node()
self.node_level_3_8.type = NodeType.LEAF
self.node_level_3_8.level = 3
self.node_level_3_8.cut = None
self.node_level_3_8.point = [9, 9]
self.node_level_3_8.left_child = None
self.node_level_3_8.right_child = None
# LEVEL 2 KD_TREE
self.node_level_2_1 = Node()
self.node_level_2_1.type = NodeType.INTERNAL
self.node_level_2_1.level = 2
self.node_level_2_1.cut = 3
self.node_level_2_1.point = None
self.node_level_2_1.left_child = self.node_level_3_1
self.node_level_2_1.right_child = self.node_level_3_2
self.node_level_2_2 = Node()
self.node_level_2_2.type = NodeType.INTERNAL
self.node_level_2_2.level = 2
self.node_level_2_2.cut = 2
self.node_level_2_2.point = None
self.node_level_2_2.left_child = self.node_level_3_3
self.node_level_2_2.right_child = self.node_level_3_4
self.node_level_2_3 = Node()
self.node_level_2_3.type = NodeType.INTERNAL
self.node_level_2_3.level = 2
self.node_level_2_3.cut = 6
self.node_level_2_3.point = None
self.node_level_2_3.left_child = self.node_level_3_5
self.node_level_2_3.right_child = self.node_level_3_6
self.node_level_2_4 = Node()
self.node_level_2_4.type = NodeType.INTERNAL
self.node_level_2_4.level = 2
self.node_level_2_4.cut = 7
self.node_level_2_4.point = None
self.node_level_2_4.left_child = self.node_level_3_7
self.node_level_2_4.right_child = self.node_level_3_8
# LEVEL 1 KD_TREE
self.node_level_1_1 = Node()
self.node_level_1_1.type = NodeType.INTERNAL
self.node_level_1_1.level = 1
self.node_level_1_1.cut = 5
self.node_level_1_1.point = None
self.node_level_1_1.left_child = self.node_level_2_1
self.node_level_1_1.right_child = self.node_level_2_2
self.node_level_1_2 = Node()
self.node_level_1_2.type = NodeType.INTERNAL
self.node_level_1_2.level = 1
self.node_level_1_2.cut = 4
self.node_level_1_2.point = None
self.node_level_1_2.left_child = self.node_level_2_3
self.node_level_1_2.right_child = self.node_level_2_4
# LEVEL 0 KD_TREE
self.root_node = Node()
self.root_node.type = NodeType.INTERNAL
self.root_node.level = 0
self.root_node.cut = 5
self.root_node.point = None
self.root_node.left_child = self.node_level_1_1
self.root_node.right_child = self.node_level_1_2
self.points = [[1, 2], [2, 6], [3, 1], [4, 5], [5, 7], [6, 3], [7, 8],
[8, 4], [9, 9]]
self.kd_tree = KdTree(self.points)
self.kd_tree.root_node = self.root_node
