• Docs »
  • Example tour »
  • Flexible Resource Constrained Project Scheduling Problem

Flexible Resource Constrained Project Scheduling Problem

Principles learned

  • Add multiple set decision variables

  • Use the find, contains and partition operators

  • Use of interval decision variables

  • Set precedence constraints

  • Use of a nesting of two lambda expressions to write a constraint

Problem

../_images/flexible_cumulative.svg

In the flexible cumulative problem, a project consists of a set of tasks that have to be scheduled. We have a finite number of renewable resources. Each task has to be done by one and only one resource and there can be several resources that can carry out this activity. Each task has a given duration and weight (both possibly equal to zero) on each resource and cannot be interrupted. The weight represents the amount of the resource it consumes while the task is being processed. If both the duration and the weight of the task for a given resource are zero, then the corresponding task cannot be performed by this resource. There are precedence constraints between the tasks: each task must end before any of its successors can start. Each resource has a given maximum capacity: it can process several tasks at once, but the sum of the processed tasks’s weights can never exceed this maximum capacity.

The goal is to find a schedule that minimizes the makespan: the time when all tasks have been processed.

Download the example


Data

The format of the data files is as follows:

  • First line:

    • Number of tasks

    • Number of renewable resources

  • Second line: Maximum capacity for each resource

  • From the third line, for each task * for each resource

    • Duration of the task (taskProcessingTimeData)

    • Resource requirements (weights)

  • From the next line, for each task:

    • Number of successors

    • Task ID for each successor

Program

We use set variables to model the set of tasks done by the resource.

Each task must be processed, hence the partition operator on the sets, which ensures that each task will belong to one and only one resource. Resources that are not compatible for an operation are filtered out using a contains operator.

The find operator takes as argument an array of sets and an integer value, and returns the position of the set containing the value in the array, if it exists. Here, we use this operator to retrieve the id of the resource used for each task. It then allows to deduce the duration of the operation, since it depends on the selected resource.

We use interval variables to model the start and end times of the tasks which have to respect the duration of the task according to the resource that process it.

The precedence constraints are easily written: each task must end before any of its successors can start.

The cumulative resource constraints can be formulated as follows: for each resource r, and for each time slot t, the amount of resource consumed by the tasks that are being processed must not exceed the resource’s capacity.

To model these constraints, we sum up, for each resource r, the weights of all the tasks it processes at time slot t.

The makespan to minimize is the time when all the tasks have been processed.

Execution:
localsolver flexible_cumulative.lsp inFileName=instances/pat1.fc [outFileName=] [lsTimeLimit=]
use io;

/* Read instance data.*/
function input() {
    local usage = "Usage: localsolver flexible_cumulative.lsp inFileName=instanceFile "
            + "[outFileName=outputFile] [lsTimeLimit=timeLimit]";
    if (inFileName == nil) throw usage;

    inFile = io.openRead(inFileName);
    // Number of tasks
    nbTasks = inFile.readInt();
    // Number of resources
    nbResources = inFile.readInt();

    // Maximum capacity of each resource
    capacity[r in 0...nbResources] = inFile.readInt();
    for [i in 0...nbTasks][r in 0...nbResources] {
        // Duration of task i if task i is done by resource r
        taskProcessingTime[i][r] = inFile.readInt();
        // Resource weight of resource r required for task i
        weight[r][i] = inFile.readInt(); 
    }

    for [i in 0...nbTasks] {
        // The number of successors of task i
        nbSuccessors[i] = inFile.readInt();
        // Successors of each task i
        for [s in 0...nbSuccessors[i]] {
            successors[i][s] = inFile.readInt();
        } 
    } 

    // Trivial upper bound for the start times of the tasks
    horizon = sum[i in 0...nbTasks](max[r in 0...nbResources](taskProcessingTime[i][r]));
    
    inFile.close();
}


