Many improvements ! New example "yeastfab", introduced gap_constraints, etc.

Author: Zulko

Diff for: egfscheduler/__init__.py

@@ -2,6 +2,10 @@
 
 # __all__ = []
 
-from .EGFScheduler import *
+from .classes import Resource, Task, WorkUnit
+from .numberjack_scheduler import numberjack_scheduler
+from .pyschedule_scheduler import pyschedule_scheduler
+from .plots import plot_schedule
+from .tools import gap_constraints
 
 from .version import __version__

Diff for: egfscheduler/classes.py

@@ -1,7 +1,4 @@
 import itertools as itt
-import numpy as np
-
-import Numberjack as nj
 
 tasks_counter = itt.count()
 work_units_counter = itt.count()
@@ -40,12 +37,14 @@ class Task:
       Duration of the task (the choice of the unit is left to the user.
 
     """
-    def __init__(self, name, resources, duration):
+
+    def __init__(self, name, resources, duration, scheduled=None):
 
         self.resources = resources
         self.duration = duration
         self.name = name
         self.id = tasks_counter.next()
+        self.scheduled = scheduled
 
     def __repr__(self):
         return "Task(%(id)d, %(name)s, %(duration)s)" % self.__dict__
@@ -67,4 +66,4 @@ def __init__(self, name, capacity=1):
         self.capacity = capacity
 
     def __repr__(self):
-        return self.name
+        return self.name

Diff for: egfscheduler/numberjack_scheduler.py

@@ -1,5 +1,4 @@
 import itertools as itt
-import numpy as np
 import Numberjack as nj
 
 
@@ -50,14 +49,27 @@ def numberjack_scheduler(work_units, upper_bound=500,
 
     # Create Numberjack variables to represent the tasks
     # ( starting times and resource instance that they use).
-    nj_tasks = {
-        task: nj.Task(upper_bound, task.duration)
-        for task in all_tasks
-    }
+    nj_tasks = {}
+    for task in all_tasks:
+        if task.scheduled is None:
+            new_nj_task = nj.Task(upper_bound, task.duration)
+        else:
+            new_nj_task = nj.Task(
+                task.scheduled[0],
+                task.scheduled[0]+task.duration,
+                task.duration
+            )
+        new_nj_task.name = task.name
+        nj_tasks[task] = new_nj_task
 
     nj_taskresources = {
-        task: {resource: nj.Variable(1, resource.capacity)
-               for resource in task.resources}
+        task: {
+            resource: (
+                nj.Variable(1, resource.capacity)
+                if task.scheduled is None else
+                nj.Variable([task.scheduled[2][resource]])
+            )
+            for resource in task.resources}
         for task in all_tasks
     }
 
@@ -70,7 +82,10 @@ def numberjack_scheduler(work_units, upper_bound=500,
     model = nj.Model()
 
     for resource in all_resources:
-        if resource.capacity == 1:
+
+        if resource.capacity == 'inf':
+            continue
+        elif resource.capacity == 1:
             # The resource has one slot: Only one job at the same time
             model.add(nj.UnaryResource([
                 nj_tasks[task] for task in all_tasks
@@ -140,7 +155,7 @@ def numberjack_scheduler(work_units, upper_bound=500,
     # Plus a penalty just to compress a little more:
     # sum ( work_unit.t_end for all work_units)
     if optimize:
-        C_max = nj.Variable(lower_bound, 1500000, 'C_max')
+        C_max = nj.Variable(lower_bound, 15000000, 'C_max')
         model.add(
             C_max >
             sum([
@@ -186,60 +201,3 @@ def numberjack_scheduler(work_units, upper_bound=500,
         task.scheduled = (start, end, resources)
 
     return work_units
-
-
-def plot_schedule(work_units):
-    """ Plot the work units schedule in a gant-like way.
-
-    This is quite basic and arbitrary and really meant for R&D purposes.
-
-    Example
-    -------
-
-    >>> # ... Make some work units
-    >>> solve_constraints(work_units)
-    >>> plot_schedule(work_units)
-
-    """
-
-    try:
-        import matplotlib.pyplot as plt
-        import matplotlib.cm as cm
-    except:
-        raise ImportError("Plotting requires Matplotlib.")
-
-    all_resources = list(set([
-        resource
-        for work_unit in work_units
-        for task in work_unit.tasks
-        for resource in task.resources
-    ]))
-
-    colors = itt.cycle([cm.Paired(0.21*i % 1.0) for i in range(30)])
-    fig, ax = plt.subplots(1, figsize=(15, 6))
-    max_end = 0
-    for work_unit in work_units:
-        color = colors.next()
-        label = work_unit.name
-        for task in work_unit.tasks:
-            start, end, resources = task.scheduled
-            max_end = max(end, max_end)
-            for y in [all_resources.index(resource) +
-                      0.2 + .6*resources[resource]/resource.capacity
-                      for resource in task.resources]:
-                ax.plot([start, end], [y, y], color=color, lw=10, label=label)
-                label = None
-
-    strips_colors = itt.cycle([(1, 1, 1), (1, 0.92, 0.92)])
-    for i, color in zip(range(-1, len(all_resources)+1), strips_colors):
-        ax.fill_between([0, 1.1*max_end], [i, i], y2=[i+1, i+1], color=color)
-
-    N = len(all_resources)
-    ax.set_yticks(np.arange(N)+0.5)
-    ax.set_ylim(-max(1, int(0.4*N)), max(2, int(1.5*N)))
-    ax.set_yticklabels(all_resources)
-    ax.legend(ncol=3, fontsize=8)
-    ax.set_xlabel("time (a.u.)")
-    ax.set_xlim(0, 1.1*max_end)
-
-    return fig, ax

Diff for: egfscheduler/plots.py

@@ -0,0 +1,143 @@
+import itertools as itt
+import numpy as np
+
+MATPLOTLIB_AVAILABLE = True
+try:
+    import matplotlib.pyplot as plt
+    import matplotlib.patches as patches
+    import matplotlib.cm as cm
+except:
+    MATPLOTLIB_AVAILABLE = False
+
+
+def plot_schedule(work_units):
+    """ Plot the work units schedule in a gant-like way.
+
+    This is quite basic and arbitrary and really meant for R&D purposes.
+
+    Example
+    -------
+
+    >>> # ... Make some work units
+    >>> solve_constraints(work_units)
+    >>> plot_schedule(work_units)
+
+    """
+
+    if not MATPLOTLIB_AVAILABLE:
+        raise ImportError("Plotting requires Matplotlib.")
+
+    all_resources = sorted(list(set([
+        resource
+        for work_unit in work_units
+        for task in work_unit.tasks
+        for resource in task.resources
+    ])), key=lambda e: e.name)[::-1]
+
+    print all_resources
+
+    colors = itt.cycle([cm.Paired(0.21 * i % 1.0) for i in range(30)])
+    fig, ax = plt.subplots(1, figsize=(15, 6))
+    max_end = 0
+    for work_unit in work_units:
+        color = colors.next()
+        ax.plot([0, 0], [0, 0], color=color, lw=8, label=work_unit.name)
+        for task in work_unit.tasks:
+            start, end, resources = task.scheduled
+            max_end = max(end, max_end)
+            margin = 0.2
+
+            def height(resource):
+                if resource.capacity == 'inf':
+                    slots = 1.0
+                else:
+                    slots = resource.capacity
+                return (1.0-2*margin) / slots
+
+            for r in task.resources:
+                y = (
+                    all_resources.index(r) +
+                    margin +
+                    height(r) * max(0, (resources[r] - 1))
+                )
+                ax.add_patch(
+                    patches.Rectangle(
+                        (start, y),   # (x,y)
+                        end - start,          # width
+                        height(r),          # height
+                        facecolor=color
+                    )
+                )
+
+    strips_colors = itt.cycle([(1, 1, 1), (1, 0.92, 0.92)])
+    for i, color in zip(range(-1, len(all_resources) + 1), strips_colors):
+        ax.fill_between(
+            [0, 1.1 * max_end], [i, i], y2=[i + 1, i + 1], color=color)
+
+    N = len(all_resources)
+    ax.set_yticks(np.arange(N) + 0.5)
+    ax.set_ylim(-max(1, int(0.4 * N)), max(2, int(1.5 * N)))
+    ax.set_yticklabels(all_resources)
+    ax.legend(ncol=3, fontsize=8)
+    ax.set_xlabel("time (a.u.)")
+    ax.set_xlim(0, 1.1 * max_end)
+
+    return fig, ax
+
+
+# The following compute job trees
+
+
+def _compute_depth(node, graph):
+    parents = graph.predecessors(node)
+    return (0 if (parents == []) else
+            1 + max([_compute_depth(n, graph) for n in parents]))
+
+
+def _tree_layout(graph):
+    depth_dict = {
+        node: _compute_depth(node, graph)
+        for node in graph.nodes()
+    }
+    nodes_per_level = [
+        [
+            node
+            for node in graph.nodes()
+            if depth_dict[node] == depth
+        ]
+        for depth in range(max(depth_dict.values()) + 1)
+    ]
+
+    positions = {}
+    for level, level_nodes in enumerate(nodes_per_level):
+        level_width = len(level_nodes)
+        for i, node in enumerate(level_nodes):
+            x_position = 8 * (i + 1.0) / (level_width + 1)
+            y_position = -level
+            positions[node] = (x_position, y_position)
+    return positions
+
+
+def plot_dependency_graph(elements, mode="circle", figsize=(8, 5), ax=None):
+
+    import networkx as nx
+
+    if ax is None:
+        fig, ax = plt.subplots(1, figsize=figsize)
+    edges = [
+        (e1.id, e2.id)
+        for e2 in elements
+        for e1 in e2.parents
+    ]
+    graph = nx.DiGraph(edges)
+    if mode == "circle":
+        pos = nx.graphviz_layout(graph, prog='twopi')
+    elif mode == "tree":
+        pos = _tree_layout(graph)
+    nx.draw(graph, pos, with_labels=False, arrows=True, node_size=20,
+            alpha=0.5, node_color="blue", ax=ax)
+    for w in elements:
+        if w.due_time is not None:
+            pass
+
+    return ax

Diff for: egfscheduler/tools.py

@@ -0,0 +1,32 @@
+def gap_constraints(task1_name, task2_name, min_gap=None, max_gap=None):
+    if max_gap is None:
+        # only a min gap has been provided
+        return lambda tasks: (
+            (get_task_by_name(tasks, task1_name) +
+             get_task_by_name(tasks, task1_name).duration +
+             min_gap) > get_task_by_name(tasks, task2_name)
+        )
+    elif min_gap is None:
+        # only a max gap has been provided
+        return lambda tasks: (
+            (get_task_by_name(tasks, task1_name) +
+             get_task_by_name(tasks, task1_name).duration +
+             max_gap) < get_task_by_name(tasks, task2_name)
+        )
+    else:
+        return [
+            gap_constraints(task1_name, task2_name, min_gap=min_gap),
+            gap_constraints(task1_name, task2_name, max_gap=max_gap)
+        ]
+
+
+def get_task_by_name(tasks_list, name):
+    tasks = [
+        task for task in tasks_list
+        if task.name == name
+    ]
+    if len(tasks) != 1:
+        raise ValueError("found %d entries for task name %s" % (
+            len(tasks), name
+        ))
+    return tasks[0]