Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hello Fam Saeed,

              In your model, a sequence var is defined for each worker. You can use the constraint before on the sequence variables to model your additional constraint:

"before(p, a, b) states that if both intervals a and b are present, a will appear before b in the sequence p."

The code might look like this:

  forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)

               if (a1.resource == worker1 && a2.dmd.id < a1.dmd.id )

                              before(workers[worker1], tiallocs[a2], tiallocs[a1]);

                else if(a1.resource == worker2 && a1.dmd.id in {7,6,5,4}  &&  a2.dmd.id in {7,6,5,4}  &&  a2.dmd.id < a1.dmd.id )

                             before(workers[worker2], tiallocs[a1], tiallocs[a2]);

               …

      In this example, for the worker2, the additional constraint is not applied for the fisrt three units.

      Otherwise, there is always the possibility using the constraint startBeforeStart(a,b,z) where z is the duration of a.

      Best regards,

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hello Thierry Sola,

Thanks again!

I changed the constraint a little bit to match my intended goal.

forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)
      if (a2.dmd.id < a1.dmd.id )
      before(workers[a1.resource], tiallocs[a2], tiallocs[a1]);
         else if(a2.dmd.id > a1.dmd.id )
         before(workers[a1.resource], tiallocs[a1], tiallocs[a2]);

I am trying to make the workers work across the different units sequentially (descending or ascending). So far it was a success. Now, I need to minimize the differences between the Unit IDs in the sequence for all the crews (workers).

Minimize the sum of (a2.dmd.id - a1.dmd.id) for all workers.

In other words, for a single task with 3 crews working across 10 units, I need the crew assignment to be something like: Crew1 > units 3, 4, 5, 6 - Crew2 > 2, 1 - Crew3 > 7, 8, 9, 10. Or any other assignment for the crews but following the same rule.

I would appreciate your help with this one,

Regards, Fam

Hello Fam Saeed,

              In your model, a sequence var is defined for each worker. You can use the constraint before on the sequence variables to model your additional constraint:

"before(p, a, b) states that if both intervals a and b are present, a will appear before b in the sequence p."

The code might look like this:

  forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)

               if (a1.resource == worker1 && a2.dmd.id < a1.dmd.id )

                              before(workers[worker1], tiallocs[a2], tiallocs[a1]);

                else if(a1.resource == worker2 && a1.dmd.id in {7,6,5,4}  &&  a2.dmd.id in {7,6,5,4}  &&  a2.dmd.id < a1.dmd.id )

                             before(workers[worker2], tiallocs[a1], tiallocs[a2]);

               …

      In this example, for the worker2, the additional constraint is not applied for the fisrt three units.

      Otherwise, there is always the possibility using the constraint startBeforeStart(a,b,z) where z is the duration of a.

      Best regards,

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hello Fam Saeed,

              Regarding your "before" constraints, they enforce the ascending order for all the resources (workers).

You can use sequence variables defined for each worker. You define a type for each interval variable tiallocs[a] where a is in allocs. The type of this interval variable should match with the unit of a (the house number associated to this task).           

This will allow you to know the unit of each task associated with a given worker.

The function typeOfNext, defined on a sequence variable (seq), returns the type of the interval variable that is next to the interval variable (interval)  in sequence (seq).

intExpr typeOfNext(sequenceVar seq, intervalVar interval, int lastValue = 0, int absentValue = 0)

"This function returns an integer expression that represents the type of the interval variable that is next to interval in sequence variable seq. When interval is present and is the last interval of seq, it returns the constant integer value lastValue (zero by default). When interval is absent, it returns the constant integer value absentValue (zero by default)."

Using this function, it's possible to compute the "differences between the Unit IDs in the sequence for all the crews (workers)".

int deltaHouse[r in resources][t1 in houseTypes][t2 in houseTypes] =  (abs(t1-t2) <= 1)?0:1;

where:

range houseTypes = 0..NbHouses-1;

int taskType[a in allocs] = (a.dmd.id-1) div NoTasks;

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) taskType[a] ;

At this point you can create an expression that is the sum of all deltaHouse for all workers:

dexpr int globalDifferences = sum(r in resources, a in allocs : a.resource == r)