function model() {
    // Set of tasks done by each resource
    resourcesTasks[r in 0...nbResources] <- set(nbTasks);

    // Only compatible resources can be selected for a task
    for [i in 0...nbTasks][r in 0...nbResources] {
        if (taskProcessingTime[i][r] == 0 && weight[r][i] == 0)
            constraint contains(resourcesTasks[r], i) == 0;
    }

    // All tasks are scheduled on the resources
    constraint partition[r in 0...nbResources](resourcesTasks[r]);

    // For each task, the selected resource
    taskResource[i in 0...nbTasks] <- find(resourcesTasks, i);

    // Interval decisions: time range of each task
    tasks[i in 0...nbTasks] <- interval(0, horizon);

    // Task duration constraints
    for [i in 0...nbTasks] {
        constraint length(tasks[i]) == taskProcessingTime[i][taskResource[i]];
    }

    // Precedence constraints between the tasks
    for [i in 0...nbTasks][s in 0...nbSuccessors[i]] {
        constraint tasks[i] < tasks[successors[i][s]];
    }

    // Makespan: end of the last task
    makespan <- max[i in 0...nbTasks](end(tasks[i]));

    // Cumulative resource constraints
    for [r in 0...nbResources] {
        constraint and(0...makespan, t => 
                sum(resourcesTasks[r], i => weight[r][i] * contains(tasks[i], t)) <= capacity[r]);
    }

    // Minimize the makespan
    minimize makespan;
}

/* Parameterize the solver */
function param() {
    if (lsTimeLimit == nil) lsTimeLimit = 60;
}

/* Write the solution in a file with the following format:
 *  - total makespan
 *  - for each task, the task id, the selected resource, the start and end times */
function output() {
    if (outFileName != nil) {
        outFile = io.openWrite(outFileName);
        println("Solution written in file ", outFileName);
        outFile.println(makespan.value);
        for [i in 0...nbTasks] {
            outFile.println(i, " ", taskResource[i].value, " ", tasks[i].value.start, " ", tasks[i].value.end);
        }
    }
}
Execution (Windows)
set PYTHONPATH=%LS_HOME%\bin\python
python flexible_cumulative.py instances\pat1.fc
Execution (Linux)
export PYTHONPATH=/opt/localsolver_12_0/bin/python
python flexible_cumulative.py instances/pat1.fc
import localsolver
import sys


def read_instance(filename):
    with open(filename) as f:
        lines = f.readlines()

    first_line = lines[0].split()

    # Number of tasks
    nb_tasks = int(first_line[0])

    # Number of resources
    nb_resources = int(first_line[1])

    # Maximum capacity of each resource
    capacity = [int(lines[1].split()[r]) for r in range(nb_resources)]

    # Duration of task i if task i is done by resource r
    task_processing_time_data = [[] for i in range(nb_tasks)]

    # Resource weight of resource r required for task i
    weight = [[] for r in range(nb_resources)]

    # Number of successors
    nb_successors = [0 for i in range(nb_tasks)]

    # Successors of each task i
    successors = [[] for i in range(nb_tasks)]

    for i in range(nb_tasks):
        line_d_w = lines[i + 2].split()
        for r in range(nb_resources):
            task_processing_time_data[i].append(int(line_d_w[2 * r]))
            weight[r].append(int(line_d_w[2 * r + 1]))

        line_succ = lines[i + 2 + nb_tasks].split()
        nb_successors[i] = int(line_succ[0])
        successors[i] = [int(elm) for elm in line_succ[1::]]

    # Trivial upper bound for the start times of the tasks
    horizon = sum(max(task_processing_time_data[i][r] for r in range(nb_resources)) for i in range(nb_tasks))

    return (nb_tasks, nb_resources, capacity, task_processing_time_data, weight, nb_successors, successors, horizon)


