Flexible Job Shop (FJSP)¶

/********** FlexibleJobshop.cs **********/

using System;
using System.IO;
using System.Linq;
using localsolver;

public class FlexibleJobshop : IDisposable
{
    // Number of jobs
    private int nbJobs;
    // Number of machines
    private int nbMachines;
    // Number of tasks
    private int nbTasks;
    // Processing time for each task, for each machine
    private long[][] taskProcessingTime;
    // For each job, for each operation, the corresponding task id
    private int[][] jobOperationTask;
    // Number of operations for each job;
    private int[] nbOperations;
    // Trivial upper bound for the start times of the tasks
    private long maxStart;
    // Constant for uncompatible machines
    private const long INFINITE = 1000000;

    // LocalSolver
    private LocalSolver localsolver;
    // Decision variables: start times of the tasks
    private LSExpression[] start;
    // Decision variables: sequence of tasks on each machine
    private LSExpression[] jobsOrder;
    // For each task, the selected machine
    private LSExpression[] taskMachine;
    // End times of the tasks
    private LSExpression[] end;
    // Objective = minimize the makespan: end of the last task
    private LSExpression makespan;

    public FlexibleJobshop(string fileName)
    {
        localsolver = new LocalSolver();
        ReadInstance(fileName);
    }

    private void ReadInstance(string fileName)
    {
        using (StreamReader input = new StreamReader(fileName))
        {
            char[] separators = new char[] {'\t', ' '};
            string[] splitted = input.ReadLine().Split(separators, StringSplitOptions.RemoveEmptyEntries);
            nbJobs = int.Parse(splitted[0]);
            nbMachines = int.Parse(splitted[1]);

            nbTasks = 0;
            long[][][] processingTime = new long[nbJobs][][];
            jobOperationTask = new int[nbJobs][];
            nbOperations = new int[nbJobs];
            for (int j = 0; j < nbJobs; j++)
            {
                splitted = input.ReadLine().Split(separators, StringSplitOptions.RemoveEmptyEntries);
                nbOperations[j] = int.Parse(splitted[0]);
                jobOperationTask[j] = new int[nbOperations[j]];
                processingTime[j] = new long[nbOperations[j]][];
                int k = 1;
                for (int o = 0; o < nbOperations[j]; o++)
                {
                    int nbMachinesOperation = int.Parse(splitted[k]);
                    k++;
                    processingTime[j][o] = Enumerable.Repeat((long) INFINITE, nbMachines).ToArray();
                    for (int m = 0; m < nbMachinesOperation; m++)
                    {
                        int machine = int.Parse(splitted[k]) - 1;
                        long time = long.Parse(splitted[k + 1]);
                        processingTime[j][o][machine] = time;
                        k += 2;
                    }
                    jobOperationTask[j][o] = nbTasks;
                    nbTasks++;
                }
            }

            // Trivial upper bound for the start times of the tasks
            maxStart = 0;
            taskProcessingTime = new long[nbTasks][];
            for (int j = 0; j < nbJobs; j++)
            {
                long maxProcessingTime = 0;
                for (int o = 0; o < nbOperations[j]; o++)
                {
                    int task = jobOperationTask[j][o];
                    taskProcessingTime[task] = new long[nbMachines];
                    for (int m = 0; m < nbMachines; m++)
                    {
                        taskProcessingTime[task][m] = processingTime[j][o][m];
                        if (processingTime[j][o][m] != INFINITE && processingTime[j][o][m] > maxProcessingTime)
                        {
                            maxProcessingTime = processingTime[j][o][m];
                        }
                    }
                    maxStart += maxProcessingTime;
                }
            }
        }
    }

    public void Dispose()
    {
        localsolver.Dispose();
    }