deltaHouse [r][taskType[a]][typeOfNext(workers[r],tiallocs[a],taskType[a],taskType[a])];

Now, you can minimize this expression.

There is an example that using this function: CPLEX_Studio2211\opl\examples\opl\sched_tcost.

Best regards,

Hello Thierry Sola,

Thanks again!

I changed the constraint a little bit to match my intended goal.

forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)
      if (a2.dmd.id < a1.dmd.id )
      before(workers[a1.resource], tiallocs[a2], tiallocs[a1]);
         else if(a2.dmd.id > a1.dmd.id )
         before(workers[a1.resource], tiallocs[a1], tiallocs[a2]);

I am trying to make the workers work across the different units sequentially (descending or ascending). So far it was a success. Now, I need to minimize the differences between the Unit IDs in the sequence for all the crews (workers).

Minimize the sum of (a2.dmd.id - a1.dmd.id) for all workers.

In other words, for a single task with 3 crews working across 10 units, I need the crew assignment to be something like: Crew1 > units 3, 4, 5, 6 - Crew2 > 2, 1 - Crew3 > 7, 8, 9, 10. Or any other assignment for the crews but following the same rule.

I would appreciate your help with this one,

Regards, Fam

Hello Fam Saeed,

              In your model, a sequence var is defined for each worker. You can use the constraint before on the sequence variables to model your additional constraint:

"before(p, a, b) states that if both intervals a and b are present, a will appear before b in the sequence p."

The code might look like this:

  forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)

               if (a1.resource == worker1 && a2.dmd.id < a1.dmd.id )

                              before(workers[worker1], tiallocs[a2], tiallocs[a1]);

                else if(a1.resource == worker2 && a1.dmd.id in {7,6,5,4}  &&  a2.dmd.id in {7,6,5,4}  &&  a2.dmd.id < a1.dmd.id )

                             before(workers[worker2], tiallocs[a1], tiallocs[a2]);

               …

      In this example, for the worker2, the additional constraint is not applied for the fisrt three units.

      Otherwise, there is always the possibility using the constraint startBeforeStart(a,b,z) where z is the duration of a.

      Best regards,

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hello Thierry Sola,

Thanks so much for all your help.
I tried the following code:
range houseTypes = 0..NbHouses-1;
int taskType[a in allocs] = (a.dmd.id-1) div NoTasks;
float deltaHouse[r in resources][t1 in houseTypes][t2 in houseTypes] =  (abs(t1-t2) <= 1)?0:abs(t1-t2);
dvar sequence crews[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) taskType[a] ;
dexpr float globalDifferences = sum(r in resources, a in allocs : a.resource == r)
deltaHouse [r][taskType[a]][typeOfNext(crews[r],tiallocs[a],taskType[a],taskType[a])];
 

And I added a constraint that globalDifferences == 0
And an objective function to minimize the total duration.
It did not work. The solver engine kept trying to find a feasible solution with no success.

I tried a modified version of this code as follows:

range houseTypes = 0..NbHouses-1;
int taskType[a in allocs] = (a.dmd.id-1) div NoTasks;
float deltaHouse[r in resources][t1 in houseTypes][t2 in houseTypes] =  (abs(t1-t2) <= 1)?0:abs(t1-t2);
dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ; 
dexpr float globalDifferences = sum(r in resources, a in allocs : a.resource == r)
    deltaHouse [r][taskType[a]][typeOfNext(workers[r],tiallocs[a],taskType[a],taskType[a])];

However the code worked and the constraint of the global differences was satisfied, but the solution was incorrect. See attached screenshot for the workers:

I really appreciate your thoughts and help,
Fam
 

Hello Fam Saeed,

              Regarding your "before" constraints, they enforce the ascending order for all the resources (workers).

You can use sequence variables defined for each worker. You define a type for each interval variable tiallocs[a] where a is in allocs. The type of this interval variable should match with the unit of a (the house number associated to this task).           

This will allow you to know the unit of each task associated with a given worker.

The function typeOfNext, defined on a sequence variable (seq), returns the type of the interval variable that is next to the interval variable (interval)  in sequence (seq).

intExpr typeOfNext(sequenceVar seq, intervalVar interval, int lastValue = 0, int absentValue = 0)

