Multi-tour with schedule

lib/interpreters/periodic_visits.rb

@@ -41,11 +41,7 @@ def initialize(vrp)
     def expand(vrp, job, &block)
       return vrp unless vrp.scheduling?
 
-      vehicles_linked_by_duration = save_relations(vrp, :vehicle_group_duration).concat(
-        save_relations(vrp, :vehicle_group_duration_on_weeks)
-      ).concat(
-        save_relations(vrp, :vehicle_group_duration_on_months)
-      )
+      vehicles_linking_relations = save_vehicle_linking_relations(vrp)
       vrp.relations = generate_relations(vrp)
       vrp.rests = []
       vrp.vehicles = generate_vehicles(vrp).sort{ |a, b|
@@ -61,8 +57,7 @@ def expand(vrp, job, &block)
       vrp.shipments = generate_shipments(vrp)
 
       @periods.uniq!
-      vehicles_linked_by_duration = get_all_vehicles_in_relation(vehicles_linked_by_duration)
-      generate_relations_on_periodic_vehicles(vrp, vehicles_linked_by_duration)
+      generate_relations_on_periodic_vehicles(vrp, vehicles_linking_relations)
 
       if vrp.preprocessing_first_solution_strategy.to_a.first != 'periodic' && vrp.services.any?{ |service| service.visits_number > 1 }
         vrp.routes = generate_routes(vrp)
@@ -247,7 +242,6 @@ def generate_vehicles(vrp)
           timewindows = [vehicle.timewindow || vehicle.sequence_timewindows].flatten
           if timewindows.empty?
             new_vehicle = build_vehicle(vrp, vehicle, vehicle_day_index, rests_durations)
-            @equivalent_vehicles[vehicle.original_id] << new_vehicle.id
             new_vehicle
           else
             timewindows.select{ |timewindow| timewindow.day_index.nil? || timewindow.day_index == vehicle_day_index % 7 }.collect{ |associated_timewindow|
@@ -456,67 +450,63 @@ def compute_possible_days(vrp)
       }
     end
 
-    def save_relations(vrp, relation_type)
-      vrp.relations.select{ |r| r.type == relation_type }.collect{ |r|
-        {
-          type: r.type,
-          linked_vehicle_ids: r.linked_vehicle_ids,
-          lapse: r.lapse,
-          periodicity: r.periodicity
-        }
+    def save_vehicle_linking_relations(vrp)
+      vrp.relations.select{ |r|
+        [:vehicle_group_duration, :vehicle_group_duration_on_weeks, :vehicle_group_duration_on_months,
+         :vehicle_trips].include?(r.type)
       }
     end
 
-    def get_all_vehicles_in_relation(relations)
-      relations&.each{ |r|
-        next if r[:type] == :vehicle_group_duration
+    def cut_linking_vehicle_relation_by_period(relation, periods, relation_type)
+      additional_relations = []
+      vehicles_in_relation =
+        relation[:linked_vehicle_ids].flat_map{ |v| @equivalent_vehicles[v] }
 
-        new_list = []
-        r[:linked_vehicle_ids].each{ |v|
-            new_list.concat(@equivalent_vehicles[v])
-        }
-        r[:linked_vehicle_ids] = new_list
-      }
+      while periods.any?
+        days_in_period = periods.slice!(0, relation.periodicity).flatten
+        relation_vehicles = vehicles_in_relation.select{ |id| days_in_period.include?(id.split('_').last.to_i) }
+        next unless relation_vehicles.any?
+
+        additional_relations << Models::Relation.new(
+          linked_vehicle_ids: relation_vehicles,
+          lapse: relation.lapse,
+          type: relation_type
+        )
+      end
+
+      additional_relations
     end
 
-    def generate_relations_on_periodic_vehicles(vrp, list)
-      new_relations = []
-      list.each{ |r|
-        case r[:type]
+    def collect_weeks_in_schedule
+      current_day = (@schedule_start + 1..@schedule_start + 7).find{ |d| d % 7 == 0 } # next monday
+      schedule_week_indices = [(@schedule_start..current_day - 1).to_a]
+      while current_day + 6 <= @schedule_end
+        schedule_week_indices << (current_day..current_day + 6).to_a
+        current_day += 7
+      end
+      schedule_week_indices << (current_day..@schedule_end).to_a unless current_day > @schedule_end
+
+      schedule_week_indices
+    end
+
+    def generate_relations_on_periodic_vehicles(vrp, vehicle_linking_relations)
+      vrp.relations.concat(vehicle_linking_relations.flat_map{ |relation|
+        case relation[:type]
         when :vehicle_group_duration
-          new_relations << [r[:linked_vehicle_ids], r[:lapse]]
+          Models::Relation.new(
+            type: :vehicle_group_duration, lapse: relation.lapse,
+            linked_vehicle_ids: relation[:linked_vehicle_ids].flat_map{ |v| @equivalent_vehicles[v] })
         when :vehicle_group_duration_on_weeks
-          current_sub_list = []
-          first_index = r[:linked_vehicle_ids].min.split('_').last.to_i
-          in_periodicity = first_index + 7 * (r[:periodicity] - 1)
-          max_index = (in_periodicity..in_periodicity + 7).find{ |index| index % 7 == 6 }
-          r[:linked_vehicle_ids].sort_by{ |v_id| v_id.split('_').last.to_i }.each{ |v_id|
-            this_index = v_id.split('_').last.to_i
-            if this_index <= max_index
-              current_sub_list << v_id
-            else
-              new_relations << [current_sub_list, r[:lapse]]
-              current_sub_list = [v_id]
-              first_index = this_index
-              in_periodicity = first_index + 7 * (r[:periodicity] - 1)
-              max_index = (in_periodicity..in_periodicity + 7).find{ |index| index % 7 == 6 }
-            end
-          }
-          new_relations << [current_sub_list, r[:lapse]]
+          schedule_week_indices = collect_weeks_in_schedule
+          cut_linking_vehicle_relation_by_period(relation, schedule_week_indices, :vehicle_group_duration)
         when :vehicle_group_duration_on_months
-          (0..vrp.schedule_months_indices.size - 1).step(r[:periodicity]).collect{ |v| p vrp.schedule_months_indices.slice(v, v + r[:periodicity]).flatten }.each{ |month_indices|
-            new_relations << [r[:linked_vehicle_ids].select{ |id| month_indices.include?(id.split('_').last.to_i) }, r[:lapse]]
-          }
+          cut_linking_vehicle_relation_by_period(relation, vrp.schedule_months_indices, :vehicle_group_duration)
+        when :vehicle_trips
+          # we want want vehicle_trip relation per day :
+          all_days = (@schedule_start..@schedule_end).to_a
+          cut_linking_vehicle_relation_by_period(relation, all_days, :vehicle_trips)
         end
-      }
-
-      new_relations.each{ |linked_vehicle_ids, lapse|
-        vrp.relations << Models::Relation.new(
-          type: :vehicle_group_duration,
-          linked_vehicle_ids: linked_vehicle_ids,
-          lapse: lapse
-        )
-      }
+      })
     end
 
     private

models/concerns/validate_data.rb

@@ -145,7 +145,7 @@ def calculate_day_availabilities(vehicles, timewindow_arrays)
       if timewindows.empty?
         []
       else
-        days = timewindows.flat_map{ |tw| tw[:day_index] }
+        days = timewindows.flat_map{ |tw| tw[:day_index] || (0..6).to_a }
         days.compact!
         days.uniq
       end

test/lib/interpreters/interpreter_test.rb

@@ -1408,7 +1408,7 @@ def test_overall_duration_several_vehicles
     assert_equal 2, expanded_vrp.relations.size
 
     problem[:relations].first[:type] = :vehicle_group_duration
-    expanded_vrp = periodic_expand(vrp)
+    expanded_vrp = periodic_expand(problem)
     assert_equal 1,  expanded_vrp.relations.size
     assert_equal 4,  expanded_vrp.relations.first[:linked_vehicle_ids].size
 
@@ -1418,7 +1418,7 @@ def test_overall_duration_several_vehicles
     }
     vrp = TestHelper.create(problem)
     refute_empty vrp.schedule_months_indices
-    expanded_vrp = periodic.send(:expand, vrp, nil)
+    expanded_vrp = periodic_expand(problem)
     assert_equal 2, expanded_vrp.relations.size
   end
 
@@ -1484,6 +1484,9 @@ def test_expand_relations_of_one_month_and_one_day
     expanded_vrp = periodic_expand(problem)
     assert_equal 2, expanded_vrp.relations.size
 
+    problem[:configuration][:schedule] = {
+      range_date: { start: Date.new(2020, 1, 1), end: Date.new(2020, 2, 1) }
+    }
     problem[:relations].first[:periodicity] = 2
     expanded_vrp = periodic_expand(problem)
     assert_equal 1, expanded_vrp.relations.size
@@ -1554,4 +1557,39 @@ def test_first_last_possible_days
     assert_equal 2, expanded_vrp.services.first.first_possible_days[0]
     assert_equal 2, expanded_vrp.services.first.last_possible_days[0]
   end
+
+  def test_expand_multitrips_relations
+    # If two vehicles are in vehicle_trips relation,
+    # VRP is only valid if they available at same days
+    # In this case, vehicle_trip relation should be repeated
+    # every day those vehicles are available
+    vrp = VRP.lat_lon_two_vehicles
+    vrp[:configuration][:schedule] = { range_indices: { start: 0, end: 3 }}
+    vrp[:relations] = [TestHelper.vehicle_trips_relation(vrp)]
+    vrp[:vehicles].each{ |v|
+      v.delete(:sequence_timewindows)
+      v[:timewindow] = { start: 0, end: 10 }
+    }
+    expanded_vrp = periodic_expand(vrp)
+    assert_equal 8, expanded_vrp.vehicles.size
+    assert_equal 4, (expanded_vrp.relations.count{ |r| r[:type] == :vehicle_trips })
+
+    vrp[:vehicles].each{ |v|
+      v[:timewindow] = { start: 0, end: 10, day_index: 0 }
+    }
+    expanded_vrp = periodic_expand(vrp)
+    assert_equal 2, expanded_vrp.vehicles.size
+    assert_equal 1, (expanded_vrp.relations.count{ |r| r[:type] == :vehicle_trips })
+
+    vrp[:vehicles].each{ |v|
+      v.delete(:timewindow)
+    }
+    vrp[:vehicles][0][:sequence_timewindows] = [{ start: 0, end: 10, day_index: 0 },
+                                                { start: 20, end: 30, day_index: 1 }]
+    vrp[:vehicles][1][:sequence_timewindows] = [{ start: 5, end: 15, day_index: 0 },
+                                                { start: 17, end: 45, day_index: 1 }]
+    expanded_vrp = periodic_expand(vrp)
+    assert_equal 4, expanded_vrp.vehicles.size
+    assert_equal 2, (expanded_vrp.relations.count{ |r| r[:type] == :vehicle_trips })
+  end
 end

test/models/vrp_consistency_test.rb

@@ -473,6 +473,34 @@ def test_compatible_days_availabilities_with_vehicle_trips
       end
     end
 
+    def test_compatible_days_availabilities_with_vehicle_trips_with_sequence_timewindows
+      vrp = VRP.lat_lon_two_vehicles
+      vrp[:configuration][:schedule] = { range_indices: { start: 0, end: 3 }}
+      vrp[:relations] = [TestHelper.vehicle_trips_relation(vrp)]
+      vrp[:vehicles][0][:sequence_timewindows] = [{ start: 0, end: 10, day_index: 0 },
+                                                  { start: 20, end: 30, day_index: 1 }]
+      vrp[:vehicles][1][:sequence_timewindows] = [{ start: 5, end: 15, day_index: 0 },
+                                                  { start: 17, end: 45, day_index: 1 }]
+
+      check_consistency(vrp) # this should not raise
+
+      vrp[:vehicles][1][:sequence_timewindows] = [{ start: 5, end: 15, day_index: 0 }]
+      assert_raises OptimizerWrapper::UnsupportedProblemError do
+        check_consistency(vrp)
+      end
+
+      vrp[:vehicles][1][:sequence_timewindows] = [{ start: 5, end: 15 }]
+      assert_raises OptimizerWrapper::UnsupportedProblemError do
+        check_consistency(vrp)
+      end
+
+      vrp[:vehicles][1][:sequence_timewindows] = [{ start: 5, end: 15, day_index: 0 },
+                                                  { start: 17, end: 19, day_index: 1 }]
+      assert_raises OptimizerWrapper::DiscordantProblemError do
+        check_consistency(vrp)
+      end
+    end
+
     def test_unavailable_days_with_vehicle_trips
       vrp = VRP.lat_lon_scheduling_two_vehicles
       vrp[:relations] = [TestHelper.vehicle_trips_relation(vrp)]