def main(instance_file, output_file, time_limit):
    nb_tasks, nb_resources, capacity, task_processing_time_data, weight,\
        nb_successors, successors, horizon = read_instance(instance_file)

    with localsolver.LocalSolver() as ls:
        #
        # Declare the optimization model
        #
        model = ls.model

        # Set of tasks done by each resource
        resources_tasks = [model.set(nb_tasks) for r in range(nb_resources)]
        resources = model.array(resources_tasks)

        # Only compatible resources can be selected for a task
        for i in range(nb_tasks):
            for r in range(nb_resources):
                if task_processing_time_data[i][r] == 0 and weight[r][i] == 0:
                    model.constraint(model.contains(resources_tasks[r], i) == 0)

        # For each task, the selected resource
        task_resource = [model.find(resources, t) for t in range(nb_tasks)]

        # All tasks are scheduled on the resources
        model.constraint(model.partition(resources))

        # Interval decisions: time range of each task
        tasks = [model.interval(0, horizon) for i in range(nb_tasks)]

        # Create LocalSolver arrays to be able to access them with an "at" operator
        tasks_array = model.array(tasks)
        task_processing_time = model.array(task_processing_time_data)
        weight_array = model.array(weight)

        # Task duration constraints
        for i in range(nb_tasks):
            model.constraint(model.length(tasks[i]) == task_processing_time[i][task_resource[i]])

        # Precedence constraints between the tasks
        for i in range(nb_tasks):
            for s in range(nb_successors[i]):
                model.constraint(tasks[i] < tasks[successors[i][s]])

        # Makespan: end of the last task
        makespan = model.max([model.end(tasks[i]) for i in range(nb_tasks)])

        # Cumulative resource constraints
        for r in range(nb_resources):
            capacity_respected = model.lambda_function(
                lambda t: model.sum(resources_tasks[r], model.lambda_function(
                    lambda i: model.at(weight_array, r, i) * model.contains(tasks_array[i], t)))
                <= capacity[r])
            model.constraint(model.and_(model.range(makespan), capacity_respected))

        # Minimize the makespan
        model.minimize(makespan)

        model.close()

        # Parameterize the solver
        ls.param.time_limit = time_limit

        ls.solve()

        #
        # Write the solution in a file with the following format:
        # - total makespan
        # - for each task, the task id, the selected resource, the start and end times
        #
        if output_file != None:
            with open(output_file, "w") as f:
                print("Solution written in file", output_file)
                f.write(str(makespan.value) + "\n")
                for i in range(nb_tasks):
                    f.write(
                        str(i) + " " + str(task_resource[i].value) + " " + str(tasks[i].value.start()) + " " +
                        str(tasks[i].value.end()))
                    f.write("\n")


if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python flexible_cumulative.py instance_file [output_file] [time_limit]")
        sys.exit(1)

    instance_file = sys.argv[1]
    output_file = sys.argv[2] if len(sys.argv) >= 3 else None
    time_limit = int(sys.argv[3]) if len(sys.argv) >= 4 else 60
    main(instance_file, output_file, time_limit)
Compilation / Execution (Windows)
cl /EHsc flexible_cumulative.cpp -I%LS_HOME%\include /link %LS_HOME%\bin\localsolver120.lib
flexible_cumulative instances\pat1.fc
Compilation / Execution (Linux)
g++ flexible_cumulative.cpp -I/opt/localsolver_12_0/include -llocalsolver120 -lpthread -o flexible_cumulative
./flexible_cumulative instances/pat1.fc
#include "localsolver.h"
#include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <numeric>
#include <vector>

using namespace localsolver;

class FlexibleCumulative {
private:
    // Number of tasks
    int nbTasks;
    // Number of resources
    int nbResources;
    // Maximum capacity of each resource
    std::vector<int> capacity;
    // Duration of task i if task i is done by resource r
    std::vector<std::vector<int>> taskProcessingTimeData;
    // Resource weight of resource r required for task i
    std::vector<std::vector<int>> weightData;
    // Number of successors
    std::vector<int> nbSuccessors;
    // Successors for each task i
    std::vector<std::vector<int>> successors;
    // Trivial upper bound for the start times of the tasks
    int horizon = 0;

    // Localsolver
    LocalSolver localsolver;
    // Decision variables: set of tasks done by each resource
    std::vector<LSExpression> resourcesTasks;
    // Decision variables: time range of each task
    std::vector<LSExpression> tasks;
    // For each task, the selected resource
    std::vector<LSExpression> taskResource;
    // Objective = minimize the makespan: end of the last task
    LSExpression makespan;

public:
    FlexibleCumulative(const std::string& fileName) : localsolver() {}