    public void Solve(int timeLimit)
    {
        // Declares the optimization model
        LSModel model = localsolver.GetModel();

        // Sequence of tasks on each machine
        jobsOrder = new LSExpression[nbMachines];
        LSExpression machineArray = model.Array();
        for (int m = 0; m < nbMachines; m++)
        {
            jobsOrder[m] = model.List(nbTasks);
            machineArray.AddOperand(jobsOrder[m]);
        }

        // Each task is scheduled on a machine
        model.Constraint(model.Partition(machineArray));

        // Only compatible machines can be selected for a task
        for (int t = 0; t < nbTasks; t++)
        {
            for (int m = 0; m < nbMachines; m++)
            {
                if (taskProcessingTime[t][m] == INFINITE)
                {
                    model.Constraint(!model.Contains(jobsOrder[m], t));
                }
            }
        }

        taskMachine = new LSExpression[nbTasks];
        LSExpression[] taskProcessingTimeArray = new LSExpression[nbTasks];
        for (int t = 0; t < nbTasks; t++)
        {
            // For each task, the selected machine
            taskMachine[t] = model.Find(machineArray, t);
            taskProcessingTimeArray[t] = model.Array(taskProcessingTime[t]);
        }

        start = new LSExpression[nbTasks];
        LSExpression[] duration = new LSExpression[nbTasks];
        end = new LSExpression[nbTasks];
        for (int t = 0; t < nbTasks; t++)
        {
            // Integer decisions: start time of each task
            start[t] = model.Int(0, maxStart);

            // The task duration depends on the selected machine
            duration[t] = model.At(taskProcessingTimeArray[t], taskMachine[t]);
            end[t] = start[t] + duration[t];
        }
        LSExpression startArray = model.Array(start);
        LSExpression endArray = model.Array(end);

        // Precedence constraints between the operations of a job
        for (int j = 0; j < nbJobs; j++)
        {
            for (int o = 0; o < nbOperations[j]-1; o++)
            {
                int t1 = jobOperationTask[j][o];
                int t2 = jobOperationTask[j][o + 1];
                model.Constraint(start[t2] >= end[t1]);
            }
        }

        // Disjunctive resource constraints between the tasks on a machine
        for (int m = 0; m < nbMachines; m++)
        {
            LSExpression sequence = jobsOrder[m];
            LSExpression sequenceSelector = model.LambdaFunction(t => startArray[sequence[t + 1]] >= endArray[sequence[t]]);
            model.Constraint(model.And(model.Range(0, model.Count(sequence) - 1), sequenceSelector));
        }

        // Minimize the makespan: end of the last task
        makespan = model.Max();
        for (int t = 0; t < nbTasks; t++)
        {
            makespan.AddOperand(end[t]);
        }
        model.Minimize(makespan);

        model.Close();

        // Parameterizes the solver
        localsolver.GetParam().SetTimeLimit(timeLimit);

        localsolver.Solve();
    }

    // Writes the solution in a file with the following format:
    //  - for each operation of each job, the selected machine, the start and end dates
    public void WriteSolution(string fileName)
    {
        using (StreamWriter output = new StreamWriter(fileName)) {
            Console.WriteLine("Solution written in file " + fileName);
            for (int j = 1; j <= nbJobs; j++)
            {
                for (int o = 1; o <= nbOperations[j - 1]; o++)
                {
                    int task = jobOperationTask[j - 1][o - 1];
                    output.WriteLine(j + "\t" + o + "\t" + taskMachine[task].GetValue() + "\t" + start[task].GetValue() + "\t" + end[task].GetValue());
                }
            }
        }
    }

    public static void Main(string[] args)
    {
        if (args.Length < 1)
        {
            Console.WriteLine ("Usage: FlexibleJobshop instanceFile [outputFile] [timeLimit]");
            System.Environment.Exit(1);
        }

        string instanceFile = args [0];
        string outputFile = args.Length > 1 ? args[1] : null;
        string strTimeLimit = args.Length > 2 ? args[2] : "60";

        using (FlexibleJobshop model = new FlexibleJobshop(instanceFile))
        {
            model.Solve (int.Parse(strTimeLimit));
            if (outputFile != null)
                model.WriteSolution(outputFile);
        }
    }
}