"This function returns an integer expression that represents the type of the interval variable that is next to interval in sequence variable seq. When interval is present and is the last interval of seq, it returns the constant integer value lastValue (zero by default). When interval is absent, it returns the constant integer value absentValue (zero by default)."

Using this function, it's possible to compute the "differences between the Unit IDs in the sequence for all the crews (workers)".

int deltaHouse[r in resources][t1 in houseTypes][t2 in houseTypes] =  (abs(t1-t2) <= 1)?0:1;

where:

range houseTypes = 0..NbHouses-1;

int taskType[a in allocs] = (a.dmd.id-1) div NoTasks;

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) taskType[a] ;

At this point you can create an expression that is the sum of all deltaHouse for all workers:

dexpr int globalDifferences = sum(r in resources, a in allocs : a.resource == r)

deltaHouse [r][taskType[a]][typeOfNext(workers[r],tiallocs[a],taskType[a],taskType[a])];

Now, you can minimize this expression.

There is an example that using this function: CPLEX_Studio2211\opl\examples\opl\sched_tcost.

Best regards,

Hello Thierry Sola,

Thanks again!

I changed the constraint a little bit to match my intended goal.

forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)
      if (a2.dmd.id < a1.dmd.id )
      before(workers[a1.resource], tiallocs[a2], tiallocs[a1]);
         else if(a2.dmd.id > a1.dmd.id )
         before(workers[a1.resource], tiallocs[a1], tiallocs[a2]);

I am trying to make the workers work across the different units sequentially (descending or ascending). So far it was a success. Now, I need to minimize the differences between the Unit IDs in the sequence for all the crews (workers).

Minimize the sum of (a2.dmd.id - a1.dmd.id) for all workers.

In other words, for a single task with 3 crews working across 10 units, I need the crew assignment to be something like: Crew1 > units 3, 4, 5, 6 - Crew2 > 2, 1 - Crew3 > 7, 8, 9, 10. Or any other assignment for the crews but following the same rule.

I would appreciate your help with this one,

Regards, Fam

Hello Fam Saeed,

              In your model, a sequence var is defined for each worker. You can use the constraint before on the sequence variables to model your additional constraint:

"before(p, a, b) states that if both intervals a and b are present, a will appear before b in the sequence p."

The code might look like this:

  forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)

               if (a1.resource == worker1 && a2.dmd.id < a1.dmd.id )

                              before(workers[worker1], tiallocs[a2], tiallocs[a1]);

                else if(a1.resource == worker2 && a1.dmd.id in {7,6,5,4}  &&  a2.dmd.id in {7,6,5,4}  &&  a2.dmd.id < a1.dmd.id )

                             before(workers[worker2], tiallocs[a1], tiallocs[a2]);

               …

      In this example, for the worker2, the additional constraint is not applied for the fisrt three units.

      Otherwise, there is always the possibility using the constraint startBeforeStart(a,b,z) where z is the duration of a.

      Best regards,

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hello Fam Saeed,

              Regarding your "before" constraints, they enforce the ascending order for all the resources (workers).

You can use sequence variables defined for each worker. You define a type for each interval variable tiallocs[a] where a is in allocs. The type of this interval variable should match with the unit of a (the house number associated to this task).           

This will allow you to know the unit of each task associated with a given worker.

The function typeOfNext, defined on a sequence variable (seq), returns the type of the interval variable that is next to the interval variable (interval)  in sequence (seq).

intExpr typeOfNext(sequenceVar seq, intervalVar interval, int lastValue = 0, int absentValue = 0)

"This function returns an integer expression that represents the type of the interval variable that is next to interval in sequence variable seq. When interval is present and is the last interval of seq, it returns the constant integer value lastValue (zero by default). When interval is absent, it returns the constant integer value absentValue (zero by default)."

Using this function, it's possible to compute the "differences between the Unit IDs in the sequence for all the crews (workers)".

int deltaHouse[r in resources][t1 in houseTypes][t2 in houseTypes] =  (abs(t1-t2) <= 1)?0:1;

where:

range houseTypes = 0..NbHouses-1;

int taskType[a in allocs] = (a.dmd.id-1) div NoTasks;

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) taskType[a] ;