    void readInstance(const std::string& fileName) {
        std::ifstream infile;
        infile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        infile.open(fileName.c_str());

        infile >> nbTasks;
        infile >> nbResources;

        capacity.resize(nbResources);
        for (int r = 0; r < nbResources; ++r) {
            infile >> capacity[r];
        }

        taskProcessingTimeData.resize(nbTasks);
        weightData.resize(nbResources);

        for (int i = 0; i < nbTasks; ++i) {
            taskProcessingTimeData[i].resize(nbResources);
        }

        for (int r = 0; r < nbResources; ++r) {
            weightData[r].resize(nbTasks);
        }

        for (int i = 0; i < nbTasks; ++i) {
            for (int r = 0; r < nbResources; ++r) {
                infile >> taskProcessingTimeData[i][r];
                std::cout << i << " " << r << " " << taskProcessingTimeData[i][r] << std::endl;
                infile >> weightData[r][i];
            }
        }

        nbSuccessors.resize(nbTasks);
        successors.resize(nbTasks);

        for (int i = 0; i < nbTasks; ++i) {
            infile >> nbSuccessors[i];
            successors[i].resize(nbSuccessors[i]);
            for (int s = 0; s < nbSuccessors[i]; ++s) {
                infile >> successors[i][s];
            }
            horizon += *(std::max_element(taskProcessingTimeData[i].begin(), taskProcessingTimeData[i].end()));
        }

        infile.close();
    }

    void solve(int TimeLimit) {
        // Declare the optimization model
        LSModel model = localsolver.getModel();

        resourcesTasks.resize(nbResources);
        LSExpression resources = model.array();
        for (int r = 0; r < nbResources; ++r) {
            resourcesTasks[r] = model.setVar(nbTasks);
            resources.addOperand(resourcesTasks[r]);
        }

        // Create LocalSolver arrays to be able to access them with "at" operators
        LSExpression weight = model.array();
        for (int r = 0; r < nbResources; ++r) {
            weight.addOperand(model.array(weightData[r].begin(), weightData[r].end()));
        }
        LSExpression taskProcessingTime = model.array();
        for (int i = 0; i < nbTasks; ++i) {
            taskProcessingTime.addOperand(
                model.array(taskProcessingTimeData[i].begin(), taskProcessingTimeData[i].end()));
        }

        // Only compatible resources can be selected for a task
        for (int i = 0; i < nbTasks; ++i) {
            for (int r = 0; r < nbResources; ++r) {
                if (taskProcessingTimeData[i][r] == 0 && weightData[r][i] == 0) {
                    model.constraint(model.contains(resourcesTasks[r], i) == 0);
                }
            }
        }

        // All tasks are scheduled on the resources
        model.constraint(model.partition(resources));

        taskResource.resize(nbTasks);
        for (int i = 0; i < nbTasks; ++i) {
            // For each task, the selected resource
            taskResource[i] = model.find(resources, i);
        }

        tasks.resize(nbTasks);
        std::vector<LSExpression> duration(nbTasks);
        for (int i = 0; i < nbTasks; ++i) {
            // Interval decisions: time range of each task
            tasks[i] = model.intervalVar(0, horizon);

            // Task duration constraints
            model.constraint(model.eq(model.length(tasks[i]), taskProcessingTime[i][taskResource[i]]));
        }

        // Precedence constraints between the tasks
        for (int i = 0; i < nbTasks; ++i) {
            for (int s = 0; s < nbSuccessors[i]; ++s) {
                model.constraint(tasks[i] < tasks[successors[i][s]]);
            }
        }

        // Makespan: end of the last task
        makespan = model.max();
        for (int i = 0; i < nbTasks; ++i) {
            makespan.addOperand(model.end(tasks[i]));
        }

        // Create a LocalSolver array to be able to access it with "at" operator
        LSExpression tasksArray = model.array();
        for (int i = 0; i < nbTasks; ++i) {
            tasksArray.addOperand(tasks[i]);
        }

        // Cumulative resource constraints
        for (int r = 0; r < nbResources; ++r) {
            LSExpression capacityRespected = model.createLambdaFunction([&](LSExpression t) {
                LSExpression taskWeight = model.createLambdaFunction([&](LSExpression i) {
                    return model.at(weight, r, i) * model.contains(tasksArray[i], t);
                });
                LSExpression totalWeight = model.sum(resourcesTasks[r], taskWeight);
                return model.leq(totalWeight, capacity[r]);
            });
            model.constraint(model.and_(model.range(0, makespan), capacityRespected));
        }

        // Minimize the makespan
        model.minimize(makespan);

        model.close();

        // Parameterize the solver
        localsolver.getParam().setTimeLimit(TimeLimit);

        localsolver.solve();
    }

