diff --git a/src/constraints/conversion_2_greedy_v2.mzn b/src/constraints/conversion_2_greedy_v2.mzn new file mode 100644 index 0000000000000000000000000000000000000000..67c6e1d7b048c3e24c0333147d9231047f007b4b --- /dev/null +++ b/src/constraints/conversion_2_greedy_v2.mzn @@ -0,0 +1,658 @@ +include "globals.mzn"; + +int : n_intervals; +int : n_operations; +int : n_locations; +int : n_moving_obj; + +array [0..n_operations, 0..(n_intervals + 1)] of var bool : op_status; +array [0..n_operations, 0..(n_intervals + 1)] of var bool : op_start; + +constraint forall (t in 0..(n_intervals + 1)) (op_status[0, t] = false); % Фиктивная операция. +constraint forall (t in 0..(n_intervals + 1)) ( op_start[0, t] = false); % Фиктивная операция. + +array [0..n_moving_obj, 0..n_operations] of bool : moving_op_of_obj; + +% Определение current_moving_operation. + % Текущая операция операция перемещения, в которой задействован данный объект. + array [0..n_moving_obj, 0..(n_intervals + 1)] of var 0..n_operations : current_moving_operation; + + constraint forall (t in 0..(n_intervals + 1)) (current_moving_operation[0, t] = 0); % Фиктивный объект. + + % Крайние значения. + constraint forall (obj in 1..n_moving_obj, t in {0, n_intervals + 1}) ( + current_moving_operation[obj, t] = 0 + ); + + % Текущая операция лежит в множестве тех, которые затрагивают данный объект. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + (current_moving_operation[obj, t] != 0) -> moving_op_of_obj[obj, current_moving_operation[obj, t]] + ); + % Если операция, затрагивающая данный объект в качестве главного, выполняется - то именно она текущая операция перемещения для этого объекта. + constraint forall (op in 1..n_operations, t in 1..n_intervals where is_moving_operation[op]) ( + op_status[op, t] -> (current_moving_operation[main_obj_of_operation[op], t] = op) + ); + % Связь current_moving_operation c op_status. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + (current_moving_operation[obj, t] != 0) -> (op_status[current_moving_operation[obj, t], t]) + ); + +% Определение current_moored_obj. + % Объект, пришвартованный к данной локации. + array [0..n_locations, 0..(n_intervals + 1)] of var 0..n_moving_obj : current_moored_obj; + + constraint forall (t in 0..(n_intervals + 1)) (current_moored_obj[0, t] = 0); % Фиктивная локация. + + % Фиксирование неиспользуемых значений. + constraint forall (loc in 1..n_locations, t in 0..(n_intervals + 1) where loc mod 2 = 1) ( + current_moored_obj[loc, t] = 0 + ); + + % Крайние значения. + constraint forall (loc in 1..n_locations, t in {0, n_intervals + 1}) ( + current_moored_obj[loc, t] = 0 + ); + + % Операции с условной швартовкой. + int : op_with_nominally_mooring_max_size; + array [0..n_locations, 0..n_moving_obj] of 0..op_with_nominally_mooring_max_size : op_with_nominally_mooring_sizes; + array [0..n_locations, 0..n_moving_obj, 1..op_with_nominally_mooring_max_size] of 1..n_operations : op_with_nominally_mooring; + + % current_moored_obj соответствуе какому-либо реально пришвартованному объекту. + constraint forall (loc in 1..n_locations, t in 1..n_intervals, obj = current_moored_obj[loc, t] + where loc mod 2 = 0) ( + (obj != 0) -> ((m_obj_loc[obj, t] = loc) \/ + (exists (op in [op_with_nominally_mooring[loc, obj, id] | id in 1..op_with_nominally_mooring_sizes[loc, obj]]) + (op_status[op, t])) + ) + ); + + % Если объект пришвартован или швартуется, то current_moored_obj об это знает. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals, loc = m_obj_loc[obj, t]) ( + (loc mod 2 = 0) -> (current_moored_obj[loc, t] = obj) + ); + + % Если выполняется операция, где судно условно пришвартовано, то current_moored_obj знает об этом. + constraint forall (loc in 1..n_locations, + obj in 1..n_moving_obj, + op in [op_with_nominally_mooring[loc, obj, id] | id in 1..op_with_nominally_mooring_sizes[loc, obj]], + t in 1..n_intervals) ( + op_status[op, t] -> (current_moored_obj[loc, t] = obj) + ); + +array [1..n_locations] of 0..n_locations : twin_location = [i - 1 + (i mod 2) * 2 | i in 1..n_locations]; + +array [0..n_operations] of 0..n_locations : operations_destination; % Локация в которой окажется объект после завершения операции. + +% Определение m_obj_loc. + % Местоположение объекта или пункт назначения (если объект движется) перед началом определённого интервала. + array [0..n_moving_obj, 0..(n_intervals + 1)] of var 0..n_locations : m_obj_loc; + + constraint forall (t in 0..(n_intervals + 1)) (m_obj_loc[0, t] = 0); % Фиктивный объект. + + % Главный объект (субъект) операции. + array [0..n_operations] of 0..n_moving_obj : main_obj_of_operation; + + % Является ли операция швартовкой/отшвартовкой. + array [0..n_operations] of bool : is_mooring_op; + + % За фиктивный нулевой интервал объект не успевает ничего сделать с начальным положением. + constraint forall (obj in 1..n_moving_obj) ( + m_obj_loc[obj, 1] = m_obj_loc[obj, 0] + ); + + % Направление движения/местоположение объекта может измениться только если перед этим началась операция перемещения, и он не вспомогательный при операции швартовки. + constraint forall (obj in 1..n_moving_obj, t in 2..(n_intervals + 1)) ( + ((current_moving_operation[obj, t - 1] != current_moving_operation[obj, t - 2]) /\ + (current_moving_operation[obj, t - 1] != 0) /\ + ((obj = main_obj_of_operation[current_moving_operation[obj, t - 1]]) + \/ + (not is_mooring_op[current_moving_operation[obj, t - 1]]) + ) + ) -> (m_obj_loc[obj, t] = operations_destination[current_moving_operation[obj, t - 1]]) + ); + constraint forall (obj in 1..n_moving_obj, t in 2..(n_intervals + 1)) ( + ((current_moving_operation[obj, t - 1] = current_moving_operation[obj, t - 2]) \/ + (current_moving_operation[obj, t - 1] = 0) \/ + ((obj != main_obj_of_operation[current_moving_operation[obj, t - 1]]) + /\ + ( is_mooring_op[current_moving_operation[obj, t - 1]]) + ) + ) -> (m_obj_loc[obj, t] = m_obj_loc[obj, t - 1]) + ); + +% Начальное состояние. + array [0..n_moving_obj] of 0..n_locations : initial_m_obj_loc; + constraint forall (i in 1..n_moving_obj) (m_obj_loc[i, 0] = initial_m_obj_loc[i]); + +% Конечное состояние. + array [0..n_moving_obj] of 0..n_locations : final_m_obj_loc; + constraint forall (i in 1..n_moving_obj) ( + (final_m_obj_loc[i] != 0) -> + (m_obj_loc[i, n_intervals + 1] = final_m_obj_loc[i]) + ); + +% Определение op_status, op_start. + constraint forall (i in 1..n_operations, j in {0, n_intervals + 1}) (op_status[i, j] == 0); % Краевые значения. + + constraint forall (op in 1..n_operations, j in {0, n_intervals + 1}) (op_start[op, j] = false); + constraint forall (i in 1..n_operations, j in 1..(n_intervals + 1)) (op_start[i, j] = (op_status[i, j] /\ not op_status[i, j - 1])); + +% Связь ресурсов с операцией и основным объектом. + % Операции, которые могут задействовать данный объект как ресурс. + array [0..n_moving_obj] of set of 1..n_operations : operations_that_used_obj_as_resource; + + % Является ли данная операция операцией перемещения. + array [0..n_operations] of bool : is_moving_operation; + + % Операция, в которой участвует данный объект как ресурс. + array [0..n_moving_obj, 0..(n_intervals + 1)] of var 0..n_operations : participation_as_resource; + + constraint forall (t in 0..(n_intervals + 1)) (participation_as_resource[0, t] = 0); % Фиктивный объект. + + % Граничные значения. + constraint forall (obj in 1..n_moving_obj) (participation_as_resource[obj, 0] = 0); + constraint forall (obj in 1..n_moving_obj) (participation_as_resource[obj, n_intervals + 1] = 0); + + % Только те операции, которые затрагивают данный объект. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + (participation_as_resource[obj, t] != 0) + -> participation_as_resource[obj, t] in operations_that_used_obj_as_resource[obj] + ); + + % Связь с текущими операциями перемещения. + % Если объект задействован в операции перемещения, которая использует его как ресурс, + % то participation_as_resource должен указывать на эту операцию. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + (current_moving_operation[obj, t] in operations_that_used_obj_as_resource[obj]) + -> + (participation_as_resource[obj, t] = current_moving_operation[obj, t]) + ); + % Если объект участвует как ресурс в операции перемещения, то это согласованно с current_moving_operation. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + ((participation_as_resource[obj, t] != 0) /\ + (is_moving_operation[participation_as_resource[obj, t]]) + ) -> (participation_as_resource[obj, t] = current_moving_operation[obj, t]) + ); + + % { Объект участвует где-то в качестве ресурса - соответствующая операция обязана быть активной. } + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + (participation_as_resource[obj, t] != 0) -> op_status[participation_as_resource[obj, t], t] + ); + + % От начала операции и до конца её ресурсы не могут измениться (в том числе и для погрузки). + constraint forall (obj in 1..n_moving_obj, t in 1..(n_intervals - 1)) ( + ((participation_as_resource[obj, t] != 0) /\ + (op_status[participation_as_resource[obj, t], t + 1]) + ) -> (participation_as_resource[obj, t + 1] = participation_as_resource[obj, t]) + ); + + int : n_resources_types; % Количество различных типов ресурсов. + array [1..n_resources_types] of set of 1..n_moving_obj : objects_of_type; % Все объекты конкретного типа. + + int : n_resources_counters; % Количество счётчиков ресурсов. + % Счётчик ресурсов. + array [1..n_resources_counters , 1..n_intervals] of var int : resources_counter; + array [1..n_resources_counters] of 1..n_resources_types : counter_type; % Типы ресурсов, за которыми следят счётчики. + array [1..n_resources_counters] of 1..n_operations : operation_of_counter; % Операция, которой принадлежит данный счётчик. + array [1..n_resources_counters] of int : required_counter_values; % Необходимые значения на счётчиках ресурсов для выполнения операции. + array [0..n_operations] of set of 1..n_resources_counters : counters_of_operation; % Счётчики, которые относятся к данной операции. + + % Участие всех необходимых ресурсов в операции. + constraint forall (t in 1..n_intervals, op in 1..n_operations, counter in counters_of_operation[op]) ( + op_status[op, t] -> (resources_counter[counter, t] = required_counter_values[counter]) + ); + + % Определение resources_counter. + constraint forall (counter in 1..n_resources_counters, t in 1..n_intervals) ( + resources_counter[counter, t] = sum (obj in objects_of_type[counter_type[counter]]) ( + participation_as_resource[obj, t] = operation_of_counter[counter] + ) + ); + +% Участие объекта в операциях грузообработки. + array [0..n_moving_obj, 1..n_intervals] of var bool : is_involved_in_cargo_op; + + constraint forall (t in 1..n_intervals) (is_involved_in_cargo_op[0, t] = false); % Фиктивный объект. + + % Операции погрузки, которые используют этот объект в качестве главного или в качестве бункеровщика. + array [0..n_moving_obj] of set of 0..n_operations : related_cargo_op; + + % Определение is_involved_in_cargo_op. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + is_involved_in_cargo_op[obj, t] = ( + (exists (op in related_cargo_op[obj]) (op_status[op, t])) + \/ + ((participation_as_resource[obj, t] != 0) /\ (not is_moving_operation[participation_as_resource[obj, t]])) + ) + ); + % Операции перемещения исключают операции грузообработки и наоборот. + constraint forall (obj in 1..n_moving_obj, t in 1..n_intervals) ( + is_involved_in_cargo_op[obj, t] -> (current_moving_operation[obj, t] = 0) + ); + +% Наличие всех объектов на месте во время начала операции перемещения + готовность к началу. + % Требуемое положение конкретных типов объектов в момент начала операций. + array [1..n_resources_counters] of 1..n_locations : operations_resources_start_loc; + + % Наличие на месте всех ресурсов. + constraint forall ( + op in 1..n_operations, + t in 1..n_intervals, + counter in counters_of_operation[op], + obj in objects_of_type[counter_type[counter]]) ( + ((participation_as_resource[obj, t] = op) /\ (op_start[op, t]) + ) -> (m_obj_loc[obj, t] == operations_resources_start_loc[counter]) + ); + + % Требуемое положение главного объекта в момент начала операций. + array [0..n_operations] of 0..n_locations : main_obj_start_loc; + % Требуемое положение бункеровщика в момент начала операции. + array [0..n_operations] of 0..n_locations : bunker_start_loc; + + % Бункеровщик, участвующий в операции погрузки (0, если такогого нет или это не погрузка). + array [0..n_operations] of 0..n_moving_obj : bunker_of_cargo_op; + + % Наличие главных объектов на месте. + constraint forall (op in 1..n_operations, + t in 1..n_intervals, + obj = main_obj_of_operation[op]) ( + op_start[op, t] -> (m_obj_loc[obj, t] == main_obj_start_loc[op]) + ); + + % Наличие бункеровщиков на месте. + constraint forall (op in 1..n_operations, + t in 1..n_intervals, + obj = bunker_of_cargo_op[op] where obj != 0) ( + op_start[op, t] -> (m_obj_loc[obj, t] == bunker_start_loc[op]) + ); + +% Непрерывность перемещения и швартовки. + array [0..n_operations] of int : operations_duration; + array [0..n_operations] of bool : is_continuous_operation; + + constraint forall (i in 1..n_operations, len = operations_duration[i] where is_continuous_operation[i]) ( + (forall (j in 1..(n_intervals - len + 1)) ( + (op_start[i, j] == 1) -> ( + (forall (k in 1..(len - 1)) (op_status[i, j + k])) + /\ + (not op_status[i, j + len]) + ) + )) /\ + (forall (j in (n_intervals - len + 2)..(n_intervals + 1)) (op_start[i, j] == false)) + ); + +% Конфликтующие операции. + array [0..n_operations] of set of 1..n_operations : conflicting_operations; + + constraint forall (op in 1..n_operations, t in 0..(n_intervals + 1), conf_op in conflicting_operations[op]) ( + op_status[op, t] -> not op_status[conf_op, t] + ); + +% Окна непогоды. + array [0..n_operations, 0..n_intervals] of bool : bad_weather; + + constraint forall (op in 1..n_operations, t in 1..n_intervals) ( + bad_weather[op, t] -> (op_status[op, t] = false) + ); + +% Грузообработка. + int : n_cargo_types; + int : n_all_storage_sections; + array [0..n_all_storage_sections, 0..(n_intervals + 1)] of var int : storage_used_volume; + + constraint forall (t in 0..(n_intervals + 1)) (storage_used_volume[0, t] = 0); % Фиктивный объект. + + % Ограничения на вместимость. + array [0..n_all_storage_sections] of int : max_storage_vol; + % Максимальный объём. + constraint forall (storage in 1..n_all_storage_sections, t in 0..(n_intervals + 1)) ( + (storage_used_volume[storage, t]) <= max_storage_vol[storage] + ); + % Неотрицательность объёма. + constraint forall (storage in 1..n_all_storage_sections, t in 0..(n_intervals + 1)) ( + 0 <= storage_used_volume[storage, t] + ); + + % Ограничения на граничные значения. + array [0..n_all_storage_sections] of int : initial_storage_vol; + array [0..n_all_storage_sections] of int : final_storage_vol; + + constraint forall (storage in 1..n_all_storage_sections) ( % Initial values. + storage_used_volume[storage, 0] = initial_storage_vol[storage] + ); + + constraint forall (storage in 1..n_all_storage_sections % Final values. + where final_storage_vol[storage] >= 0) ( + storage_used_volume[storage, n_intervals + 1] = final_storage_vol[storage] + ); + + % Изменение грузов в хранилищах. + array [0..n_all_storage_sections, 0..(n_intervals + 1)] of int : cargo_flows; + + int : n_loading_op; + + array [0..n_operations] of int : loading_op_delta_of_main_obj; + array [0..n_operations] of int : loading_op_abs_delta; + array [0..n_operations] of {1, -1} : loading_op_direction; + + array [0..n_operations] of 1..n_all_storage_sections : operations_main_stor; + array [0..n_operations] of 1..n_all_storage_sections : operations_secondary_stor; + array [0..n_operations] of 1..n_cargo_types : operations_cargo_t; + + array [1..n_loading_op] of int : loading_op_delta; + array [1..n_loading_op] of {1, -1} : loading_op_local_direction; + array [1..n_loading_op] of 1..n_operations : loading_op_n; % Номера среди общего списка операций. + + array [1..n_all_storage_sections] of set of 1..n_loading_op : involved_operations; + array [1..n_moving_obj] of set of 1..n_all_storage_sections : sections_of_moving_obj; + array [1..n_moving_obj] of bool : is_sections_of_moving_obj_empty; + + array [0..n_all_storage_sections] of int : storage_greedy_upper_limit; + array [0..n_all_storage_sections] of int : storage_greedy_lower_limit; + + 0..n_all_storage_sections : n_sections_of_real_storage_and_bunkers; + array [0..n_sections_of_real_storage_and_bunkers] of 0..n_all_storage_sections : number_of_connected_sections; + + 0..n_all_storage_sections : max_number_of_connected_sections; + + array [0..n_sections_of_real_storage_and_bunkers, 0..max_number_of_connected_sections, 1..(n_intervals + 1)] of var int : nominal_cargo_value; + array [0..n_sections_of_real_storage_and_bunkers, 0..(max_number_of_connected_sections + 1), 1..(n_intervals + 1)] of var int : cargo_overflow_remains; + array [0..n_sections_of_real_storage_and_bunkers, 0..max_number_of_connected_sections, 1..(n_intervals + 1)] of var int : real_cargo_value; + array [0..n_sections_of_real_storage_and_bunkers, 1..(n_intervals + 1)] of var int : total_sum; + + % Определение real_cargo_value + array [0..n_operations] of 0..n_all_storage_sections : operations_main_stor_no_in_secondary; + array [0..n_operations] of 0..n_all_storage_sections : operations_secondary_stor_no_in_main; + + array [0..n_sections_of_real_storage_and_bunkers, 0..max_number_of_connected_sections] of set of 1..n_operations : connected_op_to_pair_of_sections; + + % Определение nominal_cargo_value + % Операция грузообработки активна -> нужные номинальные значения согласованы с ней. + constraint forall (op in 1..n_operations, + t in 1..(n_intervals + 1), + section_1 = operations_main_stor[op], + section_2 = operations_secondary_stor[op], + pos = operations_main_stor_no_in_secondary[op] + where pos != 0) ( + let {var int : total_vol = storage_used_volume[section_1, t - 1] + loading_op_delta_of_main_obj[op];} in + (op_status[op, t] /\ total_vol > storage_greedy_upper_limit[section_1]) -> ( + nominal_cargo_value[section_2, pos, t] = -(loading_op_delta_of_main_obj[op] - (total_vol - storage_greedy_upper_limit[section_1])) + ) + ); + constraint forall (op in 1..n_operations, + t in 1..(n_intervals + 1), + section_1 = operations_main_stor[op], + section_2 = operations_secondary_stor[op], + pos = operations_main_stor_no_in_secondary[op] + where pos != 0) ( + let {var int : total_vol = storage_used_volume[section_1, t - 1] + loading_op_delta_of_main_obj[op];} in + (op_status[op, t] /\ total_vol < storage_greedy_lower_limit[section_1]) -> ( + nominal_cargo_value[section_2, pos, t] = -(loading_op_delta_of_main_obj[op] - (total_vol - storage_greedy_lower_limit[section_1])) + ) + ); + constraint forall (op in 1..n_operations, + t in 1..(n_intervals + 1), + section_1 = operations_main_stor[op], + section_2 = operations_secondary_stor[op], + pos = operations_main_stor_no_in_secondary[op] + where pos != 0) ( + let {var int : total_vol = storage_used_volume[section_1, t - 1] + loading_op_delta_of_main_obj[op];} in + (op_status[op, t] /\ (total_vol >= storage_greedy_lower_limit[section_1]) + /\ (total_vol <= storage_greedy_upper_limit[section_1])) -> ( + nominal_cargo_value[section_2, pos, t] = -loading_op_delta_of_main_obj[op] + ) + ); + + % Если нет активной операции, влияющей на эту пару секций, то nominal_cargo_value = 0. + constraint forall (section_1 in 1..n_sections_of_real_storage_and_bunkers, + section_2 in 1..number_of_connected_sections[section_1], + t in 1..(n_intervals + 1)) ( + (forall (op in connected_op_to_pair_of_sections[section_1, section_2]) (not op_status[op, t])) + -> + (nominal_cargo_value[section_1, section_2, t] = 0) + ); + + % Крайние значения. + constraint forall (section_1 in 1..n_sections_of_real_storage_and_bunkers, + section_2 in (number_of_connected_sections[section_1] + 1)..max_number_of_connected_sections, + t in 1..(n_intervals + 1)) ( + nominal_cargo_value[section_1, section_2, t] = 0 + ); + constraint forall (section_1 in 1..n_sections_of_real_storage_and_bunkers, + t in 1..(n_intervals + 1)) ( + nominal_cargo_value[section_1, 0, t] = 0 + ); + constraint forall (section_2 in 0..max_number_of_connected_sections, + t in 1..(n_intervals + 1)) ( + nominal_cargo_value[0, section_2, t] = 0 + ); + + % Определение cargo_overflow_remains. + % array [0..n_sections_of_real_storage_and_bunkers, 1..(n_intervals + 1)] of var int : total_sum; + constraint forall (t in 1..(n_intervals + 1), section in 1..n_sections_of_real_storage_and_bunkers) ( + total_sum[section, t] = sum (i in 1..number_of_connected_sections[section]) (nominal_cargo_value[section, i, t]) + ); + constraint forall (t in 1..(n_intervals + 1)) (total_sum[0, t] = 0); + + % Переполнение. + constraint forall (t in 1..(n_intervals + 1), section in 1..n_sections_of_real_storage_and_bunkers) ( + (total_sum[section, t] + storage_used_volume[section, t - 1] > storage_greedy_upper_limit[section]) + -> + (cargo_overflow_remains[section, number_of_connected_sections[section] + 1, t] = + total_sum[section, t] + storage_used_volume[section, t - 1] - storage_greedy_upper_limit[section] + ) + ); + constraint forall (t in 1..(n_intervals + 1), section in 1..n_sections_of_real_storage_and_bunkers) ( + (total_sum[section, t] + storage_used_volume[section, t - 1] < storage_greedy_lower_limit[section]) + -> + (cargo_overflow_remains[section, number_of_connected_sections[section] + 1, t] = + total_sum[section, t] + storage_used_volume[section, t - 1] - storage_greedy_lower_limit[section] + ) + ); + constraint forall (t in 1..(n_intervals + 1), section in 1..n_sections_of_real_storage_and_bunkers) ( + let {var int : total = total_sum[section, t] + storage_used_volume[section, t - 1]} in + ((storage_greedy_lower_limit[section] <= total) /\ (total <= storage_greedy_upper_limit[section])) + -> + (cargo_overflow_remains[section, number_of_connected_sections[section] + 1, t] = 0) + ); + + + % Избавляемся от лишнего. + % Если остаток переполнения и номналное значение одного знака, то полностью отменяем это номинальное значение. + constraint forall (t in 1..(n_intervals + 1), + section in 1..n_sections_of_real_storage_and_bunkers, + i in 1..number_of_connected_sections[section]) ( + ((((cargo_overflow_remains[section, i + 1, t] < 0) /\ (nominal_cargo_value[section, i, t] < 0)) + \/ + ((cargo_overflow_remains[section, i + 1, t] > 0) /\ (nominal_cargo_value[section, i, t] > 0)) + ) /\ (abs(cargo_overflow_remains[section, i + 1, t]) >= abs(nominal_cargo_value[section, i, t])) + ) -> ( + cargo_overflow_remains[section, i, t] = + cargo_overflow_remains[section, i + 1, t] - + nominal_cargo_value[section, i, t] + ) + ); + + % Иначе оно полностью перекрыло переполнение. + constraint forall (t in 1..(n_intervals + 1), + section in 1..n_sections_of_real_storage_and_bunkers, + i in 1..number_of_connected_sections[section]) ( + (((cargo_overflow_remains[section, i + 1, t] <= 0) /\ (nominal_cargo_value[section, i, t] >= 0)) + \/ + ((cargo_overflow_remains[section, i + 1, t] >= 0) /\ (nominal_cargo_value[section, i, t] <= 0)) + \/ + (abs(cargo_overflow_remains[section, i + 1, t]) < abs(nominal_cargo_value[section, i, t])) + ) -> ( + cargo_overflow_remains[section, i, t] = 0 + ) + ); + + % Крайние значения. + constraint forall (t in 1..(n_intervals + 1), section in 1..n_sections_of_real_storage_and_bunkers) ( + cargo_overflow_remains[section, 0, t] = 0 + ); + constraint forall (t in 1..(n_intervals + 1), + section in 1..n_sections_of_real_storage_and_bunkers, + i in (number_of_connected_sections[section] + 2)..max_number_of_connected_sections) ( + cargo_overflow_remains[section, i, t] = 0 + ); + constraint forall (section_2 in 0..(max_number_of_connected_sections + 1), + t in 1..(n_intervals + 1)) ( + cargo_overflow_remains[0, section_2, t] = 0 + ); + + % Определение real_cargo_value + constraint forall (t in 1..(n_intervals + 1), + section in 1..n_sections_of_real_storage_and_bunkers, + i in 1..number_of_connected_sections[section]) ( + real_cargo_value[section, i, t] = nominal_cargo_value[section, i, t] + - cargo_overflow_remains[section, i + 1, t] + + cargo_overflow_remains[section, i, t] + ); + % Крайние значения. + constraint forall (t in 1..(n_intervals + 1), section in 1..n_sections_of_real_storage_and_bunkers) ( + real_cargo_value[section, 0, t] = 0 + ); + constraint forall (t in 1..(n_intervals + 1), + section in 1..n_sections_of_real_storage_and_bunkers, + i in (number_of_connected_sections[section] + 1)..max_number_of_connected_sections) ( + real_cargo_value[section, i, t] = 0 + ); + constraint forall (section_2 in 0..max_number_of_connected_sections, + t in 1..(n_intervals + 1)) ( + real_cargo_value[0, section_2, t] = 0 + ); + + array [0..n_all_storage_sections] of set of 1..n_all_storage_sections : all_used_positions_in_real_cargo_value; + array [1..n_all_storage_sections, 1..n_all_storage_sections] of 0..max_number_of_connected_sections : positions_of_connected_sections; + + + constraint forall (storage in 1..n_sections_of_real_storage_and_bunkers, t in 1..(n_intervals + 1)) ( + storage_used_volume[storage, t] = ( + storage_used_volume[storage, t - 1] + + cargo_flows[storage, t] + + (sum (i in 1..number_of_connected_sections[storage]) (real_cargo_value[storage, i, t])) + + (sum (i in all_used_positions_in_real_cargo_value[storage]) (-real_cargo_value[i, positions_of_connected_sections[storage, i], t])) + ) + ); + constraint forall (storage in (n_sections_of_real_storage_and_bunkers + 1)..n_all_storage_sections, t in 1..(n_intervals + 1)) ( + storage_used_volume[storage, t] = ( + storage_used_volume[storage, t - 1] + + cargo_flows[storage, t] + + (sum (i in all_used_positions_in_real_cargo_value[storage]) (-real_cargo_value[i, positions_of_connected_sections[storage, i], t])) + ) + ); + +/* + constraint forall (storage in 1..n_sections_of_real_storage_and_bunkers, t in 1..(n_intervals + 1)) ( + debug_storage_used_volume[storage, t] = ( + debug_storage_used_volume[storage, t - 1] + + cargo_flows[storage, t] + + (sum (i in 1..number_of_connected_sections[storage]) (real_cargo_value[storage, i, t])) + + (sum (i in all_used_positions_in_real_cargo_value[storage]) (-real_cargo_value[i, positions_of_connected_sections[storage, i], t])) + ) + ); + + constraint forall (storage in (n_sections_of_real_storage_and_bunkers + 1)..n_all_storage_sections, t in 1..(n_intervals + 1)) ( + debug_storage_used_volume[storage, t] = ( + debug_storage_used_volume[storage, t - 1] + + cargo_flows[storage, t] + + (sum (i in all_used_positions_in_real_cargo_value[storage]) (-real_cargo_value[i, positions_of_connected_sections[storage, i], t])) + ) + ); +*/ + + array [0..n_all_storage_sections, 0..(n_intervals + 1)] of var int : debug_storage_used_volume; + constraint forall (t in 0..(n_intervals + 1)) (debug_storage_used_volume[0, t] = 0); % Фиктивный объект. + + constraint forall (storage in 1..n_all_storage_sections) ( % Initial values. + debug_storage_used_volume[storage, 0] = initial_storage_vol[storage] + ); + +/* + constraint forall (storage in 1..n_all_storage_sections, t in 1..(n_intervals + 1)) ( + storage_used_volume[storage, t] = ( + storage_used_volume[storage, t - 1] + + cargo_flows[storage, t] + + sum (inv_op in involved_operations[storage]) ( + loading_op_delta[inv_op] * + op_status[loading_op_n[inv_op], t] + ) + ) + ); +*/ +% Фиксированные операции. + int : n_fixed_op; + array [1..n_fixed_op] of 1..n_operations : fixed_op; + array [1..n_fixed_op] of set of 1..n_moving_obj : fixed_op_resources; + array [1..n_fixed_op] of 1..n_intervals : fixed_op_start; + array [1..n_fixed_op] of 1..n_intervals : fixed_op_end; % Включительно. + array [1..n_fixed_op] of int : fixed_op_intensity; + + array [0..n_operations, 0..n_intervals] of bool : is_fixed; + array [0..n_moving_obj, 0..(n_intervals + 1)] of bool : is_obj_involved_in_fixed_op; + + constraint forall (no in 1..n_fixed_op, op = fixed_op[no]) ( + forall (t in fixed_op_start[no]..fixed_op_end[no]) ( + (op_status[op, t]) /\ + forall (obj in fixed_op_resources[no]) ( + participation_as_resource[obj, t] = op + ) + ) + ); + + array [1..n_moving_obj, 1..n_locations, 1..n_intervals] of bool : is_fixed_op_planned_in_future; + +% Критерий оптимизации + array [1..(n_intervals + 1)] of var bool : is_not_terminated; + % В конце всё остановится. + constraint (is_not_terminated[n_intervals + 1] == false); + + % Действия ещё не остановились, если в текущий интервал что-нибудь происходит или они не остановятся в следующий интервал. + constraint forall (t in 1..n_intervals) ( + is_not_terminated[t] == ( + (exists (op in 1..n_operations) (op_status[op, t])) + \/ + is_not_terminated[t + 1] + ) + ); + + solve minimize sum(is_not_terminated); + +output [show(sum(is_not_terminated)), "\n", + "op_status = ", show(op_status), "\n\n", + "m_obj_loc = ", show(m_obj_loc), "\n\n", + "op_start = ", show(op_start), "\n\n", + "is_not_terminated = ", show(is_not_terminated), "\n\n", + "storage_used_volume = ", show(storage_used_volume), "\n\n", + "m_obj_loc = ", show(m_obj_loc), "\n\n", + "current_moving_operation = ", show(current_moving_operation), "\n\n", + "resources_counter {", show(n_intervals), "} = ", show(resources_counter), "\n\n", + "operation_of_counter {", show(n_resources_counters), "} = ", show(operation_of_counter), "\n\n", + "participation_as_resource = ", show(participation_as_resource), "\n\n", + + "is_involved_in_cargo_op = {", show(n_intervals), "} ", show(is_involved_in_cargo_op), "\n\n", + + "current_moored_obj = ", show(current_moored_obj), "\n\n", + + "nominal_cargo_value {", show(max_number_of_connected_sections + 1), " ", show(n_intervals + 1), "} = ", show(nominal_cargo_value), "\n\n", + "cargo_overflow_remains {", show(max_number_of_connected_sections + 2), " ", show(n_intervals + 1), "} = ", show(cargo_overflow_remains), "\n\n", + "real_cargo_value {", show(max_number_of_connected_sections + 1), " ", show(n_intervals + 1), "} = ", show(real_cargo_value), "\n\n", + + % "debug_1 {", show(max_number_of_connected_sections + 1), " ", show(n_intervals + 1), "} = ", show(debug_1), "\n\n", + + + % "debug_storage_used_volume = ", show(debug_storage_used_volume), "\n\n", + + "total_sum {", show(n_intervals + 1), "} = ", show(total_sum), "\n\n", + + +/* + "is_op_possible {", show(n_intervals), "} = ", show(is_op_possible), "\n\n", + "debug_1 {", show(n_intervals), "} = ", show(debug_1), "\n\n", + "is_enough_free_resources {", show(n_intervals), "} = ", show(is_enough_free_resources), "\n\n", + "operation_of_counter {", show(n_resources_counters), "} = ", show(operation_of_counter), "\n\n", + "possible_resources_counter {", show(n_intervals), "} = ", show(possible_resources_counter), "\n\n", +*/ + ""];