def on_release(event):
global HotkeyStatus, fatigueLevel
if HotkeyStatus == 0:
global List_of_Lists
threading.Thread(target=Writer.rawfileWriter().write_rawfile,
args=(
'Data/RawKeystokes.tsv',
event,
'Released',
datetime.now(),
fatigueLevel,
)).start()
for list in List_of_Lists:
if list[0] == event:
list[2] = str(datetime.now())
list[3] = fatigueLevel
thred = threading.Thread(target=Writer.Write().write_file,
args=(
list,
fileLocation,
))
thred.start()
List_of_Lists.remove(list)
elif HotkeyStatus == 1:
List_of_Lists = []
def CollectIOC(outFormat):
url = "https://otx.alienvault.com/api/v1/pulses/activity"
while True: # page loop
header = {
'X-OTX-API-KEY':
'<----------------API-KEY---------------------->' # Write API Key
}
r = requests.get(url=url, headers=header)
result = r.json()
if r.status_code == 200:
for i in range(0, len(result["results"])): # results loop
indicatorsLength = len(
result["results"][i]["indicators"]) # indicators loop
for j in range(0, indicatorsLength):
if outFormat == 1:
Writer.jsonWriter(i, j, result) # json output
else:
Writer.csvWriter(i, j, result) # csv output
if r.json()["next"] is None: #next page control
print("IOC Hunter Finished") #finish
break
else:
url = r.json()["next"] # go to next page
else:
print("IOC Hunter Finished") #finish
break
def __init__(self):
self.root = Tk()
self.north = Entry(self.root)
self.direction = 0
self.distance = 0
self.pen_button = Button()
self.color_button = Button()
self.eraser_button = Button()
self.north_button = Button()
self.south_button = Button()
self.west_button = Button()
self.east_button = Button()
self.square_button = Button()
self.circle_button = Button()
self.triangle_button = Button()
self.up = Button()
self.down = Button()
self.clear_canvas = Button()
self.choose_size_button = Scale()
self.c = Canvas()
self.x = 0
self.y = 0
self.entry = 0.0
self.line_width = 1
self.button = Button()
self.north = Entry()
self.entry = self.north.get()
self.line_width = self.choose_size_button.get()
self.pen_state = True
# so can be used in every mehotds.
self.file = Writer("TKInterDrawer_Result.txt")
def open():
display(" ≈≈ WELCOME TO ≈≈ ")
print("")
display(" ≈≈ D-CIPHERED! ≈≈ ")
print("")
time.sleep(2)
command = ''
while command != "exit":
print("•")
print("-To create an Encrypted message type 'create' ")
print("•")
print("-To Decrypt a message type 'read' ")
print("•")
print("-Finally, To exit type 'exit'\n")
command = input(">")
if "create" in command.casefold():
Writer.new(userName, key)
elif "read" in command.casefold():
print("One moment please while we fetch your top secret messages!")
Reciver.mailQueue(userName, key)
decrypt = Reciver.decipher()
display(decrypt)
# time.sleep(len(decrypt)/4) ///uncomment this string to add time to the display of your messages
print("\n")
con = input("when finished reading type anything to continue \n >")
elif "exit" in command.casefold():
sys.exit(0)
else:
print("im sorry that doesnt seem to be a command.")
def write(self, msg):
self.writelock.acquire()
try:
if debugWrite: print "Write:", msg
Writer.write(self.wfile, Writer.contract(msg, self.extension.serialize))
self.wfile.write('\n')
self.wfile.flush()
finally:
self.writelock.release()
def main2():
person_tweets = []
count = 0
for f in os.listdir("/home/kevin/Documents/Epic/NER/Input/Gold/CrfGold/Person/"):
count += 1
print f
print count
person_tweets = Writer.load_tweets_crf_gold(f.split("/")[-1], "/home/kevin/Documents/Epic/NER/Input/Gold/CrfGold/", "Person")
Writer.write_tweets_crf_gold(person_tweets, f, "/home/kevin/Documents/Epic/NER/Input/Gold/CrfGoldTest/", ["Person"])
def run():
global graph
filename = "AISearchfile017.txt"
global tour
global length
global pQueue
global n
distances = Parser.loadSearchFile(filename) # Distance matrix
n = len(distances) # No. of nodes
graph = Parser.createGraph(distances)
pTour = PartialTourModG() # Create the empty partial tour
heapq.heappush(pQueue, pTour) # Add initial partial tour to the frontier
while (True):
if not pQueue: # Check if Frontier is Empty
return
else:
pTour = heapq.heappop(pQueue) # Get the most optimal pTour
# outPath = []
# outPath.extend(pTour.path)
# print outPath
# print "g: " + str(pTour.g) + " - h: " + str(pTour.h)
# print
if len(pTour.path) < (n - 1): # If not a full tour
if pTour.endNode == "": # If pTour = []
children = [Node(str(i), 0) for i in range(n)]
else:
children = graph.get(pTour.endNode) # Get all children
expand(pTour, children) # Expand the frontier
else: # If a full tour, i.e ensuring goal node not expanded
tour = pTour.path
tour.append(pTour.endNode)
tour = [str(int(i) + 1) for i in tour] # start at 1 not 0
for node in graph.get(str(int(tour[0]) - 1)): # F*****G -1
if node.name == pTour.endNode:
length = pTour.lth + node.dist
break
Writer.writeTourFile(filename, n, length, tour)
tourString = ",".join(str(t) for t in tour)
print "Start Location: " + tour[0] + " - Distance: " + str(
length) + " - Tour: " + tourString
def Calucalte(type1):
fileOperator = Writer("Scores.txt")
scores = fileOperator.readFile()
scores = removeX(scores)
ScoresTuples = tuplize(scores)
scoresSummation = 0
unitsSummation = 0
for scoresTuple in ScoresTuples:
score = scoresTuple[0] * 5
unit = scoresTuple[1]
GPA = 0
if (type1 == True):
if (score >= 0 and score < 60):
GPA = 0
elif (score >= 60 and score < 67):
GPA = 1
elif (score >= 67 and score <= 69):
GPA = 1.3
elif (score >= 70 and score < 73):
GPA = 1.7
elif (score >= 73 and score < 77):
GPA = 2
elif (score >= 77 and score < 80):
GPA = 2.3
elif (score >= 80 and score < 84):
GPA = 2.7
elif (score >= 84 and score < 87):
GPA = 3
elif (score >= 87 and score < 90):
GPA = 3.3
elif (score >= 90 and score < 94):
GPA = 3.7
elif (score >= 94 and score <= 100):
GPA = 4.0
print("Normal: " + str(scoresTuple[0]) + " |Score : " + str(score) + " | Unit : " + str(unit) + " | GPA: " + str(GPA))
scoresSummation += GPA * unit
unitsSummation += unit
return scoresSummation/unitsSummation
def run(self):
print("[log]Generator start...")
while (not globcfg.event.is_set()):
print(
"[log]currentRunThread: Reader= {readCount}, Writer= {writeCount}"
.format(readCount=globcfg.currentRunThreadCount['Reader'],
writeCount=globcfg.currentRunThreadCount['Writer']))
genterate_time = getRandomInterval(globcfg.lamGen)
globcfg.generateTime_lock.acquire()
globcfg.generate_time_globalCopy = genterate_time
globcfg.generateTime_lock.release()
globcfg.event.wait(genterate_time)
choice = random.randint(0, 1)
# generate a new thread
if (choice):
print("[log]Generate thread {number} : {name}".format(
number=globcfg.threadNumber, name="Reader"))
self.gui.change_state("R", globcfg.threadNumber,
self.gui.nowhere, self.gui.scheduling)
globcfg.waitingList.append(
Reader.Reader(self.book, self.lock, globcfg.threadNumber,
self.gui)) #new Reader
else:
print("[log]Generate thread {number} : {name}".format(
number=globcfg.threadNumber, name="Writer"))
self.gui.change_state("W", globcfg.threadNumber,
self.gui.nowhere, self.gui.scheduling)
globcfg.waitingList.append(
Writer.Writer(self.book, self.lock, globcfg.threadNumber,
self.gui)) #new Writer
globcfg.threadNumber += 1
def __str__(self):
try:
stringWriter = Writer.StringWriter()
self.writeDeclaration(stringWriter)
return str(stringWriter)
except:
return self.name
def WriteGmadFiles(self):
""" Write the gmad files for all tests in the Tests directory.
"""
_os.chdir('Tests')
for test in self._tests:
writer = Writer.Writer()
writer.WriteTests(test)
if not self._testNames.__contains__(test.Component):
self._testNames[test.Component] = []
self._testNames[test.Component].extend(writer._fileNamesWritten[test.Component])
_os.chdir('../')
def main():
filename = "AISearchfile012.txt"
distances = Parser.loadSearchFile(filename) # Distance matrix
numNodes = len(distances)
graph = Parser.createGraph(distances)
shortestLength = sys.maxsize
shortestTour = []
for i in range(numNodes):
tour, length = nn(graph, numNodes, str(i))
if length < shortestLength:
shortestLength = length
shortestTour = tour
print shortestTour
print shortestLength
Writer.writeTourFile(filename, numNodes, shortestLength, shortestTour)
def Check_Availability():
if not path.exists(fileLocation):
f = open(fileLocation, "w")
f.close()
firstList = ['key', 'keydown_time', 'keyup_time', 'fatigue level']
thread1 = threading.Thread(target=Writer.Write().write_file,
args=(
firstList,
fileLocation,
))
thread1.start()
def on_save_entries( self, selection ):
dialog = Gtk.FileChooserDialog(
"Save generated names",
None,
Gtk.FileChooserAction.SAVE,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT),
)
response = dialog.run()
if response == Gtk.ResponseType.ACCEPT:
filename = dialog.get_filename()
def store_iterator():
for row in self.store_:
yield( row[0], row[1] )
Writer.writeLexiconFromIterator( filename, store_iterator() )
elif response == Gtk.ResponseType.CANCEL:
dialog.destroy()
return None
dialog.destroy()
return filename
def GenerateSubgraph(name, outputPath):
s2file = path.join(outputPath, str(name)+'_s2.csv')
s3file = path.join(outputPath, str(name)+'_s3.csv')
s4file = path.join(outputPath, str(name)+'_s4.csv')
Writer.outputGraph(s2file, follower, 2, name)
Writer.outputGraph(s3file, follower, 3, name)
Writer.outputGraph(s4file, follower, 4, name)
def GenerateSubgraph(name, outputPath):
s2file = path.join(outputPath, str(name) + '_s2.csv')
s3file = path.join(outputPath, str(name) + '_s3.csv')
s4file = path.join(outputPath, str(name) + '_s4.csv')
Writer.outputGraph(s2file, follower, 2, name)
Writer.outputGraph(s3file, follower, 3, name)
Writer.outputGraph(s4file, follower, 4, name)
def __init__(self, fileName):
self.fileName = fileName
self.cfgfname = 'cfg.json'
self.cfg = {}
self.branches = {}
self.out = Writer.Writer(
os.path.join('output',
fileName[:-2] + '_tranformed.ll')) # output file
self.branchLabel = 0 #
self.branch_blocks = {}
self.isVisited = {}
self.TB_st = {}
self.FB_st = {}
self.debug = False
def write_entity_test(verbose):
relative_file_path = "../../resources/sql/accountSchema.sql"
file_contents = Reader.open_file(relative_file_path)
parser = Reader.SQL_Parser(file_contents)
table_name = parser.parse_table()
table_attributes = parser.parse_attributes()
t = Table.Table(table_name, file_contents, table_attributes)
w = Writer.Entity_Writer(t)
w.write_entity("some_file")
return 0
def on_press(event):
global HotkeyStatus, fatigueLevel
if HotkeyStatus == 0:
setFatigueLevel()
threading.Thread(target=Writer.rawfileWriter().write_rawfile,
args=(
'Data/RawKeystokes.tsv',
event,
'Pressed',
datetime.now(),
fatigueLevel,
)).start()
Check_Availability()
global List_of_Lists
if not isExist(List_of_Lists, event):
List_of_Lists.append(list([event, str(datetime.now()), '', '']))
def main():
theInputPath = os.getcwd()
theOutputPath = os.path.join(os.getcwd(), 'Output')
os.makedirs(theOutputPath)
# theDocumentPath = os.path.join(theInputPath, 'WallE.dae')
# theDocumentPath = os.path.join(theInputPath, 'Samples/Cylinder.dae')
# theDocumentPath = os.path.join(theInputPath, 'Samples/F1.dae')
theDocumentPath = os.path.join(theInputPath, 'Samples/Cube.dae')
theTree = etree.parse(theDocumentPath)
theRootElement = OneOrThrow(
theTree.xpath("/NS:COLLADA", namespaces=Collada.Parser.NS))
theParser = Collada.Parser()
doc = theParser.DocumentFactory(None, None, theRootElement)
doc.dump()
for node in doc.walk():
if isinstance(node, Collada.Source):
print 'Source:', node.id, node.vbo.signature.hexdigest()
node.vbo.write(theOutputPath)
elif isinstance(node, Collada.Mesh):
print 'Mesh:', node.id, node.indices.signature.hexdigest()
if node.indices:
node.indices.write(theOutputPath)
theLibrary = []
for l in doc.libraries:
theLibrary.extend(l.children)
theLibrary = [
o for o in theLibrary if not isinstance(o, Collada.VisualScene)
]
theLibrary = [o for o in theLibrary if o.id is not None]
d = {
'root': doc.scene.visualScene.resolve(),
'library': dict([(o.id, o) for o in theLibrary]),
}
s = Writer.MyJSONEncoder(indent=2).encode(d)
file(os.path.join(theOutputPath, 'Output.json'), 'w').write(s)
def write():
writer = Writer()
argc = len(sys.argv)
if argc < 4:
print("Expecting data file(s) and output paths")
return False
for i in range(2, argc - 1):
writer.load(sys.argv[i])
writer.write(sys.argv[argc - 1])
return True
class ArgumentSourceReader(AbstractSourceReader):
results = Writer("SourceReader_Result.txt")
def go(self):
result = ArgumentParser.parse(self, '')
if result == 'g':
print('graphics')
self.results.writeToFile("Graphics")
elif result == 't':
self.results.writeToFile("Running Turtle Command")
TurtlePrompt().cmdloop()
elif result == 'k':
self.results.writeToFile("Running TKInter Drawer")
TkinterDrawer().start()
elif result == 'e':
self.results.writeToFile("Exiting program")
exit()
else:
self.results.writeToFile(
"Graphics from else as arguments were wrong")
print('graphics')
def ParserMatriz(self, configuracion, matriz):
error =''
self.posicionLista = self.inicializarLista()
for i in range (0,5):
for j in range (0,4):
self.posicionLista[i][j] = self.variablesGUI[ matriz[i][j] ]
print (self.posicionLista)
error = self.validarMatriz()
if error == '':
if configuracion == 'inicial':
self.posicionInicial = copy.deepcopy(self.posicionLista)
writer = Writer() #se escribe en el txt file
writer.writeConfiguracion('inicial', self.posicionInicial)
elif configuracion == 'final':
self.posicionFinal = copy.deepcopy(self.posicionLista)
writer = Writer() #se escribe en el txt file
writer.writeConfiguracion('final', self.posicionInicial)
return error
def main():
totalFile = 0
students = Reader.__readStudentList__("CES3063_Fall2020_rptSinifListesi.XLS")
if os.name == "posix":
polls = Reader.__readAnswerFileNames__(os.getcwd() + "/Answers")
Reader.__readPollFileNames__(os.getcwd() + "/Polls", students,totalFile) # we will read student answers with this func
elif os.name == "nt":
polls = Reader.__readAnswerFileNames__(os.getcwd() + "\Answers")
Reader.__readPollFileNames__(os.getcwd() + "\Polls", students,totalFile) # we will read student answers with this func
Analyzer.__findAttendancePolls__(students, "Are you attending this lecture")
Analyzer.__findPollsAndChangeKey__(students, polls)
Analyzer.__findStudentAnswers__(students, polls)
Statistic.__answerCounts__(students, polls)
Writer.__export__(students, polls)
Writer.__globalFile__(students,polls)
Writer.__Attendance__(students,polls)
from ParSite import *
from Writer import *
if __name__ == '__main__':
print("http://", input('http://'))
http = ParSite()
http.html_doc('http://')
data = Writer()
data.csv_writer(data)
#data = link.get(get.html('https://33pingvina.ru'))
runValueIteration = ValueIteration.ValueIteration(stateList, actionList,
decayRate,
convergeThreshold,
maxIterationStep)
createPolicyFromValue = ValueIteration.PolicyFromValue(
stateList, actionList, decayRate)
runQLearning = QLearning.QLearning(alpha, gamma, epsilon,
segmentTotalNumber, stateList,
actionList,
transitionFromStateAndAction)
print('finish setting function', time.time() - time0)
trainWolfPolicy = TrainWolfPolicyValueIteration(stateList,
transitionProbabilityDict,
createRewardDict,
runValueIteration,
createPolicyFromValue)
# trainWolfPolicy = TrainWolfPolicyQLearning(stateList, createRewardDict, runQLearning)
wolfPolicy = trainWolfPolicy()
# print(wolfPolicy)
print('finish training policy', time.time() - time0)
print('begin saving policy, please wait')
Writer.savePolicyToPkl(wolfPolicy, savePolicyFilename)
# Writer.savePolicyToNpy(wolfPolicy, savePolicyFilename)
# Writer.savePolicyToJson(wolfPolicy, savePolicyFilename)
print('finish saving policy, mission complete', time.time() - time0)
# loadWolfPolicy=klepto.archives.file_archive(savePolicyFilename+'.json')
# print(loadWolfPolicy.archive[((1,0),(0,1))])
fout.close()
print "static finish"
#mutual retweets of the author of the tweet is instance related
start = time.time()
edge_feat_file = path.join(trainPath, 'edge_cotreweet.csv')
f = open(edge_feat_file, 'w')
for node1, node2 in relations:
feat_list = []
for ID in tweet_list:
authorID = Processor.GetAuthor(ID, tweet_info_path)
edge_feat = Processor.GetEdgeFeat(node1, node2, authorID, mutual_path, tweet_info_path)
if edge_feat > 0:
feat_list += ["%s:%s" % (ID, edge_feat)]
f.write("%s_%s,%s\n" % (node1, node2, ",".join(feat_list)))
f.close()
print time.time()-start, " complete edge feature extraction, start node feature extraction"
nodes = [int(line.strip()) for line in open(nodefile)]
#user only feature are static, other features are associated with instance
tag=''
for node in nodes:
pool = []
node_feat_file = path.join(nodeFeatPath, str(node)+'.txt')
for ID in tweet_list:
tag, node_feat = Collect.GetTrainData(node, ID, tag, follower_dict, tweet_info_path, user_path, mutual_path)
pool += [node_feat]
Writer.outputFeature(node_feat_file, pool)
def GenerateSubgraph(name, outputPath):
s2file = path.join(outputPath, str(name)+'_s2.csv')
s3file = path.join(outputPath, str(name)+'_s3.csv')
s4file = path.join(outputPath, str(name)+'_s4.csv')
Writer.outputGraph(s2file, follower, 2, name)
Writer.outputGraph(s3file, follower, 3, name)
Writer.outputGraph(s4file, follower, 4, name)
follower = defaultdict(list)
rank_list = []
for line in open(networkfile):
linelist = line.strip().split()
user = int(linelist[0])
if len(linelist) < 2:
continue
follower[user] = [int(item) for item in linelist[1].split(',')]
rank_list.append( (user, len(follower[user])) )
rank_list = sorted(rank_list, key=lambda item:item[1], reverse=True)
allfile = path.join(outputPath, 'all_1000.csv')
Writer.outputGraph(allfile, follower, -1)
select = [0, 100, 200, 300, 400, 500, 600, 700, 800, 900]
for rank in select:
print rank_list[rank]
GenerateSubgraph(rank_list[rank][0], outputPath)
class Domain(object):
'''
variable:
self.width
self.height
self.nCellsX
self.nCellsY
self.X
self.Y
self.hx # cell size in x-direction
self.hy # cell size in y-direction
self.nodes
self.cells
self.particles
self.analysisControl
self.plotControl
self.outputControl
self.Re
self.v0
self.time = 0.0
self.plot
self.writer
self.motion ... manufactured solution for testing
self.particleUpdateScheme ... the timeIntegrator
self.lastWrite ... time of the last output
self.lastPlot ... time of the last plot
self.recordParticleTrace = False
methods:
def __init__(self, width=1., height=1., nCellsX=2, nCellsY=2)
def __str__(self)
def setTimeIntegrator(self, integrator)
def setMotion(self, motion)
def setBoundaryConditions(self)
def setPlotInterval(self, dt)
def setWriteInterval(self, dt)
def setAnalysis(self, doInit, solveVstar, solveP, solveVtilde, solveVenhanced, updatePosition, updateStress)
def getAnalysisControl(self)
def setInitialState(self)
def setParameters(self, Re, density, velocity)
def runAnalysis(self, maxtime=1.0)
def runSingleStep(self, dt=1.0)
def initStep(self)
def solveVstar(self, dt)
def solveP(self, dt)
def solveVtilde(self, dt)
def solveVenhanced(self, dt)
def updateParticleStress(self)
def updateParticleMotion(self)
def findCell(self, x)
def createParticles(self, n, m) # Default particle creator that generates particles in all cells
def createParticlesMID(self, n, m) # Particle creator that generates particle only in the middle cell
def createParticleAtX(self, mp, xp) # Particle creator that generates a single particle of mass mp at position xp
def getTimeStep(self, CFL)
def plotData(self)
def writeData(self)
def setMotion(self, dt=0.0)
def particleTrace(self, OnOff) # turn particle trace on and off
def computeCellFlux(self)
'''
def __init__(self, width=1., height=1., nCellsX=2, nCellsY=2):
'''
Constructor
'''
self.width = width
self.height = height
self.nCellsX = nCellsX
self.nCellsY = nCellsY
self.hx = width/nCellsX # cell size in x-direction
self.hy = height/nCellsY # cell size in y-direction
self.time = 0.0
self.recordParticleTrace = False
#self.X = outer(ones(nCellsY+1), linspace(0.0, width, nCellsX+1))
#self.Y = outer(linspace(0.0, height, nCellsY+1), ones(nCellsX+1))
x = linspace(0,width ,(nCellsX+1))
y = linspace(0,height,(nCellsY+1))
self.X, self.Y = meshgrid(x, y, indexing='xy')
self.Re = 1.0
self.rho = 1.0
self.v0 = 0.0
self.motion = None
self.particleUpdateScheme = ExplicitEuler()
self.nodes = [ [ None for j in range(self.nCellsY+1) ] for i in range(self.nCellsX+1) ]
id = -1
for i in range(nCellsX+1):
for j in range(nCellsY+1):
id += 1
theNode = Node(id,x[i],y[j])
theNode.setGridCoordinates(i,j)
self.nodes[i][j] = theNode
self.cells = []
id = -1
hx = width / nCellsX
hy = height / nCellsY
for i in range(nCellsX):
for j in range(nCellsY):
id += 1
newCell = Cell(id, hx, hy)
newCell.setCellGridCoordinates(i, j)
theNodes = []
theNodes.append(self.nodes[i][j])
theNodes.append(self.nodes[i+1][j])
theNodes.append(self.nodes[i+1][j+1])
theNodes.append(self.nodes[i][j+1])
newCell.SetNodes(theNodes)
self.cells.append(newCell)
self.setParameters(self.Re, self.rho, self.v0)
self.particles = []
# set default analysis parameters
self.setAnalysis(False, True, True, True, False, True, True, True)
# set default plot parameters
self.plotControl = {'Active':False, 'DelTime':-1 }
self.plot = Plotter()
self.plot.setGrid(width, height, nCellsX, nCellsY)
self.lastPlot = self.time
# set default output parameters
self.outputControl = {'Active':False, 'DelTime':-1 }
self.writer = Writer()
self.writer.setGrid(width, height, nCellsX, nCellsY)
self.lastWrite = self.time
def __str__(self):
s = "==== D O M A I N ====\n"
s += "Nodes:\n"
for i in range(self.nCellsX+1):
for j in range(self.nCellsY+1):
s += str(self.nodes[i][j]) + "\n"
s += "nCells:\n"
for cell in self.cells:
s += str(cell) + "\n"
return s
def particleTrace(self, OnOff):
self.recordParticleTrace = OnOff
for particle in self.particles:
particle.trace(OnOff)
def setTimeIntegrator(self, integrator):
self.particleUpdateScheme = integrator
def setMotion(self, motion):
self.motion = motion
def setPlotInterval(self, dt):
self.plotControl['DelTime'] = dt
self.plotControl['Active'] = (dt >= 0)
def setWriteInterval(self, dt):
self.outputControl['DelTime'] = dt
self.outputControl['Active'] = (dt >= 0)
def setBoundaryConditions(self):
nCellsX = self.nCellsX
nCellsY = self.nCellsY
# define fixities
for i in range(nCellsX+1):
self.nodes[i][0].fixDOF(1, 0.0)
self.nodes[i][nCellsY].fixDOF(1, 0.0)
#self.nodes[i][0].fixDOF(0, 0.0) # fully fixed
#self.nodes[i][nCellsY].fixDOF(0, 0.0) # fully fixed
if (i>0 and i< nCellsX+1):
self.nodes[i][nCellsY].fixDOF(0, self.v0)
for j in range(nCellsY+1):
self.nodes[0][j].fixDOF(0, 0.0)
self.nodes[nCellsX][j].fixDOF(0, 0.0)
#self.nodes[0][j].fixDOF(1, 0.0) # fully xixed
#self.nodes[nCellsX][j].fixDOF(1, 0.0) # fully fixed
def setAnalysis(self, doInit, solveVstar, solveP, solveVtilde, solveVenhanced, updatePosition, updateStress, addTransient):
self.analysisControl = {
'doInit':doInit,
'solveVstar':solveVstar,
'solveP':solveP,
'solveVtilde':solveVtilde,
'solveVenhanced':solveVenhanced,
'updatePosition':updatePosition,
'updateStress':updateStress,
'addTransient':addTransient
}
for cell in self.cells:
# cell.setEnhanced(True)
cell.setEnhanced(solveVenhanced)
if (doInit and updatePosition and addTransient):
print("INCONSISTENCY WARNING: transient active with updatePosition && doInit ")
def getAnalysisControl(self):
return self.analysisControl
def setParameters(self, Re, density, velocity):
if (self.width < self.height ):
L = self.width
else:
L = self.height
viscosity = density * velocity * L / Re
self.Re = Re
self.rho = density
self.v0 = velocity
self.mu = viscosity
self.setBoundaryConditions()
for cell in self.cells:
cell.setParameters(density, viscosity)
def setInitialState(self):
for nodeList in self.nodes:
for node in nodeList:
node.wipe()
for cell in self.cells:
cell.mapMassToNodes()
# initial condition at nodes define v*, not v
for i in range(self.nCellsX+1):
for j in range(self.nCellsY):
self.nodes[i][j].setVelocity(zeros(2))
self.nodes[i][self.nCellsY].setVelocity(array([self.v0 ,0.0]))
# fix the top corner nodes
self.nodes[0][self.nCellsY].setVelocity(zeros(2))
self.nodes[self.nCellsX][self.nCellsY].setVelocity(zeros(2))
# now find pressure for a fictitious time step dt = 1.0
self.solveP(1.0)
# compute \tilde v
self.solveVtilde(1.0)
# initial conditions are now set
self.plotData()
self.writeData()
def setState(self, time):
self.time = time
for nodeList in self.nodes:
for node in nodeList:
node.setVelocity(zeros(2))
for cell in self.cells:
cell.mapMassToNodes()
self.setNodalMotion(time)
###self.time += dt # WHAT IS THAT FOR ?????
def runAnalysis(self, maxtime=1.0):
# find ideal timestep using CFL
dt = self.getTimeStep(0.5)
if (dt > (maxtime - self.time)):
dt = (maxtime - self.time)
if (dt < (maxtime - self.time)):
nsteps = ceil((maxtime - self.time)/dt)
if (nsteps>50):
nsteps= 50
dt = (maxtime - self.time) / nsteps
while (self.time < maxtime-0.1*dt):
self.runSingleStep(self.time, dt)
self.time += dt
if self.plotControl['Active']:
# check if this is a plot interval
if self.time > (self.lastPlot + self.plotControl['DelTime'] - 0.5*dt) :
self.plotData()
self.lastPlot = self.time
if self.outputControl['Active']:
# check if this is an outout interval
if self.time > (self.lastPlot + self.outputControl['DelTime'] - 0.5*dt) :
self.writeData()
self.lastWrite = self.time
def runSingleStep(self, time=0.0, dt=1.0):
t = process_time()
if (self.analysisControl['doInit']):
self.initStep()
if (self.analysisControl['solveVstar']):
self.solveVstar(dt, self.analysisControl['addTransient'])
if (self.analysisControl['solveP']):
self.solveP(dt)
if (self.analysisControl['solveVtilde']):
self.solveVtilde(dt)
if (self.analysisControl['solveVenhanced']):
self.solveVenhanced(dt)
if (self.analysisControl['updatePosition']):
self.updateParticleMotion(dt)
if (self.analysisControl['updateStress']):
self.updateParticleStress()
elapsed_time = process_time() - t
print("starting at t_n = {:.3f}, time step \u0394t = {}, ending at t_(n+1) = {:.3f} (cpu: {:.3f}s)".format(time, dt, time+dt, elapsed_time))
def initStep(self):
# reset nodal mass, momentum, and force
for nodeList in self.nodes:
for node in nodeList:
node.wipe()
# map mass and momentum to nodes
for cell in self.cells:
# cell.mapMassToNodes() # for particle formulation only
cell.mapMomentumToNodes()
def solveVstar(self, dt, addTransient=False):
# compute nodal forces from shear
for i in range(self.nCellsX+1):
for j in range(self.nCellsY+1):
self.nodes[i][j].setForce(zeros(2))
for cell in self.cells:
cell.computeForces(addTransient)
# solve for nodal acceleration a*
# and update nodal velocity to v*
for i in range(self.nCellsX+1):
for j in range(self.nCellsY+1):
self.nodes[i][j].updateVstar(dt)
def solveP(self, dt):
ndof = (self.nCellsX+1)*(self.nCellsY+1)
# sparse outperformes dense very quickly for this problem.
# I lowered this number to 100 and might want to switch to sparse entirely.
if ndof <= 100:
useDense = True
else:
useDense = False
# assemble matrix and force
if (useDense):
# use dense matrix
self.FP = zeros(ndof)
self.KP = zeros((ndof,ndof))
else:
# use sparse matrix
self.FP = zeros(ndof)
KP = matrixDataType(ndof)
for cell in self.cells:
ke = cell.GetStiffness()
fe = cell.GetPforce(dt)
nodeIndices = cell.getGridCoordinates()
dof = [ x[0] + x[1]*(self.nCellsX+1) for x in nodeIndices ]
if (useDense):
# use dense matrix
for i in range(4):
self.FP[dof[i]] += fe[i]
for j in range(4):
self.KP[dof[i]][dof[j]] += ke[i][j]
else:
# use sparse matrix
for i in range(4):
self.FP[dof[i]] += fe[i]
for j in range(4):
KP.add(ke[i][j],dof[i],dof[j])
# apply boundary conditions
i = self.nCellsX // 2
dof = i + self.nCellsY*(self.nCellsX+1)
if (useDense):
# use dense matrix
self.KP[dof][dof] = 1.0e20
self.FP[dof] = 0.0
else:
# use sparse matrix
KP.add(1.0e20, dof, dof)
self.FP[dof] = 0.0
# solve for nodal p
if (useDense):
# use dense matrix
pressure = solve(self.KP, self.FP)
else:
# use sparse matrix
self.KP = KP.toCSCmatrix()
pressure = spsolve(self.KP, self.FP)
# assign pressure to nodes
for i in range(self.nCellsX+1):
for j in range(self.nCellsY+1):
dof = i + j*(self.nCellsX+1)
self.nodes[i][j].setPressure(pressure[dof])
#print(pressure)
def solveVtilde(self, dt):
for i in range(self.nCellsX+1):
for j in range(self.nCellsY+1):
# compute nodal pressure gradient
if ( i==0 or i==self.nCellsX ):
dpx = 0.0
else:
dpx = 0.5*(self.nodes[i+1][j].getPressure()-self.nodes[i-1][j].getPressure())/self.hx
if ( j==0 or j==self.nCellsY ):
dpy = 0.0
else:
dpy = 0.5*(self.nodes[i][j+1].getPressure()-self.nodes[i][j-1].getPressure())/self.hy
# update nodal velocity
dv = -dt/self.rho * array([dpx,dpy])
self.nodes[i][j].addVelocity(dv)
def solveVenhanced(self, dt):
for cell in self.cells:
# initialize the divergence terms in the cell
cell.SetVelocity()
def updateParticleStress(self):
pass
def updateParticleMotion(self, dt):
# this is the Butcher tableau
a = dt*self.particleUpdateScheme.get_a() # time factors
b = dt*self.particleUpdateScheme.get_b() # position factors
c = dt*self.particleUpdateScheme.get_c() # update factors
tn = self.time
for p in self.particles:
kI = []
fI = []
Dv = []
dF = identity(2)
xn1 = p.position()
Nsteps = len(a)
try:
for i in range(Nsteps):
xi = p.position()
f = identity(2)
for j in range(i):
if (b[i][j] != 0.):
xi += b[i][j] * kI[j]
f += b[i][j] * dot(Dv[j], fI[j])
cell = self.findCell(xi)
# this line represents the MPM-style interpolation of the velocity field
kI.append(cell.GetVelocity(xi) + a[i] * cell.GetApparentAccel(xi))
# the following line uses the analytic expression for the motion. It yields the proper accuracy
#kI.append(self.motion.getVel(xi, self.time + a[i]))
Dv.append(cell.GetGradientV(xi) + a[i]*cell.GetGradientA(xi))
fI.append(f)
# particle position
xn1 += c[i] * kI[-1]
#incremental deformation gradient
dF += c[i] * dot(Dv[-1], fI[-1])
# update particle position ...
p.addToPosition(xn1 - p.position())
# update particle velocity ...
cell = self.findCell(xn1)
vel = cell.GetVelocity(xn1) + dt*cell.GetApparentAccel(xn1)
p.setVelocity(vel)
# update the deformation gradient ...
p.setDeformationGradient(dot(dF, p.getDeformationGradient()))
except CellIndexError as e:
print(e)
raise e
def findCell(self, x, testCell=None):
if (testCell != None and testCell.contains(x)):
return testCell
# find a cell that contains x
i = np.int_((x[0] - 0.0) / self.hx)
j = np.int_((x[1] - 0.0) / self.hy)
if (i<0):
i = 0
if (i>self.nCellsX-1):
i = self.nCellsX -1
if (j<0):
j = 0
if (j>self.nCellsY-1):
j = self.nCellsY -1
k = self.nCellsX * i + j
try:
cell = self.cells[k]
except:
raise CellIndexError((i,j,k,x))
# this is used for safety check but will slow down multi-particle simulations
if not cell.contains(x):
print("warning: particle position ({},{}) outside cell {}".format(*x, cell.id))
return cell
def createParticles(self, n, m):
for cell in self.cells:
h = cell.getSize()
mp = self.rho,h[0]*h[1]/n/m
for i in range(n):
s = -1. + (2*i+1)/n
for j in range(m):
t = -1. + (2*j+1)/m
xl = array([s,t])
xp = cell.getGlobal(xl)
newParticle = Particle(mp,xp)
self.particles.append(newParticle)
cell.addParticle(newParticle)
def createParticlesMID(self, n, m):
for cell in self.cells:
if ( cell.getID() != int( (self.nCellsX) * (self.nCellsY) / 2) - int(self.nCellsY/2.0) ):
continue
# print(cell.getID())
h = cell.getSize()
mp = self.rho,h[0]*h[1]/n/m
for i in range(n):
s = -1. + (2*i+1)/n
# s = 0.5
for j in range(m):
t = -1. + (2*j+1)/m
# t = 0.5
xl = array([s,t])
xp = cell.getGlobal(xl)
# print(xp)
newParticle = Particle(mp,xp)
self.particles.append(newParticle)
cell.addParticle(newParticle)
def createParticleAtX(self, mp, xp): # Particle creator that generates a single particle at position X
newParticle = Particle(mp,xp)
self.particles.append(newParticle)
cell = self.findCell(xp)
if (cell):
cell.addParticle(newParticle)
def getTimeStep(self, CFL):
dt = 1.0e10
for nodeList in self.nodes:
for node in nodeList:
vel = node.getVelocity()
if (abs(vel[0]) > 1.0e-5):
dtx = self.hx / abs(vel[0])
if (dtx<dt):
dt = dtx
if (abs(vel[1]) > 1.0e-5):
dty = self.hy / abs(vel[1])
if (dty<dt):
dt = dty
return dt*CFL
def plotData(self):
self.computeCellFlux()
self.plot.setCellFluxData(self.cells)
self.plot.setData(self.nodes)
self.plot.setParticleData(self.particles)
self.plot.refresh(self.time)
def writeData(self):
self.writer.setData(self.nodes)
self.writer.setParticleData(self.particles)
self.writer.writeData(self.time)
def setNodalMotion(self, time=0.0):
# set nodal velocity field
for rowOfNodes in self.nodes:
for node in rowOfNodes:
x = node.getPosition() # x is Eulerial nodal position
node.setVelocity( self.motion.getVel(x, time) )
node.setApparentAccel( self.motion.getDvDt(x, time) )
for cell in self.cells:
cell.SetVelocity()
def getParticles(self):
return self.particles
def setTime(self, time):
self.time = time
def plotParticleTrace(self, filename):
plotter = ParticleTracePlot()
plotter.setDomain(0.0, 0.0, self.width, self.height)
particleTraceList = []
if self.recordParticleTrace:
for particle in self.particles:
pDict = {}
pDict['node'] = particle.id
pDict['path'] = array(particle.getTrace())
particleTraceList.append(pDict)
plotter.addTraces(particleTraceList)
plotter.setGridNodes(self.nodes)
plotter.exportImage(filename)
def computeCellFlux(self):
for theCell in self.cells:
cellSize = theCell.getSize()
nodeIndices = theCell.GetNodeIndexes()
node00 = self.nodes[nodeIndices[0][0]][nodeIndices[0][1]]
node10 = self.nodes[nodeIndices[1][0]][nodeIndices[1][1]]
node11 = self.nodes[nodeIndices[2][0]][nodeIndices[2][1]]
node01 = self.nodes[nodeIndices[3][0]][nodeIndices[3][1]]
leftFlux = 0.5 * (node00.getVelocity() + node01.getVelocity()) @ array([-1., 0.]) * cellSize[0]
rightFlux = 0.5 * (node10.getVelocity() + node11.getVelocity()) @ array([ 1., 0.]) * cellSize[0]
topFlux = 0.5 * (node11.getVelocity() + node01.getVelocity()) @ array([ 0., 1.]) * cellSize[1]
bottomFlux = 0.5 * (node11.getVelocity() + node01.getVelocity()) @ array([ 0., -1.]) * cellSize[1]
theCell.setFlux(leftFlux + rightFlux + topFlux + bottomFlux)
def GenerateSubgraph(name, outputPath):
s2file = path.join(outputPath, str(name) + '_s2.csv')
s3file = path.join(outputPath, str(name) + '_s3.csv')
s4file = path.join(outputPath, str(name) + '_s4.csv')
Writer.outputGraph(s2file, follower, 2, name)
Writer.outputGraph(s3file, follower, 3, name)
Writer.outputGraph(s4file, follower, 4, name)
follower = defaultdict(list)
rank_list = []
for line in open(networkfile):
linelist = line.strip().split()
user = int(linelist[0])
if len(linelist) < 2:
continue
follower[user] = [int(item) for item in linelist[1].split(',')]
rank_list.append((user, len(follower[user])))
rank_list = sorted(rank_list, key=lambda item: item[1], reverse=True)
allfile = path.join(outputPath, 'all_1000.csv')
Writer.outputGraph(allfile, follower, -1)
select = [0, 100, 200, 300, 400, 500, 600, 700, 800, 900]
for rank in select:
print rank_list[rank]
GenerateSubgraph(rank_list[rank][0], outputPath)
param=param,
datapath=args.directory,
multiopt="many")
# Now read in as desired
# def readDataMany(self,skip=0,step=1,howmany='all',Nvariable=False,readtypes = 'all'):
Cornea.readDataMany("SAMoS",
args.skip,
args.step,
args.howmany,
True,
readtypes=[1, 2])
#def __init__(self,directory,conffile,skip,howmany,ignore=True,maxtype=3):
data = {'configuration': args.conffile}
write = Writer()
output = True
nav = 0
nbin = 100
data['nbin'] = nbin
data['directory'] = args.directory
data['skip'] = args.skip
data['howmany'] = args.howmany
data['step'] = args.step
data['average'] = args.average
data['coneangle'] = args.coneangle
# Histogram of swirling
v_swirlhist = np.zeros((args.howmany - args.average, nbin))
def write(self):
#First I write the license, comments etc..
#then the includes and finally the members,
#in the same order in which they are contained
#inside self.members
if FileDumper.developer_name or FileDumper.developer_email:
copyright = '(c) ' + FileDumper.developer_name + ', ' + FileDumper.developer_email
else:
copyright = ''
fileHnd = open(self.name, 'wt')
printOnFile('/***************************************************************************\\', fileHnd)
printOnFile(' *', fileHnd)
for line in FileDumper.banner.split('\n'):
printOnFile(' * ' + line, fileHnd)
printOnFile(' *', fileHnd)
printOnFile(' *', fileHnd)
for line in FileDumper.license_text.split('\n'):
printOnFile(' * ' + line, fileHnd)
printOnFile(' *', fileHnd)
printOnFile(' *', fileHnd)
for line in copyright.split('\n'):
printOnFile(' * ' + line, fileHnd)
printOnFile(' *', fileHnd)
printOnFile('\\***************************************************************************/\n\n', fileHnd)
# Now I can start priting the actual code: lets create the writer
writer = Writer.CodeWriter(fileHnd)
if self.isHeader:
writer.write('#ifndef ' + self.name.replace('.','_').upper() + '\n')
writer.write('#define ' + self.name.replace('.','_').upper() + '\n')
# as a first thing I compute the includes and print them
for member in self.members:
try:
for include in member.getIncludes():
if include and not include in self.includes:
self.includes.append(include)
except AttributeError:
pass
if self.includes:
writer.write('\n')
# Not that I have to add a dirty hack to put always SystemC in the
# last position among the includes, otherwise it might create problems
# compiling
foundSysC = False
for include in self.includes:
include = include.lstrip()
if 'systemc.h' in include:
foundSysC = True
else:
if include.startswith('#'):
writer.write(include + '\n')
elif include != self.name:
writer.write('#include <' + include + '>\n')
if foundSysC:
writer.write('#include <systemc.h>\n')
writer.write('\n')
# Now I simply have to print in order all the members
for member in self.members:
if self.isHeader:
try:
member.writeDeclaration(writer)
except AttributeError:
pass
else:
try:
member.writeImplementation(writer)
except AttributeError:
pass
if self.isHeader:
writer.write('\n\n#endif')
writer.write('\n')
fileHnd.close()
# (or any n) from the .csv file.
dec = int(nStocks / 10)
topDecile = []
# Store temporary momentums from top decile for sorting reasons
moms = [o.mom for o in stocks[:dec]]
# Sort top decile by momentum
for i in range(dec):
# Get index of top momentum performer in top decile
topMomInd = moms.index(max(moms))
# Sort
topDecile.append(stocks[topMomInd])
# Remove top momentum performer from further consideration
moms[topMomInd] = -100
print('Saving stocks...')
# Save momentum-weighted top decile
topCsvPath = 'top.csv'
Writer.writeCSV(topCsvPath, topDecile)
# Save results to .csv
allCsvPath = 'stocks.csv'
Writer.writeCSV(allCsvPath, stocks)
print('\n')
print('Complete.')
print('Top decile (sorted by momentum) saved to: ' + topCsvPath)
print('All stocks (sorted by trending value) saved to: ' + allCsvPath)
c.executemany('INSERT INTO temp_track (trackID) VALUES (?)',new_tup)
c.execute('SELECT count(albumID) FROM ID_album')
n_albumIDs = [i for i in c][0][0]
album_pop = range(1,n_albumIDs)
album_sample = random.sample(album_pop,200)
new_tup = [ ( i,) for i in album_sample]
c.execute('DROP TABLE IF EXISTS temp_album')
c.execute('CREATE TABLE temp_album (albumID)')
c.executemany('INSERT INTO temp_album (albumID) VALUES (?)',new_tup)
con.commit()
# instantiate writer track
wr=Writer(category='track',user='******',db_path=db_path,db_lock=db_lock)
print 'writer instantiated'
# playslist selection is limited to 5000 track takes around 5 min to assemble
wr.limit(rank_by='plays_track_total',topX=2, con=con, asc=False)
sort_by = ['date_artist','date_track','i_score_artist','i_score_track']
asc = [ True , True , False , False]
wr.sort( sort_by=sort_by, asc=asc, con=con )
wr.write_playlist('test_track',path, con=con)
# instantiate writer album
wr=Writer(category='album',user='******',db_path=db_path,db_lock=db_lock)
data = newmodels.Models(data)
joblib.dump(data, "trained.data")
print 'Done with stage:', stage
stage = 'test'
if stage == 'test':
models = joblib.load("trained.data", "r")
testData = newparser.InsultParser(testingDataFile, isTestDataLabelled)
evaluation = Evaluate.Evaluate(testData, models)
ypred = evaluation.predictions
print ypred
if isTestDataLabelled == True:
ytrue = testData.y
print len(ytrue), len(ypred)
fpr, tpr, thresholds = sklearn.metrics.roc_curve(ytrue, ypred)
print fpr, tpr, thresholds
print sklearn.metrics.auc(fpr, tpr)
incorrect = Evaluate.crossValidate(ypred, ytrue)
for key in incorrect:
print key+2, ypred[key], ytrue[key], testData.X[key]
Evaluate.crossValidate(evaluation.mainModelPredictions, ytrue)
#incorrect=Evaluate.crossValidate(evaluation.invIdxModelPredictions, ytrue)
#Evaluate.crossValidate(evaluation.distanceBasedClassifier, ytrue)
else:
Writer.writeCSVFile('insult_output.csv', ypred, testingDataFile)
print 'Done with stage:', stage
stage = 'done'
tweet_feat, authorID = Processor.GetTweetFeature(tweetfile)
authorfile = path.join(user_path, str(authorID)+'.txt')
author_feat = Processor.GetAuthorFeature(authorfile)
userfile = path.join(user_path, str(userID)+'.txt')
user_feat = Processor.GetUserFeature(userfile)
relation_feat = Processor.GetRelationFeature(int(userID), int(authorID), follower_dict, follow_dict, mutual_path)
#instance: label, feat_list
train_pool += [(tag, tweet_feat+author_feat+user_feat+relation_feat[0:2])]
return train_pool
if path.exists(retweet_list_file):
positive_list = Reader.LoadID(retweet_list_file)
all_list = Reader.LoadID(all_retweet_file)
negative_list = list(set(all_list)-set(positive_list))
follow_dict, follower_dict = Reader.LoadNetwork(networkfile)
print "%s positive: %s, negative: %s" % (userID, len(positive_list), len(negative_list))
pos_pool = GetTrainData(positive_list, '1')
neg_pool = GetTrainData(negative_list, '0')
print len(pos_pool), len(neg_pool)
Writer.outputData(trainfile, pos_pool+neg_pool)
else:
print "no retweets ", userID
stocks = [x for (y, x) in sorted(zip(rankOverall, stocks))]
# Sort top decile by momentum factor
dec = int(nStocks / 10)
topDecile = []
# Store temporary momentums from top decile
moms = [o.mom for o in stocks[:dec]]
for i in range(dec):
# Get index of top momentum performer in top decile
topMomInd = moms.index(max(moms))
# Sort
topDecile.append(stocks[topMomInd])
# Remove top momentum performer from further consideration
moms[topMomInd] = -100
print('Saving stocks...')
# Save momentum-weighted top decile
csvpath = 'top.csv'
Writer.writeCSV(csvpath, topDecile)
# Save results to .csv
csvpath = 'stocks.csv'
Writer.writeCSV(csvpath, stocks)
print('\n')
print('Complete.')
print('Results saved to ' + csvpath)
# (or any n) from the .csv file.
dec = int(nStocks / 10)
topDecile = []
# Store temporary momentums from top decile for sorting reasons
moms = [o.mom for o in stocks[:dec]]
# Sort top decile by momentum
for i in range(dec):
# Get index of top momentum performer in top decile
topMomInd = moms.index(max(moms))
# Sort
topDecile.append(stocks[topMomInd])
# Remove top momentum performer from further consideration
moms[topMomInd] = -100
print('Saving stocks...')
# Save momentum-weighted top decile
topCsvPath = 'top.csv'
Writer.writeCSV(topCsvPath, topDecile)
# Save results to .csv
allCsvPath = 'stocks.csv'
Writer.writeCSV(allCsvPath, stocks)
print('\n')
print('Complete.')
print('Top decile (sorted by momentum) saved to: ' + topCsvPath)
print('All stocks (sorted by trending value) saved to: ' + allCsvPath)
def __init__(self, width=1., height=1., nCellsX=2, nCellsY=2):
'''
Constructor
'''
self.width = width
self.height = height
self.nCellsX = nCellsX
self.nCellsY = nCellsY
self.hx = width/nCellsX # cell size in x-direction
self.hy = height/nCellsY # cell size in y-direction
self.time = 0.0
self.recordParticleTrace = False
#self.X = outer(ones(nCellsY+1), linspace(0.0, width, nCellsX+1))
#self.Y = outer(linspace(0.0, height, nCellsY+1), ones(nCellsX+1))
x = linspace(0,width ,(nCellsX+1))
y = linspace(0,height,(nCellsY+1))
self.X, self.Y = meshgrid(x, y, indexing='xy')
self.Re = 1.0
self.rho = 1.0
self.v0 = 0.0
self.motion = None
self.particleUpdateScheme = ExplicitEuler()
self.nodes = [ [ None for j in range(self.nCellsY+1) ] for i in range(self.nCellsX+1) ]
id = -1
for i in range(nCellsX+1):
for j in range(nCellsY+1):
id += 1
theNode = Node(id,x[i],y[j])
theNode.setGridCoordinates(i,j)
self.nodes[i][j] = theNode
self.cells = []
id = -1
hx = width / nCellsX
hy = height / nCellsY
for i in range(nCellsX):
for j in range(nCellsY):
id += 1
newCell = Cell(id, hx, hy)
newCell.setCellGridCoordinates(i, j)
theNodes = []
theNodes.append(self.nodes[i][j])
theNodes.append(self.nodes[i+1][j])
theNodes.append(self.nodes[i+1][j+1])
theNodes.append(self.nodes[i][j+1])
newCell.SetNodes(theNodes)
self.cells.append(newCell)
self.setParameters(self.Re, self.rho, self.v0)
self.particles = []
# set default analysis parameters
self.setAnalysis(False, True, True, True, False, True, True, True)
# set default plot parameters
self.plotControl = {'Active':False, 'DelTime':-1 }
self.plot = Plotter()
self.plot.setGrid(width, height, nCellsX, nCellsY)
self.lastPlot = self.time
# set default output parameters
self.outputControl = {'Active':False, 'DelTime':-1 }
self.writer = Writer()
self.writer.setGrid(width, height, nCellsX, nCellsY)
self.lastWrite = self.time
final=Tower(
[['n','n','n','e'],
['a','v','A','r'],
['a','v','A','r'],
['a','v','A','r'],
['a','v','A','r']])
# igual que aqui
easy=Tower( #0.5s
[['n','n','n','e'],
['a','a','v','r'],
['r','v','A','A'],
['a','v','A','r'],
['a','v','A','r']])
#se debe llamar a esa funcion
result = busqueda(easy,final)
for elem in result:
try:
print(elem.description)
printBeauty(elem.tower.matrix) #deberia ser la funcion para escribir en archivos
#printBeauty(elem.Modelo.matrix)
except:
printBeauty(easy.matrix) # inicial #deberia ser la funcion para escribir en archivos
print() #\n
writer = Writer()
writer.writeSolution(easy,result)
print bestLength
print bestTour
print bestBeta
print bestOpt
print bestRand
print bestSuccess
bestTours[f] = bestTour
bestLengths[f] = bestLength
bestBetas[f] = bestBeta
bestOpts[f] = bestOpt
bestRands[f] = bestRand
bestSuccesses[f] = bestSuccess
print bestTours
print
print bestLengths
print
print bestBetas
print
print bestOpts
print
print bestRands
print
print bestSuccesses
Writer.writeTourFile(FILENAME, numNodes, bestLength,
bestTour) #CHANGE TO BESTLENGTH, BESTTOUR
#main()
recordPath='/home/yipei/Twitter/FeatureExtraction/data/author'
tweetPath='/home/yipei/Twitter/FeatureExtraction/data/tweets'
for line in open(filelist):
filepath = line.strip()
filename = path.basename(filepath)
author = path.splitext(filename)[0]
retweetfile = path.join(recordPath, filename)
retweet_list = []
if path.exists(retweetfile):
retweet_list = [int(line.strip()) for line in open(retweetfile)]
#print "retweetfile: ", retweetfile, len(retweet_list)
user_info, history = Reader.CollectInfo(filepath)
if len(user_info.items())==0:
print "skip ", line.strip()
continue
tweet_dict = {}
if len(retweet_list)>0:
tweet_dict = Reader.CollectTweet(filepath, retweet_list)
outputfile = path.join(outputPath, filename)
Writer.outputInfo(user_info, history, outputfile)
if len(tweet_dict.items())>0:
Writer.outputTweet(tweet_dict, author, tweetPath)
