def test_model_small(self): p = Node('project') times = pd.read_csv(os.path.join(BASE_DIR, 'fixtures/timings.dsv'), delimiter='|', dtype={'PROC_ID': str}) deps = pd.read_csv(os.path.join(BASE_DIR, 'fixtures/deps_small.dsv'), delimiter='|', dtype={ 'PARENT_ID': str, 'UPROC_ID': str }) # Define nodes with timings for utiming in times.itertuples(index=False): p.add(Node(utiming.PROC_ID, duration=utiming.DURATION)) # Add dependencies to the model for dep in deps.itertuples(index=False): while True: try: p.link(dep.PARENT_ID, dep.UPROC_ID) break except KeyError as missingnode: print('Missing node when adding dependency = ') print(missingnode) print(dep) for errordep in dep: p.add(Node(errordep, duration=0)) p.update_all() critical_path = p.get_critical_path() print(critical_path)
def test_model_big(self): """ A very large graph that tests the CPU and memory efficiency of our cyclic checker. """ p = Node(name='project') times = pd.read_csv(os.path.join(BASE_DIR, 'fixtures/timings.dsv'), delimiter='|', dtype={'PROC_ID': str}) deps = pd.read_csv(os.path.join(BASE_DIR, 'fixtures/deps_big.dsv'), delimiter='|', dtype={'PARENT_ID': str, 'UPROC_ID': str}) # Define nodes with timings for utiming in times.itertuples(index=False): p.add(Node(name=utiming.PROC_ID, duration=utiming.DURATION)) # Add dependencies to the model for dep in deps.itertuples(index=False): while True: try: p.link(dep.PARENT_ID, dep.UPROC_ID) break except KeyError as missingnode: print('Missing node when adding dependency = ') print(missingnode) print(dep) for errordep in dep: p.add(Node(errordep, duration=0)) p.update_all() critical_path = p.get_critical_path() print(critical_path)
def get_critical_path(activities, nodes, edges): p = Node('Activity') links = [] p.add(Node(activities[0].activity_name, duration=activities[0].duration)) for i in range(1, len(activities)): p.add( Node(activities[i].activity_name, duration=activities[i].duration, lag=0)) for act in activities: if act.no_of_predecessors != 0: if len(act.predecessors_string) > 1: for pred in act.predecessors: links.append((pred, act.activity_name)) else: links.append((act.predecessors_string, act.activity_name)) for lk in links: if lk[0] != ' ': p.link(lk[0], lk[1]) p.update_all() print("Critical Path = ", p.get_critical_path()) print("Critical Path Duration = ", p.duration) return p.get_critical_path(), p.duration
def getPath(self): project = get_object_or_404(Project, pk=self.pk) p = Node(project.name) task = Task.objects.all() for t in task: ptask = p.add(Node(t.name, duration=t.duration)) if t.predecessors: for pred in t.predecessors.all(): p.link(ptask.name,pred.name) p.update_all() return p.get_critical_path()
def get_criticalpath_project(self, act_ids): p = Node('project') node = {} #Node register for act in act_ids: node[act.id] = p.add(Node(act.name, duration = act.duration)) #Link Nodes for act in act_ids: for trans in act.to_ids: p.link(node[trans.process_from_id.id], node[trans.process_to_id.id]) p.update_all() return p, node
def handle(self, root_job_id, **options): root_job = Job.objects.get(id=int(root_job_id)) samples = int(options['samples']) # Add all system task nodes. system = Node('system') system.add( Node(root_job.id, duration=root_job.get_run_length_estimate(samples=samples))) print('%s takes about %s seconds' \ % (root_job, root_job.get_run_length_estimate(samples=samples))) chain = root_job.get_chained_jobs() for job in chain: print('%s takes about %s seconds' \ % (job, job.get_run_length_estimate(samples=samples))) node = Node(job.id, duration=job.get_run_length_estimate(samples=samples)) node.description = job.name system.add(node) # Add all links between task nodes. print('-' * 80) for job in chain: if not job.enabled: continue dependees = JobDependency.objects.filter(dependent=job, dependee__enabled=True) dependees = dependees.values_list('dependee_id', flat=True) print(job, dependees) for dependee in dependees: # Link dependent job to dependee. assert job.id != 1 system.link(from_node=dependee, to_node=job.id) root_node = system.lookup_node(1) print('root_node:', root_node, root_node.to_nodes, root_node.incoming_nodes) system.add_exit() sys.stdout.flush() #return print('Updating values...') system.update_all() critical_path = system.get_critical_path() print('critical_path:', critical_path) system.print_times() print('min hours:', system.duration * (1 / 60.) * (1 / 60.))
def CriticalPath(request,pk): context = {} project = get_object_or_404(Project, pk=pk) p = Node(project.name) task = Task.objects.all() for t in task: ptask = p.add(Node(t.name, duration=t.duration)) if t.predecessors: for pred in t.predecessors.all(): p.link(ptask.name,pred.name) p.update_all() context['criticalpath'] = p.get_critical_path() context['duration'] = p.duration context['name'] = p template = 'manage/criticalpath.html' return render_to_response(template, context, context_instance=RequestContext(request) )
class Project: def __init__(self): self.p = Node('project') self.nodes = [] def create_network(self, actions): for action in actions: self.nodes.append(self.p.add(Node(action.name, action.duration))) for action in actions: for pre in action.predecessors: self.p.link(pre, action.name) self.p.update_all() def get_critical_path(self): return self.p.get_critical_path() def get_duration(self): return self.p.duration
def handle(self, root_job_id, **options): root_job = Job.objects.get(id=int(root_job_id)) samples = int(options['samples']) # Add all system task nodes. system = Node('system') system.add(Node(root_job.id, duration=root_job.get_run_length_estimate(samples=samples))) print('%s takes about %s seconds' \ % (root_job, root_job.get_run_length_estimate(samples=samples))) chain = root_job.get_chained_jobs() for job in chain: print('%s takes about %s seconds' \ % (job, job.get_run_length_estimate(samples=samples))) node = Node(job.id, duration=job.get_run_length_estimate(samples=samples)) node.description = job.name system.add(node) # Add all links between task nodes. print('-'*80) for job in chain: if not job.enabled: continue dependees = JobDependency.objects.filter(dependent=job, dependee__enabled=True) dependees = dependees.values_list('dependee_id', flat=True) print(job, dependees) for dependee in dependees: # Link dependent job to dependee. assert job.id != 1 system.link(from_node=dependee, to_node=job.id) root_node = system.lookup_node(1) print('root_node:', root_node, root_node.to_nodes, root_node.incoming_nodes) system.add_exit() sys.stdout.flush() #return print('Updating values...') system.update_all() critical_path = system.get_critical_path() print('critical_path:', critical_path) system.print_times() print('min hours:', system.duration*(1/60.)*(1/60.))
def test_graph(n): """Return an acyclic graph containing 2**n simple paths.""" p = Node(name='graph') for i in range(n): from_id = 3 * i to_id1 = 3 * i + 1 to_id2 = 3 * i + 2 to_id3 = 3 * (i + 1) #i=0=>0,1,2,3 #i=1=>3,4,5,6 p.add(p.get_or_create_node(name=from_id, duration=1)) p.add(p.get_or_create_node(name=to_id1, duration=1)) p.add(p.get_or_create_node(name=to_id2, duration=1)) p.add(p.get_or_create_node(name=to_id3, duration=1)) p.link(from_id, to_id1) p.link(from_id, to_id2) p.link(to_id1, to_id3) p.link(to_id2, to_id3) return p
def test_project(self): p = Node('project') a = p.add(Node('A', duration=3)) b = p.add(Node('B', duration=3, lag=0)) c = p.add(Node('C', duration=4, lag=0)) d = p.add(Node('D', duration=6, lag=0)) e = p.add(Node('E', duration=5, lag=0)) p.link(a, b) p.link(a, c) p.link(a, d) p.link(b, e) p.link(c, e) p.link(d, e) p.update_all() # for node in sorted(p.nodes, key=lambda n: n.name): # node.print_times() self.assertEqual(a.es, 0) self.assertEqual(a.ef, 3) self.assertEqual(a.ls, 0) self.assertEqual(a.lf, 3) self.assertEqual(b.es, 3) self.assertEqual(b.ef, 6) self.assertEqual(b.ls, 6) self.assertEqual(b.lf, 9) self.assertEqual(c.es, 3) self.assertEqual(c.ef, 7) self.assertEqual(c.ls, 5) self.assertEqual(c.lf, 9) self.assertEqual(d.es, 3) self.assertEqual(d.ef, 9) self.assertEqual(d.ls, 3) self.assertEqual(d.lf, 9) self.assertEqual(e.es, 9) self.assertEqual(e.ef, 14) self.assertEqual(e.ls, 9) self.assertEqual(e.lf, 14) critical_path = p.get_critical_path() #print critical_path self.assertEqual(critical_path, [a, d, e]) self.assertEqual(p.duration, 14) self.assertEqual(p.es, 0) self.assertEqual(p.ef, 14) self.assertEqual(p.ls, 0) self.assertEqual(p.lf, 14)
def test_cycles(self): p = Node('project') a = p.add(Node('A', duration=3)) b = p.add(Node('B', duration=3, lag=0)) c = p.add(Node('C', duration=4, lag=0)) d = p.add(Node('D', duration=6, lag=0)) e = p.add(Node('E', duration=5, lag=0)) p.link(a, b) p.link(a, c) p.link(a, d) p.link(b, e) p.link(c, e) p.link(d, e) self.assertEqual(p.is_acyclic(), True) p = Node('project') a = p.add(Node('A', duration=3)) b = p.add(Node('B', duration=3, lag=0)) c = p.add(Node('C', duration=4, lag=0)) d = p.add(Node('D', duration=6, lag=0)) e = p.add(Node('E', duration=5, lag=0)) p.link(a, b) p.link(a, c) p.link(a, d) p.link(b, e) p.link(c, e) p.link(d, e) p.link(e, a) # links back! self.assertEqual(p.is_acyclic(), False)
#se capturan los nodos a = None b = str(i) duracion = int(input("Ingrese la duracion del nodo " + b + " :")) nodos.append(a) nodos[i] = p.add(Node(b, duration=duracion)) print("ingrese las relacion por pares") print("Se termina con un espacio en blanco") while True: list = [] valor1 = input() if valor1 == "": break valor2 = input() valor1 = int(valor1) valor2 = int(valor2) list.append(nodos[valor1]) list.append(nodos[valor2]) list = tuple(list) links.append(list) print() for link in links: p.link(*link) p.update_all() print(p.get_critical_path()) print(p.duration)
def create_function(combination,Res,BindAvail): combinations=copy.copy(combination) #**********new combination processing********* Qout={} j=1 #create the ordering graph executable=True pred2='' predecessors=[] valeurs = [] namep=str("projet") p = Node(namep) l={} while len(combination) > 0 and not BindAvail < Res: Exec=[] #determine the set of data services which can be executed at iteration i(i.e.,all its required inputs are available) for servic in combination: for ser in Service_lake: if ser.ide==servic: service=ser if set(service.inputs).issubset(BindAvail): Exec.append(service) if not Exec: executable=False else: for service in Exec: l[str(service.ide)]=p.add(Node(str(service.ide), duration=int(service.response_time),lag=0)) predd='"' pred2=pred2+service.name+' '+str(service.response_time)+' ' if len(predecessors)>1: for pr in predecessors: for service1 in Service_lake: if service1.name==pr: p.link(l[str(service.ide)],l[str(service1.ide)]) predd=predd+str(service1.ide)+',' pred2=pred2+str(service1.name)+' ' Index=len(predd)-1 Name_list = list(predd) Name_list[Index] = '"' predd = "".join(Name_list) elif len(predecessors)==1: for service1 in Service_lake: if service1==predecessors[0]: p.link(l[str(service.ide)],l[str(service1.ide)]) predd=str(service1.ide) pred2=pred2+str(service1.name)+' ' if predd=='"': predd='' valeurs.append([str(service.ide),service.name,str(service.response_time),predd,str(0)]) pred2=pred2+str("\n ") for out in service.outputs: BindAvail.add(out) #check here the content of BindAvail combination.remove(service.ide) predecessors=[] for service in Exec: predecessors.append(service) if executable: #!!! identify the critical path for a plan P, elapsed time and critical services !!! p.update_all() s=p.get_critical_path() t=p.duration P=Plan(combinations,pred2,s,t) Plans.append(P) ii=P.ide file=str("Plans/"+"ExecutableOrdering"+str(ii)+".csv") f = open(file, 'w') ligneEntete = ",".join(entetes) + "\n" f.write(ligneEntete) n=0 for valeur in valeurs: ligne = ",".join(valeur) + "\n" f.write(ligne) n+=1 f.close() df = pd.read_csv("Plans/"+"ExecutableOrdering"+str(ii)+".csv") for i in range(0,n): for servic in P.incl_services: if df.at[i,"id"]==servic: for ser in Service_lake: if ser.ide==servic: service=ser p=calls_number(service,str("Plans/"+"ExecutableOrdering"+str(ii)+".csv")) df.at[i, "critical"]= 1 df.at[i,"calls_number"]=p df.to_csv("Plans/"+"ExecutableOrdering"+str(ii)+".csv", index=False) P.Ordering_file=file else: print("this plan is not executable") return P,executable
d = p.add(Node("D", duration=3)) e = p.add(Node("E", duration=1)) b = p.add(Node("B", duration=5)) h = p.add(Node("H", duration=3)) f = p.add(Node("F", duration=4)) g = p.add(Node("G", duration=1)) j = p.add(Node("J", duration=4)) i = p.add(Node("I", duration=5)) l = p.add(Node("L", duration=2)) k = p.add(Node("K", duration=5)) p.link(a, e).link(e, g).link(e, h).link(g, k) p.link(c, b).link(b, j).link(c, h).link(h, j).link(h, i) p.link(d, h).link(h, i).link(d, f).link(f, i).link(f, l) # all tasks A-K must be completed within 10 weeks # you're allocated 4 workers per week # the most workers on a given task is 2 per week # the most workers on all tasks for a given week is 5 # putting an additional worker on a task (2 total) adds a $100 charge # charge $200 per worker per week # if you use an extra worker (5 total) it is a $300 charge for the week p.update_all() print(p.get_critical_path())