Routing solver doesn't seems to respect time windows

[waelbb]

Hello, I have a vrp problem where each node correspond to a category (A, B or C), I duplicated the node from the category C. The thing is that I don't want 2 duplicated node to be include in the same route so what I did is that I added time windows. Let's say that I have 40 vehicle with 15 capacity (each visited node has a capacity of 1 it is just to limit the number of visited node per vehicle to 15), I divided all my vehicle to 2 start and end location. So I have start node 0 and end node 1 with 20 vehicles and start node 2 and end node 3 with 20 vehicles. I tried to set up time windows for my start and end location this way :

• start node 0 : [28800,28800] (corresponds to 8 am in seconds and it is the same start and end range to from the 20 vehicle to leave asap)
• end node 1 : [80000,80000]
• start node 2 : [115200, 115200]
• end node 3 : [166400,166400]

Those start and end node are dummy location so they have a 0 seconds distance to all the other nodes. Here is how my time_window matrix is setup :

[[28800, 28800],
[80000, 80000],
[115200, 115200],
[166400, 166400],
[[0, 86400], []],
[[], [0, 86400]],
[[0, 86400], []],
[[0, 86400], [0, 86400]]

For the visited nodes if the nodes is not a duplicated node is will be available from [28800,80000] and [115200,166400]. If it is a duplicated node one will be available during the first part [28800,80000] and the duplicated one from [115200,166400].

Unfortunately in the end I have duplicated node in the same route while it should be impossible cause vehicle either start from the first start and end node which means they should be back at 80000 or form the second meaning they can only start at 115200.

Could you help me solve this please ?
Here is my code so you can better understand :

num_days = 40
n_freq = 2
days_per_freq = num_days // n_freq
day_length_in_seconds = 86400

start_indices = [n for n in range(0,2*n_freq,2) for _ in range(days_per_freq)]
end_indices = [n for n in range(1,2*n_freq+1,2) for _ in range(days_per_freq)]

# Create the routing index manager.
manager = pywrapcp.RoutingIndexManager(
    len(data["time_matrix"]), data["num_vehicles"], start_indices, end_indices
)

# Create Routing Model.
routing = pywrapcp.RoutingModel(manager)


# Create and register a transit callback.
def time_callback(from_index, to_index):
    from_node = manager.IndexToNode(from_index)
    to_node = manager.IndexToNode(to_index)
    return data["time_matrix"][from_node][to_node]

transit_callback_index = routing.RegisterTransitCallback(time_callback)
    

# Define cost of each arc.
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

# Add Time dimension.
time = "Time"
routing.AddDimension(
    transit_callback_index,
    86400*n_freq, 
    86400*n_freq,  
    False,  
    time)
time_dimension = routing.GetDimensionOrDie(time)

routing.AddDimensionWithVehicleCapacity(
        transit_callback_index,
        0,
        # Have to add 1 to maximum locations because of end location
        [3600]* data["num_vehicles"] ,  # maximum travel time per vehicle
        True,
        'TravelTime')

# Add time window constraints for all start and end locations.
for i in range(0, n_freq*2):
    if i in start_indices:
        index = routing.Start(int(i/2))
    elif i in end_indices:
        index = routing.End(int((i-1)/2))
    time_dimension.CumulVar(index).SetRange(
                windows[i][0], windows[i][1])

# Time window constraints for visits
for location_index, time_window in enumerate(windows):
    if location_index in range(n_freq * 2, len(data["time_matrix"])):
        index = manager.NodeToIndex(location_index)
        time_dimension.CumulVar(index).SetRange(0, day_length_in_seconds * n_freq)
        for Day in range(n_freq):

            Day_Start = Day * day_length_in_seconds
            Day_End = Day_Start + day_length_in_seconds
            Working_Start = windows[Day * 2][0]
            Working_End = windows[Day * 2 + 1][1]

            if int(len(time_window[Day])/2) == 0:
                time_dimension.CumulVar(index).RemoveInterval(Day_Start, Day_End)
            else:
                time_dimension.CumulVar(index).RemoveInterval(Day_Start, Working_Start)
                time_dimension.CumulVar(index).RemoveInterval(Working_End, Day_End)

          
                

# Add Capacity constraint.
def demand_callback(from_index):
    from_node = manager.IndexToNode(from_index)
    return 1 if (from_node not in (start_indices + end_indices)) else 0

demand_callback_index = routing.RegisterUnaryTransitCallback(demand_callback)
Capacity = "Capacity"
routing.AddDimensionWithVehicleCapacity(
    demand_callback_index,
    0, 
    data["vehicle_capacities"],  
    True, 
    "Capacity",
)

# Define penalty sizes for each category
penalty_sizes = {
    "Very High Value": 101200, 
    "High Value": 101080, 
    "Mid Value": 100840, 
    "Low Value": 100600, 
    "Very Low Value" :100480
}

# Assign penalties based on node categories
for node in range(n_freq*2, len(data["time_matrix"])):
    if node not in (start_indices + end_indices):
        category = locations[node-(n_freq*2)]["category"]
        penalty = penalty_sizes[category]
        routing.AddDisjunction([manager.NodeToIndex(node)], penalty)


for i in range(n_freq):
    routing.AddVariableMinimizedByFinalizer(
        time_dimension.CumulVar(routing.Start(i)))
    routing.AddVariableMinimizedByFinalizer(
        time_dimension.CumulVar(routing.End(i)))


# Setting first solution heuristic.
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
    routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
)
search_parameters.local_search_metaheuristic = (
    routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
search_parameters.time_limit.seconds = 30
search_parameters.log_search = False

# Solve the problem.
solution = routing.SolveWithParameters(search_parameters)