    /* Write the solution in a file with the following format:
     *  - total makespan
     *  - for each task, the task id, the selected resource, the start and end times */
    void writeSolution(const std::string& fileName) {
        std::ofstream outfile(fileName.c_str());
        if (!outfile.is_open()) {
            std::cerr << "File " << fileName << " cannot be opened." << std::endl;
            exit(1);
        }
        std::cout << "Solution written in file " << fileName << std::endl;

        outfile << makespan.getValue() << std::endl;
        for (int i = 0; i < nbTasks; ++i) {
            outfile << i << " " << taskResource[i].getValue() << " " << tasks[i].getIntervalValue().getStart() << " "
                    << tasks[i].getIntervalValue().getEnd() << std::endl;
        }
        outfile.close();
    }
};

int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Usage: flexible_cumulative instanceFile [outputFile] [timeLimit]" << std::endl;
        exit(1);
    }

    const char* instanceFile = argv[1];
    const char* outputFile = argc > 2 ? argv[2] : NULL;
    const char* strTimeLimit = argc > 3 ? argv[3] : "60";

    FlexibleCumulative model(instanceFile);
    try {
        model.readInstance(instanceFile);
        const int timeLimit = atoi(strTimeLimit);
        model.solve(timeLimit);
        if (outputFile != NULL)
            model.writeSolution(outputFile);
        return 0;
    } catch (const std::exception& e) {
        std::cerr << "An error occurred: " << e.what() << std::endl;
        return 1;
    }
}
Compilation / Execution (Windows)
copy %LS_HOME%\bin\localsolvernet.dll .
csc FlexibleCumulative.cs /reference:localsolvernet.dll
FlexibleCumulative instances\pat1.fc
using System;
using System.IO;
using System.Linq;
using localsolver;

public class FlexibleCumulative : IDisposable
{
    // Number of tasks
    private int nbTasks;

    // Number of resources
    private int nbResources;

    // Maximum capacity of each resource
    private int[] capacity;

    // Duration of task i if task i is done by resource r
    private int[][] taskProcessingTimeData;

    // Resource weight of resource r required for task i
    private int[][] weightData;

    // Number of successors
    private int[] nbSuccessors;

    // Successors for each task i
    private int[][] successors;

    // Trivial upper bound for the start times of the tasks
    private int horizon = 0;

    // LocalSolver
    private LocalSolver localsolver;

    // Decision variables: set of tasks done by each resource
    private LSExpression[] resourcesTasks;

    // Decision variables: time range of each task
    private LSExpression[] tasks;

    // For each task, the selected resource
    private LSExpression[] taskResource;

    // Objective = minimize the makespan: end of the last task
    private LSExpression makespan;

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

