def main():
"""
Test Cohen-Sadeh algorithm
Arguments:
infile - project file
"""
# Parse arguments and options
parser = argparse.ArgumentParser()
parser.add_argument('infile')
args = parser.parse_args()
# Open the input file collecting the required information.
activities, _, _, _ = fileFormats.load_with_some_format(args.infile, [fileFormats.PPCProjectFileFormat(),
fileFormats.PSPProjectFileFormat()])
successors = dict(((act[1], act[2]) for act in activities))
gg1 = cohen_sadeh(graph.successors2precedents(successors))
#subgraph = gg1.focus(787, 875) # Error en Large Tavares
window = graph.Test()
window.add_image(graph.pert2image(gg1))
graph.gtk.main()
print gg1
print validation.check_validation(successors, gg1)
return 0
def main():
"""
Test Syslo algorithm
Arguments:
infile - project file
"""
# Parse arguments and options
parser = argparse.ArgumentParser()
parser.add_argument("infile")
args = parser.parse_args()
# Open the input file collecting the required information.
activities, _, _, _ = fileFormats.load_with_some_format(
args.infile, [fileFormats.PPCProjectFileFormat(), fileFormats.PSPProjectFileFormat()]
)
successors = dict(((act[1], act[2]) for act in activities))
pert_graph = sysloPolynomial(graph.successors2precedents(successors))
# subgraph = gg1.focus(787, 875) # Error en Large Tavares
window = graph.Test()
window.add_image(graph.pert2image(pert_graph))
graph.gtk.main()
print pert_graph
print validation.check_validation(successors, pert_graph)
return 0
def main():
"""
Test Mouhoub algorithm
Arguments:
infile - project file
"""
# Parse arguments and options
parser = argparse.ArgumentParser()
parser.add_argument('infile')
args = parser.parse_args()
# Open the input file collecting the required information.
activities, _, _, _ = fileFormats.load_with_some_format(args.infile, [fileFormats.PPCProjectFileFormat(),
fileFormats.PSPProjectFileFormat()])
successors = dict(((act[1], act[2]) for act in activities))
pert_graph = mouhoub(graph.successors2precedents(successors))
window = graph.Test()
window.add_image(graph.pert2image(pert_graph))
graph.gtk.main()
print pert_graph
print validation.check_validation(successors, pert_graph)
return 0
def pertFinal(actividad):
"""
Creacion del grafo Pert numerado en orden
Valor de retorno: grafoRenumerado (grafo final)
"""
successors = dict(((act[1], act[2]) for act in actividad))
grafo = Pert()
grafo = grafo.construct(graph.successors2precedents(successors))
grafoRenumerado = grafo.renumerar()
return grafoRenumerado
def pertFinal(actividad):
"""
Creacion del grafo Pert numerado en orden
Valor de retorno: grafoRenumerado (grafo final)
"""
successors = dict(((act[1], act[2]) for act in actividad))
grafo = Pert()
grafo = grafo.construct(graph.successors2precedents(successors))
grafoRenumerado = grafo.renumerar()
return grafoRenumerado
def sysloOptimal(prelations):
"""
Build a PERT graph using Syslo algorithm
return p_graph pert.PertMultigraph()
"""
# Adaptation to avoid multiple end nodes
successors = graph.reversed_prelation_table(prelations)
end_act = graph.ending_activities(successors)
#Kahn1962.check_cycles(successors)
prela = successors.copy()
Columns = namedlist.namedlist('Columns', ['pre', 'blocked', 'dummy', 'suc', 'start_node', 'end_node'])
# [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node]
# Blocked = (False or Activity with same precedents)
#Step 0.
grafo = {}
alt = graph.successors2precedents(successors)
grafo = graph.successors2precedents(syslo_table.syslo(prela, grafo, alt))
#Step 1. Save the new prelation table in a work table
work_table = {}
for act, pre in grafo.items():
if not act in prelations:
work_table[act] = Columns(pre, False, True, None, None, None)
else:
work_table[act] = Columns(pre, False, False, None, None, None)
#Step 2. Identify Dummy Activities And Identical Precedence Constraint of Diferent Activities
visited_pred = {}
for act, columns in work_table.items():
pred = frozenset(columns.pre)
if pred not in visited_pred:
visited_pred[pred] = act
else:
columns.blocked = visited_pred[pred]
#Step 3. Creating nodes
# (a) find start nodes
node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging
for act, columns in work_table.items():
if not columns.blocked:
columns.start_node = node
node += 1
if columns.blocked:
columns.start_node = work_table[columns.blocked].start_node
# Associate activities with their end nodes
for suc, suc_columns in work_table.items():
if not suc_columns.blocked:
if act in suc_columns.pre:
columns.suc = suc
break
# (b) find end nodes
graph_end_node = node # Reserve one node for graph end
node += 1
for act, columns in work_table.items():
suc = columns.suc
if suc:
columns.end_node = work_table[suc].start_node
else:
# Create needed end nodes, avoiding multiple graph end nodes (adaptation)
if act in end_act:
columns.end_node = graph_end_node
else:
columns.end_node = node
node += 1
# Step 4. Remove redundancy of dummy activities
vis = []
for act, columns in work_table.items():
if columns.dummy == False:
for q in work_table[act].pre:
for w in work_table[act].pre:
if q in work_table and w in work_table:
if q != w and work_table[q].pre == work_table[w].pre and work_table[q].dummy==True and work_table[w].dummy==True:
if w not in vis:
del work_table[w]
vis.append(q)
#Step 5. Generate the graph
pm_graph = pert.PertMultigraph()
for act, columns in work_table.items():
_, _, dummy, _, start, end = columns
pm_graph.add_arc((start, end), (act, dummy))
p_graph = pm_graph.to_directed_graph()
return p_graph
return p_graph
def sysloPolynomial(prelations):
# Adaptation to avoid multiple end nodes
successors = graph.reversed_prelation_table(prelations)
end_act = graph.ending_activities(successors)
# Step 0. Construct work table with Immediate Predecessors
Columns = namedlist.namedlist("Columns", ["pre", "blocked", "dummy", "suc", "start_node", "end_node"])
# [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node]
# Blocked = (False or Activity with same precedents)
# Step 1. Create the improper covers
work_table_pol = makeCover(prelations, successors)
# Step 2. Syslo Polynomial algorithm
final = successors.copy()
visited = []
for act, pred in prelations.items():
for v in pred:
for u in pred:
if u != v and successors[v] != successors[u] and act not in visited:
# Find activity in the improper cover table
for key, value in work_table_pol.items():
if act in value.w:
w = value.w
# Find each row that belongs to the predecessors of activity
for key, value in work_table_pol.items():
if set(value.u).issubset(prelations[act]) and value.u:
vertex = set(value.u).pop()
# Compare successors of a row with the improper cover of the activity
if successors[vertex] != w:
for q in value.u:
if final.has_key(q):
final[q] = list(
(set(final[q]) - set(w) | set([str(vertex) + separator + str(act)]))
- set([act])
)
else:
final[q] = list(
set(successors[q]) - set(w) | set([str(vertex) + separator + str(act)])
)
final[str(vertex) + separator + str(act)] = [act]
for l in w:
visited.append(l)
final = graph.successors2precedents(final)
work_table = {}
for act, pred in final.items():
work_table[act] = Columns(pred, False, False, None, None, None)
if act not in prelations:
work_table[act].dummy = True
# Step 3. Identify Dummy Activities And Identical Precedence Constraint of Diferent Activities
visited_pred = {}
for act, columns in work_table.items():
pred = frozenset(columns.pre)
if pred not in visited_pred:
visited_pred[pred] = act
else:
columns.blocked = visited_pred[pred]
# Step 4. Creating nodes
# (a) find start nodes
node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging
for act, columns in work_table.items():
if not columns.blocked:
columns.start_node = node
node += 1
if columns.blocked:
columns.start_node = work_table[columns.blocked].start_node
# Associate activities with their end nodes
for suc, suc_columns in work_table.items():
if not suc_columns.blocked:
if act in suc_columns.pre:
columns.suc = suc
break
# (b) find end nodes
graph_end_node = node # Reserve one node for graph end
node += 1
pm_graph = pert.PertMultigraph()
for act, columns in work_table.items():
suc = columns.suc
if suc:
columns.end_node = work_table[suc].start_node
else:
# Create needed end nodes, avoiding multiple graph end nodes (adaptation)
if act in end_act:
columns.end_node = node
else:
columns.end_node = graph_end_node
node += 1
# Generate the graph
_, _, dummy, _, start, end = columns
pm_graph.add_arc((start, end), (act, dummy))
p_graph = pm_graph.to_directed_graph()
return p_graph
def sysloPolynomial(prelations):
# Adaptation to avoid multiple end nodes
successors = graph.reversed_prelation_table(prelations)
end_act = graph.ending_activities(successors)
#Step 0. Construct work table with Immediate Predecessors
Columns = namedlist.namedlist('Columns', ['pre', 'blocked', 'dummy', 'suc', 'start_node', 'end_node'])
# [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node]
# Blocked = (False or Activity with same precedents)
#Step 1. Create the improper covers
work_table_pol = makeCover(prelations, successors)
# Step 2. Syslo Polynomial algorithm
final = successors.copy()
visited = []
for act, pred in prelations.items():
for v in pred:
for u in pred:
if u != v and successors[v] != successors[u] and act not in visited:
# Find activity in the improper cover table
for key, value in work_table_pol.items():
if act in value.w:
w = value.w
# Find each row that belongs to the predecessors of activity
for key, value in work_table_pol.items():
if set(value.u).issubset(prelations[act]) and value.u:
vertex = set(value.u).pop()
# Compare successors of a row with the improper cover of the activity
if successors[vertex] != w:
for q in value.u:
if final.has_key(q):
final[q] = list((set(final[q]) - set(w) | set([str(vertex) + separator + str(act)])) - set([act]))
else:
final[q] = list(set(successors[q]) - set(w) | set([str(vertex) + separator + str(act)]))
final[str(vertex) + separator + str(act)] = [act]
for l in w:
visited.append(l)
final = graph.successors2precedents(final)
work_table = {}
for act, pred in final.items():
work_table[act] = Columns(pred, False, False, None, None, None)
if act not in prelations:
work_table[act].dummy = True
#Step 3. Identify Dummy Activities And Identical Precedence Constraint of Diferent Activities
visited_pred = {}
for act, columns in work_table.items():
pred = frozenset(columns.pre)
if pred not in visited_pred:
visited_pred[pred] = act
else:
columns.blocked = visited_pred[pred]
#Step 4. Creating nodes
# (a) find start nodes
node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging
for act, columns in work_table.items():
if not columns.blocked:
columns.start_node = node
node += 1
if columns.blocked:
columns.start_node = work_table[columns.blocked].start_node
# Associate activities with their end nodes
for suc, suc_columns in work_table.items():
if not suc_columns.blocked:
if act in suc_columns.pre:
columns.suc = suc
break
# (b) find end nodes
graph_end_node = node # Reserve one node for graph end
node += 1
pm_graph = pert.PertMultigraph()
for act, columns in work_table.items():
suc = columns.suc
if suc:
columns.end_node = work_table[suc].start_node
else:
# Create needed end nodes, avoiding multiple graph end nodes (adaptation)
if act in end_act:
columns.end_node = node
else:
columns.end_node = graph_end_node
node += 1
# Generate the graph
_, _, dummy, _, start, end = columns
pm_graph.add_arc((start, end), (act, dummy))
p_graph = pm_graph.to_directed_graph()
return p_graph
def simulated_annealing(asignation,resources,successors,activities,leveling,nu,phi,minTemperature,maxIteration,numIterations):
"""
Try to find the best schedule of the project by
the technique of simulated annealing
Parameters: asignation (returned by resourcesPerActivity)
resources (returned by resourcesAvailability)
successors (the prelations of the activities)
activities (dictionary with the name of activities and their characteristics)
leveling (if 0 it will allocate else it will level)
nu (parameter to configure simulated annealing algorithm)
phi (parameter to configure simulated annealing algorithm)
minTemperature (parameter to configure simulated annealing algorithm)
maxIteration (parameter to configure simulated annealing algorithm)
numIterations (parameter to configure simulated annealing algorithm)
Returned value: sch (the best schedule found)
schEvaluated (loading sheet of schedule)
duration (duration of schedule)
alpha (parameter to configure simulated annealing algorithm)
tempAux (parameter to configure simulated annealing algorithm)
it (number of iterations done)
"""
predecessors = successors2precedents(successors)
for a in predecessors.copy():
if predecessors[a] == []:
del predecessors[a]
# sch1 will store the best plannings
schAux = sch1 = generate(asignation,resources.copy(),copy.deepcopy(predecessors),activities.copy(),leveling)
sch1Evaluated, loadSheet1, duration1 = evaluate(sch1,leveling,asignation,resources)
schAuxEvaluated = sch1Evaluated
durationAux = duration1
loadSheetAux = loadSheet1
if duration1 == 0:
return (sch1, sch1Evaluated, duration1, None, None, None)
if sch1Evaluated == 0:
return (sch1, sch1Evaluated, duration1, None, None, 0)
tempAux = temperature = (nu / -log(phi)) * sch1Evaluated
alpha = (minTemperature / temperature) ** (1 / maxIteration)
if alpha >= 1:
return (None,None,None,None,None,None)
it=0
numIterationsAux = numIterations
while temperature > minTemperature and numIterations != 0:
it += 1
sch2 = modify(asignation,resources.copy(),copy.deepcopy(predecessors),activities.copy(),sch1,leveling)
sch2Evaluated, loadSheet2, duration2 = evaluate(sch2,leveling,asignation,resources)
if sch2Evaluated <= sch1Evaluated:
loadSheet1 = loadSheet2
duration1 = duration2
sch1 = sch2
sch1Evaluated = sch2Evaluated
# Set numIterations to initial value
numIterations = numIterationsAux
else:
numIterations -= 1
r = random.random()
m = exp(-(sch2Evaluated-sch1Evaluated) / temperature)
if r < m:
if schAuxEvaluated > sch1Evaluated:
loadSheetAux = loadSheet1
durationAux = duration1
schAux = sch1
schAuxEvaluated = sch1Evaluated
sch1 = sch2
sch1Evaluated = sch2Evaluated
loadSheet1 = loadSheet2
duration1 = duration2
temperature = alpha * temperature
if sch1Evaluated <= schAuxEvaluated:
return (sch1, sch1Evaluated, duration1, alpha, tempAux, it)
else:
return (schAux, schAuxEvaluated, durationAux, alpha, tempAux, it)
def mouhoub(prelations):
"""
Build a PERT graph using Mouhoub algorithm
prelations = {'activity': ['predecesor1', 'predecesor2'...}
return p_graph pert.PertMultigraph()
"""
Columns = namedlist.namedlist('Columns', ['pre', 'su', 'blocked', 'dummy', 'suc', 'start_node', 'end_node', 'aux'])
# [0 Predecesors, 1 Successors, 2 Blocked, 3 Dummy, 4 Blocked successor, 5 Start node, 6 End node, 7 Auxiliar ]
# Blocked = (False or Activity with same precedents)
# Adaptation to avoid multiple end nodes
successors = graph.reversed_prelation_table(prelations)
successors_copy = graph.reversed_prelation_table(prelations.copy())
end_act = graph.ending_activities(successors)
# Step 0. Remove Z Configuration. Update the prelation table in complete_bipartite dictionary
complete_bipartite = successors
complete_bipartite.update(zConfiguration.zconf(successors))
# STEPS TO BUILD THE PERT GRAPH
#Step 1. Save the prelations in the work table
complete_bipartite = graph.successors2precedents(complete_bipartite)
work_table = {}
for act, sucesores in complete_bipartite.items():
work_table[act] = Columns(set(sucesores), successors[act], None, False, None, None, None, None)
if act not in prelations:
work_table[act].dummy = True
#Step 2. Identify Identical Precedence Constraint of Diferent Activities
visited_pred = {}
for act, columns in work_table.items():
pred = frozenset(columns.pre)
if pred not in visited_pred:
visited_pred[pred] = act
else:
columns.blocked = visited_pred[pred]
#Step 3. Creating nodes
# (a) Find start nodes
node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging
for act, columns in work_table.items():
if not columns.blocked:
columns.start_node = node
node += 1
if columns.blocked:
columns.start_node = work_table[columns.blocked].start_node
# Associate activities with their end nodes
for suc, suc_columns in work_table.items():
if not suc_columns.blocked:
if act in suc_columns.pre:
columns.suc = suc
break
# (b) Find end nodes
graph_end_node = node # Reserve one node for graph end
node += 1
for act, columns in work_table.items():
suc = columns.suc
if suc:
columns.end_node = work_table[suc].start_node
else:
# Create needed end nodes, avoiding multiple graph end nodes (adaptation)
if act in end_act:
columns.end_node = graph_end_node
else:
columns.end_node = node
node += 1
#Step 4. MOUHOUB algorithm rules to remove extra dummy activities
mouhoubRules.rule_1(successors_copy, work_table)
G2 = mouhoubRules.rule_2(prelations, work_table)
G3 = mouhoubRules.rule_3(G2, work_table)
G4 = mouhoubRules.rule_4(G3, work_table)
G5_6 = mouhoubRules.rule_5_6(successors_copy, work_table, G4)
G3a = mouhoubRules.rule_3(G5_6, work_table)
G4a = mouhoubRules.rule_4(G3a, work_table)
G7 = mouhoubRules.rule_7(successors_copy, successors, G4a, node)
work_table_final = {}
for act, sucesores in G7.items():
work_table_final[act] = Columns([], [], [], sucesores.dummy, sucesores.suc, sucesores.start_node, sucesores.end_node, [])
#Step 5. Delete Dummy Cycles
for act, sucesores in work_table_final.items():
for act2, sucesores2 in work_table_final.items():
if act != act2:
if sucesores.end_node == sucesores2.end_node and sucesores.start_node == sucesores2.start_node:
if act not in successors:
del work_table_final[act]
#Step 6. Generate the graph
pm_graph = pert.PertMultigraph()
for act, columns in work_table_final.items():
_, _, _, dummy, _, start, end, _ = columns
pm_graph.add_arc((start, end), (act, dummy))
p_graph = pm_graph.to_directed_graph()
return p_graph