At this point you can create an expression that is the sum of all deltaHouse for all workers:

dexpr int globalDifferences = sum(r in resources, a in allocs : a.resource == r)

deltaHouse [r][taskType[a]][typeOfNext(workers[r],tiallocs[a],taskType[a],taskType[a])];

Now, you can minimize this expression.

There is an example that using this function: CPLEX_Studio2211\opl\examples\opl\sched_tcost.

Best regards,

Hello Thierry Sola,

Thanks again!

I changed the constraint a little bit to match my intended goal.

forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)
      if (a2.dmd.id < a1.dmd.id )
      before(workers[a1.resource], tiallocs[a2], tiallocs[a1]);
         else if(a2.dmd.id > a1.dmd.id )
         before(workers[a1.resource], tiallocs[a1], tiallocs[a2]);

I am trying to make the workers work across the different units sequentially (descending or ascending). So far it was a success. Now, I need to minimize the differences between the Unit IDs in the sequence for all the crews (workers).

Minimize the sum of (a2.dmd.id - a1.dmd.id) for all workers.

In other words, for a single task with 3 crews working across 10 units, I need the crew assignment to be something like: Crew1 > units 3, 4, 5, 6 - Crew2 > 2, 1 - Crew3 > 7, 8, 9, 10. Or any other assignment for the crews but following the same rule.

I would appreciate your help with this one,

Regards, Fam

Hello Fam Saeed,

              In your model, a sequence var is defined for each worker. You can use the constraint before on the sequence variables to model your additional constraint:

"before(p, a, b) states that if both intervals a and b are present, a will appear before b in the sequence p."

The code might look like this:

  forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)

               if (a1.resource == worker1 && a2.dmd.id < a1.dmd.id )

                              before(workers[worker1], tiallocs[a2], tiallocs[a1]);

                else if(a1.resource == worker2 && a1.dmd.id in {7,6,5,4}  &&  a2.dmd.id in {7,6,5,4}  &&  a2.dmd.id < a1.dmd.id )

                             before(workers[worker2], tiallocs[a1], tiallocs[a2]);

               …

      In this example, for the worker2, the additional constraint is not applied for the fisrt three units.

      Otherwise, there is always the possibility using the constraint startBeforeStart(a,b,z) where z is the duration of a.

      Best regards,

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.

Best regards,

Hello,
I am modifying the Sched_tasks example to make it applicable to optimize several tasks across scattered units with different durations.

Here is my .mod file:

Here is my .dat file

Hi Thierry,

Thanks for your prompt response.

I have sent you a private message with both the .mod and .dat inputs.
As well, here is the .dat input.

Hello Fam Saeed,

              Regarding your "before" constraints, they enforce the ascending order for all the resources (workers).

You can use sequence variables defined for each worker. You define a type for each interval variable tiallocs[a] where a is in allocs. The type of this interval variable should match with the unit of a (the house number associated to this task).           

This will allow you to know the unit of each task associated with a given worker.

The function typeOfNext, defined on a sequence variable (seq), returns the type of the interval variable that is next to the interval variable (interval)  in sequence (seq).

intExpr typeOfNext(sequenceVar seq, intervalVar interval, int lastValue = 0, int absentValue = 0)

"This function returns an integer expression that represents the type of the interval variable that is next to interval in sequence variable seq. When interval is present and is the last interval of seq, it returns the constant integer value lastValue (zero by default). When interval is absent, it returns the constant integer value absentValue (zero by default)."

Using this function, it's possible to compute the "differences between the Unit IDs in the sequence for all the crews (workers)".

int deltaHouse[r in resources][t1 in houseTypes][t2 in houseTypes] =  (abs(t1-t2) <= 1)?0:1;

where:

range houseTypes = 0..NbHouses-1;

int taskType[a in allocs] = (a.dmd.id-1) div NoTasks;

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) taskType[a] ;

At this point you can create an expression that is the sum of all deltaHouse for all workers:

dexpr int globalDifferences = sum(r in resources, a in allocs : a.resource == r)

deltaHouse [r][taskType[a]][typeOfNext(workers[r],tiallocs[a],taskType[a],taskType[a])];

Now, you can minimize this expression.

