discrete_optimization.rcpsp_blocking_resource package

Submodules

discrete_optimization.rcpsp_blocking_resource.blocking_generator module

Generator for RCPSP instances with resource blocking constraints.

This module provides utilities to generate RCPSP problems with blocking constraints from standard RCPSP instances. It creates realistic scenarios such as: - Setup times between tasks using same resources - Changeover periods between task modes - Project-level resource reservations

discrete_optimization.rcpsp_blocking_resource.blocking_generator.generate_batch_blocking(base_problem: RcpspProblem, batch_size: int = 3, resource_name: str | None = None, seed: int | None = None, blocking_intensity: float = 0.2) → RcpspWithResourceBlocking[source]

Generate RCPSP with span blocking for batch processing.

Creates span blocking constraints where groups of tasks must reserve a portion of resources for their entire execution span. Since blocking is ADDITIVE (task + blocking <= capacity), the blocking amount is carefully chosen to avoid infeasibilities.

Parameters:

  • base_problem – Original RCPSP problem

  • batch_size – Number of tasks per batch

  • resource_name – Resource to block (None = first renewable resource)

  • seed – Random seed for batch generation

  • blocking_intensity – Fraction of AVAILABLE capacity to block (default 0.4 = 40%) Available capacity = total capacity - max batch task consumption

Returns:

RcpspWithResourceBlocking with span blocking constraints for batches

Example

>>> from discrete_optimization.rcpsp.parser import parse_file, get_data_available
>>> files = get_data_available()
>>> base_problem = parse_file(files[0])
>>> problem_with_batches = generate_batch_blocking(base_problem, blocking_intensity=0.6)
discrete_optimization.rcpsp_blocking_resource.blocking_generator.generate_combined_blocking(base_problem: RcpspProblem, setup_ratio: float = 0.2, batch_size: int = 3, seed: int | None = None) → RcpspWithResourceBlocking[source]

Generate RCPSP with both setup time and batch blocking constraints.

Combines gap blocking (setup times) and span blocking (batches) to create more complex and realistic scheduling scenarios.

Parameters:

  • base_problem – Original RCPSP problem

  • setup_ratio – Setup time ratio for gap blocking

  • batch_size – Batch size for span blocking

  • seed – Random seed

Returns:

RcpspWithResourceBlocking with both types of blocking constraints

Example

>>> from discrete_optimization.rcpsp.parser import parse_file, get_data_available
>>> files = get_data_available()
>>> base_problem = parse_file(files[0])
>>> problem = generate_combined_blocking(base_problem)
discrete_optimization.rcpsp_blocking_resource.blocking_generator.generate_setup_time_blocking(base_problem: RcpspProblem, setup_ratio: float = 0.2, resource_subset: list[str] | None = None, seed: int | None = None, blocking_intensity: float = 0.5) → RcpspWithResourceBlocking[source]

Generate RCPSP with setup time blocking between consecutive tasks.

Creates blocking constraints representing setup/changeover times between tasks that consume the same resources. Since blocking is ADDITIVE (task + blocking <= capacity), the blocking amount is carefully chosen to avoid infeasibilities.

Parameters:

  • base_problem – Original RCPSP problem

  • setup_ratio – Ratio of setup time to average task duration (default 0.2 = 20%)

  • resource_subset – Resources affected by setup (None = all renewable resources)

  • seed – Random seed for reproducibility

  • blocking_intensity – Fraction of AVAILABLE capacity to block (default 0.5 = 50%) Available capacity = total capacity - max task consumption

Returns:

RcpspWithResourceBlocking with gap blocking constraints for setup times

Example

>>> from discrete_optimization.rcpsp.parser import parse_file, get_data_available
>>> files = get_data_available()
>>> base_problem = parse_file(files[0])
>>> problem_with_setup = generate_setup_time_blocking(base_problem, blocking_intensity=0.7)

discrete_optimization.rcpsp_blocking_resource.problem_with_blocking module

RCPSP with Resource Blocking Constraints.

This module provides an extension to standard RCPSP that includes resource blocking constraints such as setup times, changeover periods, and safety monitoring spans.

class discrete_optimization.rcpsp_blocking_resource.problem_with_blocking.RcpspWithResourceBlocking(resources: dict[str, int | list[int]], non_renewable_resources: list[str], mode_details: dict[Hashable, dict[int, dict[str, int]]], successors: dict[Hashable, list[Hashable]], horizon: int, tasks_list: list[Hashable] | None = None, source_task: Hashable | None = None, sink_task: Hashable | None = None, name_task: dict[Hashable, str] | None = None, calendar_details: dict[str, list[list[int]]] | None = None, special_constraints: SpecialConstraintsDescription | None = None, fixed_permutation: list[int] | None = None, fixed_modes: list[int] | None = None, flexible_gap_blocking_constraints: list[tuple[SchedulingEntity, StartOrEnd, SchedulingEntity, StartOrEnd, dict[Hashable, int], BlockingConstraintMetadata]] | None = None, span_blocking_constraints: list[tuple[SchedulingEntity, dict[Hashable, int], BlockingConstraintMetadata]] | None = None, **kwargs: Any)[source]

Bases: RcpspProblem

RCPSP with Resource Blocking Constraints.

Extends standard RCPSP with two types of blocking constraints: 1. Flexible gap blocking: Resources blocked between two task events

(e.g., setup time between task A end and task B start)

  1. Span blocking: Resources blocked for entire span of task group (e.g., project reservation blocking resource from first to last task)

All attributes from RcpspProblem, plus
flexible_gap_blocking_constraints

List of gap blocking constraints

span_blocking_constraints

List of span blocking constraints

Example

>>> from discrete_optimization.generic_tasks_tools.resource_blocking import (
...     BlockingMode, BlockingConstraintMetadata,
... )
>>> from discrete_optimization.generic_tasks_tools.enums import StartOrEnd
>>> from discrete_optimization.generic_tasks_tools.entities import TaskEntity
>>> # Define standard RCPSP parameters
>>> resources = {"R1": 5}
>>> mode_details = {
...     1: {1: {"duration": 0, "R1": 0}},
...     2: {1: {"duration": 4, "R1": 2}},
...     3: {1: {"duration": 3, "R1": 3}},
...     4: {1: {"duration": 0, "R1": 0}},
... }
>>> successors = {1: [2, 3], 2: [4], 3: [4], 4: []}
>>> # Add setup time blocking between tasks
>>> blocking_constraints = [
...     (
...         TaskEntity(2), StartOrEnd.END,
...         TaskEntity(3), StartOrEnd.START,
...         {"R1": 1},  # 1 unit of R1 blocked during setup
...         BlockingConstraintMetadata(
...             mode=BlockingMode.RESERVATION,
...             description="Setup time between task 2 and 3"
...         ),
...     )
... ]
>>> problem = RcpspWithResourceBlocking(
...     resources=resources,
...     non_renewable_resources=[],
...     mode_details=mode_details,
...     successors=successors,
...     horizon=20,
...     flexible_gap_blocking_constraints=blocking_constraints,
... )
get_flexible_gap_blocking_constraints() → list[tuple[SchedulingEntity, StartOrEnd, SchedulingEntity, StartOrEnd, dict[Hashable, int], BlockingConstraintMetadata]][source]

Return flexible gap blocking constraints.

get_span_blocking_constraints() → list[tuple[SchedulingEntity, dict[Hashable, int], BlockingConstraintMetadata]][source]

Return span blocking constraints.

satisfy(variable) → bool[source]

Check if solution satisfies all constraints including blocking.

Parameters:

variable – The solution to check

Returns:

True if solution satisfies all constraints

Module contents