    private static string[] ReadNextLine(StreamReader input) {
        return input.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    private void ReadInstance(string fileName)
    {
        using (StreamReader input = new StreamReader(fileName))
        {
            string[] splitted = ReadNextLine(input);
            if (splitted.Length == 0)
                splitted = ReadNextLine(input);
            nbTasks = int.Parse(splitted[0]);
            nbResources = int.Parse(splitted[1]);

            capacity = new int[nbResources];
            splitted = ReadNextLine(input);
            for (int r = 0; r < nbResources; ++r)
                capacity[r] = int.Parse(splitted[r]);

            taskProcessingTimeData = new int[nbTasks][];
            for (int i = 0; i < nbTasks; i++)
                taskProcessingTimeData[i] = new int[nbResources];

            weightData = new int[nbResources][];
            for (int r = 0; r < nbResources; r++)
                weightData[r] = new int[nbTasks];

            for (int i = 0; i < nbTasks; ++i)
            {
                splitted = ReadNextLine(input);
                if (splitted.Length == 0)
                    splitted = ReadNextLine(input);
                for (int r = 0; r < nbResources; ++r)
                {
                    taskProcessingTimeData[i][r] = int.Parse(splitted[2 * r]);
                    weightData[r][i] = int.Parse(splitted[2 * r + 1]);
                }
            }

            nbSuccessors = new int[nbTasks];
            successors = new int[nbTasks][];

            for (int i = 0; i < nbTasks; ++i)
            {
                splitted = ReadNextLine(input);
                if (splitted.Length == 0)
                    splitted = ReadNextLine(input);
                nbSuccessors[i] = int.Parse(splitted[0]);
                successors[i] = new int[nbSuccessors[i]];
                for (int s = 0; s < nbSuccessors[i]; ++s)
                    successors[i][s] = int.Parse(splitted[s + 1]);
                horizon += (taskProcessingTimeData[i]).Max();
            }
        }
    }

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

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

        resourcesTasks = new LSExpression[nbResources];

        for (int r = 0; r < nbResources; ++r)
            resourcesTasks[r] = model.Set(nbTasks);

        // Create LocalSolver arrays to be able to access them with "at" operators
        LSExpression resources = model.Array(resourcesTasks);
        LSExpression weight = model.Array(weightData);
        LSExpression taskProcessingTime = model.Array(taskProcessingTimeData);

        // Only compatible resources can be selected for a task
        for (int i = 0; i < nbTasks; ++i)
        {
            for (int r = 0; r < nbResources; ++r)
            {
                if (taskProcessingTimeData[i][r] == 0 && weightData[r][i] == 0)
                {
                    model.Constraint(model.Contains(resourcesTasks[r], i) == 0);
                }
            }
        }

        // All tasks are scheduled on the resources
        model.Constraint(model.Partition(resources));

        taskResource = new LSExpression[nbTasks];
        for (int i = 0; i < nbTasks; ++i)
        {
            // For each task, the selected resource
            taskResource[i] = model.Find(resources, i);
        }

        tasks = new LSExpression[nbTasks];
        for (int i = 0; i < nbTasks; ++i)
        {
            // Interval decisions: time range of each task
            tasks[i] = model.Interval(0, horizon);

            // Task duration constraints
            LSExpression iExpr = model.CreateConstant(i);
            LSExpression duration = model.At(taskProcessingTime, iExpr, taskResource[i]);
            model.Constraint(model.Length(tasks[i]) == duration);
        }

        // Create a LocalSolver array to be able to access it with "at" operator
        LSExpression tasksArray = model.Array();
        for (int i = 0; i < nbTasks; ++i)
            tasksArray.AddOperand(tasks[i]);

        // Precedence constraints between the tasks
        for (int i = 0; i < nbTasks; ++i)
        {
            for (int s = 0; s < nbSuccessors[i]; ++s)
            {
                model.Constraint(tasks[i] < tasks[successors[i][s]]);
            }
        }

        // Makespan: end of the last task
        makespan = model.Max();
        for (int i = 0; i < nbTasks; ++i)
            makespan.AddOperand(model.End(tasks[i]));

        // Cumulative resource constraints
        for (int r = 0; r < nbResources; ++r)
        {
            LSExpression capacityRespected = model.LambdaFunction(t =>
                {
                    LSExpression taskWeight = model.LambdaFunction(i =>
                    {
                        LSExpression rExpr = model.CreateConstant(r);
                        return model.At(weight, rExpr, i) * model.Contains(tasksArray[i], t);
                    });
                    LSExpression totalWeight = model.Sum(resourcesTasks[r], taskWeight);
                    return totalWeight <= capacity[r];
                });
            model.Constraint(model.And(model.Range(0, makespan), capacityRespected));
        }

        // Minimize the makespan
        model.Minimize(makespan);

        model.Close();

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

        localsolver.Solve();
    }