There is an example that using this function: CPLEX_Studio2211\opl\examples\opl\sched_tcost.

Best regards,

Hello Thierry Sola,

Thanks again!

I changed the constraint a little bit to match my intended goal.

forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)
      if (a2.dmd.id < a1.dmd.id )
      before(workers[a1.resource], tiallocs[a2], tiallocs[a1]);
         else if(a2.dmd.id > a1.dmd.id )
         before(workers[a1.resource], tiallocs[a1], tiallocs[a2]);

I am trying to make the workers work across the different units sequentially (descending or ascending). So far it was a success. Now, I need to minimize the differences between the Unit IDs in the sequence for all the crews (workers).

Minimize the sum of (a2.dmd.id - a1.dmd.id) for all workers.

In other words, for a single task with 3 crews working across 10 units, I need the crew assignment to be something like: Crew1 > units 3, 4, 5, 6 - Crew2 > 2, 1 - Crew3 > 7, 8, 9, 10. Or any other assignment for the crews but following the same rule.

I would appreciate your help with this one,

Regards, Fam

Hello Fam Saeed,

              In your model, a sequence var is defined for each worker. You can use the constraint before on the sequence variables to model your additional constraint:

"before(p, a, b) states that if both intervals a and b are present, a will appear before b in the sequence p."

The code might look like this:

  forall(a1 in allocs, a2 in allocs: a1.resource == a2.resource)

               if (a1.resource == worker1 && a2.dmd.id < a1.dmd.id )

                              before(workers[worker1], tiallocs[a2], tiallocs[a1]);

                else if(a1.resource == worker2 && a1.dmd.id in {7,6,5,4}  &&  a2.dmd.id in {7,6,5,4}  &&  a2.dmd.id < a1.dmd.id )

                             before(workers[worker2], tiallocs[a1], tiallocs[a2]);

               …

      In this example, for the worker2, the additional constraint is not applied for the fisrt three units.

      Otherwise, there is always the possibility using the constraint startBeforeStart(a,b,z) where z is the duration of a.

      Best regards,

Hi Thierry Sola,

Thanks so much for your great help!
I have one more part that I need your help with.

I need to add a constraint that each worker (resource) can work across the units only in a sequential order. As an example, worker1 > units 1,2,3,4, etc or worker 2 > units 7,6,5,4, etc.

I would appreciate any help.
Regards,

Hello Fam,

             In your example "tasksAsTuples" corresponds to "operations" in the Sched_tasks example.

You can update your definition as follows:

{ListOfTask} tasksAsTuples = {<(h-1)*NoTasks + i, TaskNames[i]> | i in TasksRange, h in HousesRange};

You want to build NbHouses houses.

Regarding the sequence variables, if you want to take into account the transition times, you have to define a type for each interval vars.

dvar sequence workers[r in resources] in all(a in allocs: a.resource == r) tiallocs[a] types all(a in allocs: a.resource == r) (((a.dmd.id-1) div NoTasks)+1) ;

Regarding the cumul functions, "tasksAsTuples" contains now all the operations for all the houses, you can update your code as follows:

cumulFunction cumuls[rt in resourceTypes] =

  sum(rc in requirements, tn in tasksAsTuples : rc.resource == rt && tn.TaskName == rc.task) pulse(itvs[((tn.id-1) div NoTasks) + 1][((tn.id mod NoTasks) == 0 ? NoTasks:(tn.id mod NoTasks))], rc.quantity);

In the Sched_tasks example, the tiops interval variables are linked to the tiallocs interval variables using alternatives.

You need to do the same thing between itvs and tiallocs interval variables:

forall(h in HousesRange) {

  forall(t in TasksRange) {

    forall (rc in requirements : rc.task == TaskNames[t]) {

             alternative(itvs[h][t], all(a in allocs : a.dmd.id == (h-1)*NoTasks+t) tiallocs[a], rc.quantity);

   }        

  }

} 

Regarding the redundant cumul function, you can keep the same as in Sched_tasks example:

  forall(r in resourceTypes: levels[r] > 1) {

    cumuls[r] <= levels[r];

  } 

In your example you set some parameters. For them to be taken into account, you must define them before defining your objective function.