    /* Write the solution in a file with the following format:
     *  - total makespan
     *  - for each task, the task id, the selected resource, the start and end times */
    public void WriteSolution(string fileName)
    {
        using (StreamWriter output = new StreamWriter(fileName))
        {
            Console.WriteLine("Solution written in file " + fileName);
            output.WriteLine(makespan.GetValue());
            for (int i = 0; i < nbTasks; ++i)
            {
                output.Write(i + " " + taskResource[i].GetValue() + " " + tasks[i].GetIntervalValue().Start() + " "
                        + tasks[i].GetIntervalValue().End());
                output.WriteLine();
            }
        }
    }

    public static void Main(string[] args)
    {
        if (args.Length < 1)
        {
            Console.WriteLine("Usage: FlexibleCumulative 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 (FlexibleCumulative model = new FlexibleCumulative(instanceFile))
        {
            model.ReadInstance(instanceFile);
            model.Solve(int.Parse(strTimeLimit));
            if (outputFile != null)
                model.WriteSolution(outputFile);
        }
    }
}
Compilation / Execution (Windows)
javac FlexibleCumulative.java -cp %LS_HOME%\bin\localsolver.jar
java -cp %LS_HOME%\bin\localsolver.jar;. FlexibleCumulative instances\pat1.fc
Compilation / Execution (Linux)
javac FlexibleCumulative.java -cp /opt/localsolver_12_0/bin/localsolver.jar
java -cp /opt/localsolver_12_0/bin/localsolver.jar:. FlexibleCumulative instances/pat1.fc
import java.util.*;
import java.io.*;
import localsolver.*;

public class FlexibleCumulative {
    // Number of tasks
    private int nbTasks;
    // Number of resources
    private int nbResources;
    // Maximum capacity of each resource
    private int[] capacity;
    // Duration of task i if task i is done by resource r
    private int[][] taskProcessingTimeData;
    // Resource weight of resource r required for task i
    private int[][] weightData;
    // Number of successors
    private int[] nbSuccessors;
    // Successors for each task i
    private int[][] successors;
    // Trivial upper bound for the start times of the tasks
    private int horizon = 0;

    // LocalSolver
    final LocalSolver localsolver;
    // Decision variables: set of tasks done by each resource
    private LSExpression[] resourcesTasks;
    // Decision variables: time range of each task
    private LSExpression[] tasks;
    // For each task, the selected resource
    private LSExpression[] taskResource;
    // Objective = minimize the makespan: end of the last task
    private LSExpression makespan;

    public FlexibleCumulative(LocalSolver localsolver, String fileName) throws IOException {
        this.localsolver = localsolver;
    }

    private void readInstance(String fileName) throws IOException {
        try (Scanner input = new Scanner(new File(fileName))) {
            nbTasks = input.nextInt();
            nbResources = input.nextInt();

            capacity = new int[nbResources];
            for (int r = 0; r < nbResources; ++r) {
                capacity[r] = input.nextInt();
            }

            taskProcessingTimeData = new int[nbTasks][nbResources];
            weightData = new int[nbResources][nbTasks];
            nbSuccessors = new int[nbTasks];
            successors = new int[nbTasks][];
            for (int i = 0; i < nbTasks; ++i) {
                for (int r = 0; r < nbResources; ++r) {
                    taskProcessingTimeData[i][r] = input.nextInt();
                    weightData[r][i] = input.nextInt();
                }
            }
            for (int i = 0; i < nbTasks; ++i) {
                nbSuccessors[i] = input.nextInt();
                successors[i] = new int[nbSuccessors[i]];
                for (int s = 0; s < nbSuccessors[i]; ++s) {
                    successors[i][s] = input.nextInt();
                }

                int maxDurationTask = taskProcessingTimeData[i][0];
                for (int r = 0; r < nbResources; ++r) {
                    if (taskProcessingTimeData[i][r] > taskProcessingTimeData[i][0]) {
                        maxDurationTask = taskProcessingTimeData[i][r];
                    }
                }
                horizon += maxDurationTask;
            }
        }
    }

    public void solve(int timeLimit) {
        // Declare the optimization model
        LSModel model = localsolver.getModel();

        resourcesTasks = new LSExpression[nbResources];

        for (int r = 0; r < nbResources; ++r) {
            resourcesTasks[r] = model.setVar(nbTasks);
        }
        // Create LocalSolver arrays to be able to access them with "at" operators
        LSExpression resources = model.array(resourcesTasks);
        LSExpression weight = model.array(weightData);
        LSExpression taskProcessingTime = model.array(taskProcessingTimeData);

        // Only compatible resources can be selected for a task
        for (int i = 0; i < nbTasks; ++i) {
            for (int r = 0; r < nbResources; ++r) {
                if (taskProcessingTimeData[i][r] == 0 && weightData[r][i] == 0) {
                    model.constraint(model.eq(model.contains(resourcesTasks[r], i), 0));
                }
            }
        }
        
        // All tasks are scheduled on the resources
        model.constraint(model.partition(resources));
        
        taskResource = new LSExpression[nbTasks];
        for (int i = 0; i < nbTasks; ++i) {
            // For each task, the selected resource
            taskResource[i] = model.find(resources, i);
        }

        tasks = new LSExpression[nbTasks];
        for (int i = 0; i < nbTasks; ++i) {
            // Interval decisions: time range of each task
            tasks[i] = model.intervalVar(0, horizon);

            // Task duration constraints
            LSExpression iExpr = model.createConstant(i);
            LSExpression duration = model.at(taskProcessingTime, iExpr, taskResource[i]);
            model.constraint(model.eq(model.length(tasks[i]), duration));
        }

        // Create a LocalSolver array to be able to access it with "at" operator
        LSExpression tasksArray = model.array();
        for (int i = 0; i < nbTasks; ++i) {
            tasksArray.addOperand(tasks[i]);
        }

        // Precedence constraints between the tasks
        for (int i = 0; i < nbTasks; ++i) {
            for (int s = 0; s < nbSuccessors[i]; ++s) {
                model.constraint(model.lt(tasks[i], tasks[successors[i][s]]));
            }
        }

        // Makespan: end of the last task
        makespan = model.max();
        for (int i = 0; i < nbTasks; ++i) {
            makespan.addOperand(model.end(tasks[i]));
        }

        // Cumulative resource constraints
        for (int r = 0; r < nbResources; ++r) {
            final int rL = r;
            LSExpression capacityRespected = model.lambdaFunction(t -> {
                LSExpression taskWeight = model.lambdaFunction(i -> {
                    LSExpression rExpr = model.createConstant(rL);
                    return model.prod(
                           model.at(weight, rExpr, i),
                           model.contains(model.at(tasksArray, i), t));
                });
                LSExpression totalWeight = model.sum(resourcesTasks[rL], taskWeight);
                return model.leq(totalWeight, capacity[rL]);
            });
            model.constraint(model.and(model.range(0, makespan), capacityRespected));
        }

        // Minimize the makespan
        model.minimize(makespan);
        model.close();

        // Parameterize the solver
        localsolver.getParam().setTimeLimit(timeLimit);

        localsolver.solve();
    }

    /*
     * Write the solution in a file with the following format:
     * - total makespan
     * - for each task, the task id, the selected resource, the start and end times
     */
    public void writeSolution(String fileName) throws IOException {
        try (PrintWriter output = new PrintWriter(fileName)) {
            System.out.println("Solution written in file " + fileName);

            output.println(makespan.getValue());

            for (int i = 0; i < nbTasks; ++i) {
                output.println(i + " " + taskResource[i].getValue() + " " + tasks[i].getIntervalValue().getStart() + " "
                        + tasks[i].getIntervalValue().getEnd());
            }
        }
    }

    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("Usage: java FlexibleCumulative instanceFile [outputFile] [timeLimit]");
            System.exit(1);
        }

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

        try (LocalSolver localsolver = new LocalSolver()) {
            FlexibleCumulative model = new FlexibleCumulative(localsolver, instanceFile);
            model.readInstance(instanceFile);
            model.solve(Integer.parseInt(strTimeLimit));
            if (outputFile != null) {
                model.writeSolution(outputFile);
            }
        } catch (Exception ex) {
            System.err.println(ex);
            ex.printStackTrace();
            System.exit(1);
        }
    }
}