Добавлены ограничения с вариативной интенсивностью.

src/constraints/conversion_2_with_partial_cargo_operations.mod

+using CP;
+
+int n_intervals  = ...;
+int n_operations = ...;
+int n_locations  = ...;
+int n_moving_obj = ...;
+
+dvar boolean op_status[0..n_operations][0..(n_intervals + 1)];
+dvar boolean op_start[0..n_operations][0..(n_intervals + 1)];
+
+int moving_op_of_obj[0..n_moving_obj][0..n_operations] = ...;
+
+// Текущая операция операция перемещения, в которой задействован данный объект.
+dvar int current_moving_operation[0..n_moving_obj][0..(n_intervals + 1)] in 0..n_operations;
+
+// Является ли данная операция операцией перемещения.
+int is_moving_operation[0..n_operations] = ...;
+
+// Главный объект (субъект) операции.
+int main_obj_of_operation[0..n_operations] = ...;
+
+
+// Объект, пришвартованный к данной локации.
+dvar int current_moored_obj[0..n_locations, 0..(n_intervals + 1)] in 0..n_moving_obj;
+
+// Операции с условной швартовкой.
+int op_with_nominally_mooring_max_size = ...;
+int op_with_nominally_mooring_sizes[0..n_locations, 0..n_moving_obj] = ...;
+int op_with_nominally_mooring[0..n_locations, 0..n_moving_obj, 1..op_with_nominally_mooring_max_size] = ...;
+    
+
+// Местоположение объекта или пункт назначения (если объект движется) перед началом определённого интервала.
+dvar int m_obj_loc[0..n_moving_obj, 0..(n_intervals + 1)] in 0..n_locations;
+
+int twin_location[1..n_locations];
+int main_location[1..n_locations];
+
+execute initializeArray {
+    for(var i = 1; i <= n_locations; i++) {
+        twin_location[i] = i - 1 + (i % 2) * 2;
+        main_location[i] = i - ((i + 1) % 2);
+    }
+}
+
+int operations_destination[0..n_operations] = ...; // Локация в которой окажется объект после завершения операции.
+
+// Является ли операция швартовкой/отшвартовкой.
+int is_mooring_op[0..n_operations] = ...;
+
+int initial_m_obj_loc[0..n_moving_obj] = ...;
+int final_m_obj_loc[0..n_moving_obj] = ...;
+
+// Операции, которые могут задействовать данный объект как ресурс.
+{int} operations_that_used_obj_as_resource [0..n_moving_obj] = ...;
+
+// Операция, в которой участвует данный объект как ресурс.
+dvar int participation_as_resource[0..n_moving_obj, 0..(n_intervals + 1)] in 0..n_operations;
+
+int n_resources_types = ...; // Количество различных типов ресурсов.
+{int} objects_of_type[1..n_resources_types] = ...; // Все объекты конкретного типа.
+
+int n_resources_counters = ...; // Количество счётчиков ресурсов.
+// Счётчик ресурсов.
+dvar int resources_counter[1..n_resources_counters , 1..n_intervals];
+int counter_type[1..n_resources_counters] = ...; // Типы ресурсов, за которыми следят счётчики.
+int operation_of_counter[1..n_resources_counters] = ...; // Операция, которой принадлежит данный счётчик.
+int required_counter_values[1..n_resources_counters] = ...; // Необходимые значения на счётчиках ресурсов для выполнения операции.
+{int} counters_of_operation[0..n_operations] = ...; // Счётчики, которые относятся к данной операции.
+
+dvar boolean is_involved_in_cargo_op[0..n_moving_obj, 0..n_intervals];
+
+// Операции погрузки, которые используют этот объект в качестве главного или в качестве бункеровщика.
+{int} related_cargo_op[0..n_moving_obj] = ...;
+
+// Операции отшвартовки, которые используют объект в качестве главного.
+{int} related_unmooring_op[0..n_moving_obj] = ...;
+
+// Требуемое положение конкретных типов объектов в момент начала операций.
+int operations_resources_start_loc[1..n_resources_counters] = ...;
+
+// Требуемое положение главного объекта в момент начала операций.
+int main_obj_start_loc[0..n_operations] = ...;
+// Требуемое положение бункеровщика в момент начала операции.
+int bunker_start_loc[0..n_operations] = ...;
+
+// Бункеровщик, участвующий в операции погрузки (0, если такогого нет или это не погрузка).
+int bunker_of_cargo_op[0..n_operations] = ...;
+
+int operations_duration[0..n_operations] = ...;
+int is_continuous_operation[0..n_operations] = ...;
+
+{int} conflicting_operations[0..n_operations] = ...;
+
+int bad_weather[0..n_operations, 0..n_intervals] = ...;
+
+
+int n_cargo_types = ...;
+int n_all_storage_sections = ...;
+dvar int storage_used_volume[0..n_all_storage_sections, 0..(n_intervals + 1)];
+
+int max_storage_vol[0..n_all_storage_sections] = ...;
+
+int initial_storage_vol[0..n_all_storage_sections] = ...;
+int final_storage_vol[0..n_all_storage_sections] = ...;
+
+int cargo_flows[0..n_all_storage_sections, 0..(n_intervals + 1)] = ...;
+
+int n_loading_op = ...;
+
+int loading_op_delta_of_main_obj[0..n_operations] = ...;
+int loading_op_abs_delta[0..n_operations] = ...;
+int loading_op_direction[0..n_operations] = ...;
+
+int operations_main_stor[0..n_operations] = ...;
+int operations_secondary_stor[0..n_operations] = ...;
+int operations_cargo_t[0..n_operations] = ...;
+
+int loading_op_delta[1..n_loading_op] = ...;
+int loading_op_local_direction[1..n_loading_op] = ...;
+int loading_op_n[1..n_loading_op] = ...; // Номера среди общего списка операций.
+
+{int} involved_operations[1..n_all_storage_sections] = ...;
+{int} sections_of_moving_obj[1..n_moving_obj] = ...;
+int is_sections_of_moving_obj_empty[1..n_moving_obj] = ...;
+
+// Интенсивность операций погрузки.
+dvar int cargo_op_intensity[0..n_operations, 0..(n_intervals + 1)];
+
+
+int n_fixed_op = ...;
+int fixed_op[1..n_fixed_op] = ...;
+{int} fixed_op_resources[1..n_fixed_op] = ...;
+int fixed_op_start[1..n_fixed_op] = ...;
+int fixed_op_end[1..n_fixed_op] = ...; // Включительно.
+int fixed_op_intensity[1..n_fixed_op] = ...;
+
+int is_fixed[0..n_operations, 0..n_intervals] = ...;
+int is_obj_involved_in_fixed_op[0..n_moving_obj, 0..(n_intervals + 1)] = ...;
+
+
+int min_positive_cargo_val[1..n_all_storage_sections, 1..n_locations] = ...; // Объём максимальной положительной операции, которая может быть произведена с этой секцией в этом хранилище. Если в локации таковой нет, то это значение объёма хранилища + 1.
+int max_negative_cargo_val[1..n_all_storage_sections, 1..n_locations] = ...;
+
+int can_obj_leave_loc_only_alone[1..n_moving_obj, 1..n_locations] = ...;
+int is_fixed_op_planned_in_future[1..n_moving_obj, 1..n_locations, 1..n_intervals] = ...;
+
+
+// Возможно ли начать операцию в данный интервал (если предположить, что операция длится 1 интервал).
+dvar boolean is_op_possible[0..n_operations, 1..n_intervals];
+
+// Счётчик ресурсов, которые могут быть потенциально задействованы в операции.
+dvar int possible_resources_counter[1..n_resources_counters , 1..n_intervals];
+
+dvar boolean is_enough_free_resources[0..n_operations, 1..n_intervals];
+
+
+dvar boolean can_obj_theoretically_use_cargo_op[0..n_moving_obj, 0..(n_intervals + 1)];
+// Остановился ли объект окончательно, начиная с данного интервала.
+dvar boolean is_obj_totally_terminated[0..n_moving_obj, 0..(n_intervals + 1)];
+
+
+dvar int prev_m_obj_loc[0..n_moving_obj, 0..(n_intervals + 1)] in 1..n_locations;
+dvar boolean is_obj_involved_in_useful_operation[0..n_moving_obj, 0..(n_intervals + 1)];
+
+// Успел ли объект поучаствовать в полезной операции к концу данного интервала.
+dvar boolean is_attended_useful_op_in_cur_loc[0..n_moving_obj, 0..(n_intervals + 1)];
+
+
+dvar boolean is_cargo_op_not_exceeds_storage_limits[1..n_operations, 1..n_intervals];
+
+
+dvar boolean is_not_terminated[1..(n_intervals + 1)];
+
+minimize sum (i in 1..(n_intervals + 1)) is_not_terminated[i];
+
+subject to {
+    forall (t in 0..(n_intervals + 1)) (op_status[0, t] == 0); // Фиктивная операция.
+    forall (t in 0..(n_intervals + 1)) ( op_start[0, t] == 0); // Фиктивная операция.
+    
+    // Определение current_moving_operation.
+        forall (t in 0..(n_intervals + 1)) (current_moving_operation[0, t] == 0); // Фиктивный объект.
+        
+        // Крайние значения.
+        forall (obj in 1..n_moving_obj, t in {0, n_intervals + 1}) (
+            current_moving_operation[obj, t] == 0
+        );
+        
+        // Текущая операция лежит в множестве тех, которые затрагивают данный объект.
+        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]] != 0)
+        );
+        // Если операция, затрагивающая данный объект в качестве главного, выполняется - то именно она текущая операция перемещения для этого объекта.
+        forall (op in 1..n_operations, t in 1..n_intervals : (is_moving_operation[op] == 1)) (
+            (op_status[op, t] == 1) => (current_moving_operation[main_obj_of_operation[op], t] == op)
+        );
+        // Связь current_moving_operation c op_status.
+        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] == 1)
+        );
+
+        
+    // Определение current_moored_obj.
+        forall (t in 0..(n_intervals + 1)) (current_moored_obj[0, t] == 0); // Фиктивная локация.
+    
+        // Фиксирование неиспользуемых значений.
+        forall (loc in 1..n_locations, t in 0..(n_intervals + 1) : loc mod 2 == 1) (
+            current_moored_obj[loc, t] == 0
+        );
+    
+        // Крайние значения.
+        forall (loc in 1..n_locations, t in {0, n_intervals + 1}) (
+            current_moored_obj[loc, t] == 0
+        );
+    
+    
+        // current_moored_obj соответствуе какому-либо реально пришвартованному объекту.
+        forall (loc in 1..n_locations, t in 1..n_intervals : loc mod 2 == 0) (
+            (current_moored_obj[loc, t] != 0) => ((m_obj_loc[current_moored_obj[loc, t], t] == loc) ||
+                           (or (id in 1..op_with_nominally_mooring_max_size) // new!!!
+                             op_status[op_with_nominally_mooring[loc, current_moored_obj[loc, t], id], t] == true
+                          ))
+        );
+    
+        // Если объект пришвартован или швартуется, то current_moored_obj об это знает.
+        forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
+            (m_obj_loc[obj, t] mod 2 == 0) => (current_moored_obj[m_obj_loc[obj, t], t] == obj)
+        );
+    
+        // Если выполняется операция, где судно условно пришвартовано, то current_moored_obj знает об этом.
+        forall (loc in 1..n_locations,
+                           obj in 1..n_moving_obj,
+                           op_id in 1..op_with_nominally_mooring_sizes[loc, obj],
+                           t in 1..n_intervals) (
+            (op_status[op_with_nominally_mooring[loc, obj, op_id], t] == 1) => (current_moored_obj[loc, t] == obj)
+        );
+      
+        
+    // Определение m_obj_loc.
+        forall (t in 0..(n_intervals + 1)) (m_obj_loc[0, t] == 0); // Фиктивный объект.
+    
+        // За фиктивный нулевой интервал объект не успевает ничего сделать с начальным положением.
+        forall (obj in 1..n_moving_obj) (
+            m_obj_loc[obj, 1] == m_obj_loc[obj, 0]
+        );
+    
+        // Направление движения/местоположение объекта может измениться только если перед этим началась операция перемещения, и он не вспомогательный при операции швартовки.
+            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]] == 0)
+                 )
+                ) => (m_obj_loc[obj, t] == operations_destination[current_moving_operation[obj, t - 1]])
+            );
+            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]] == 1)
+                 )
+                ) => (m_obj_loc[obj, t] == m_obj_loc[obj, t - 1])
+            );
+            
+            
+    // Начальное состояние.
+        forall (i in 1..n_moving_obj) (m_obj_loc[i, 0] == initial_m_obj_loc[i]);
+    
+    // Конечное состояние.
+        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.
+        forall (i in 1..n_operations, j in {0, n_intervals + 1}) (op_status[i, j] == 0); // Краевые значения.
+    
+        forall (op in 1..n_operations, j in {0, n_intervals + 1}) (op_start[op, j] == 0);
+        forall (i in 1..n_operations, j in 1..(n_intervals + 1)) (op_start[i, j] == ((op_status[i, j] == 1) && (op_status[i, j - 1] == 0)));
+
+
+    // Связь ресурсов с операцией и основным объектом.  
+        forall (t in 0..(n_intervals + 1)) (participation_as_resource[0, t] == 0); // Фиктивный объект.
+    
+            // Граничные значения.
+            forall (obj in 1..n_moving_obj) (participation_as_resource[obj, 0] == 0);
+            forall (obj in 1..n_moving_obj) (participation_as_resource[obj, n_intervals + 1] == 0);
+    
+            // Только те операции, которые затрагивают данный объект.
+            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 должен указывать на эту операцию.
+                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.
+                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]] == 1)
+                    ) => (participation_as_resource[obj, t] == current_moving_operation[obj, t])
+                );
+    
+            // { Объект участвует где-то в качестве ресурса - соответствующая операция обязана быть активной. }
+            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] == 1)
+            );
+    
+            // От начала операции и до конца её ресурсы не могут измениться (в том числе и для погрузки).
+            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] == 1)
+                ) => (participation_as_resource[obj, t + 1] == participation_as_resource[obj, t])
+            );
+    
+    
+        // Участие всех необходимых ресурсов в операции.
+        forall (t in 1..n_intervals, op in 1..n_operations, counter in counters_of_operation[op]) (
+            (op_status[op, t] == 1) => (resources_counter[counter, t] == required_counter_values[counter])
+        );
+    
+        // Определение resources_counter.
+        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]
+            )
+        );
+
+
+    // Участие объекта в операциях грузообработки.
+        forall (t in 1..n_intervals) (is_involved_in_cargo_op[0, t] == 0); // Фиктивный объект.
+        forall (obj in 1..n_moving_obj) (is_involved_in_cargo_op[obj, 0] == 0);
+    
+        // Определение is_involved_in_cargo_op.
+        forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
+            is_involved_in_cargo_op[obj, t] == (
+                    (or (op in related_cargo_op[obj]) (op_status[op, t] == true))
+                        ||
+                    ((participation_as_resource[obj, t] != 0) && (is_moving_operation[participation_as_resource[obj, t]] == 0))
+                )
+        );
+        // Операции перемещения исключают операции грузообработки и наоборот.
+        forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
+            (is_involved_in_cargo_op[obj, t] == 1) => (current_moving_operation[obj, t] == 0)
+        );
+
+
+
+    // Наличие всех объектов на месте во время начала операции перемещения + готовность к началу.
+        // Наличие на месте всех ресурсов.
+        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] == 1)
+                ) => (m_obj_loc[obj, t] == operations_resources_start_loc[counter])
+        );
+    
+        // Наличие главных объектов на месте.
+        forall (op in 1..n_operations, t in 1..n_intervals) (
+            (op_start[op, t] == 1) => (m_obj_loc[main_obj_of_operation[op], t] == main_obj_start_loc[op])
+        );
+    
+        // Наличие бункеровщиков на месте.
+        forall (op in 1..n_operations,
+                           t in 1..n_intervals
+                            : bunker_of_cargo_op[op] != 0) (
+            (op_start[op, t] == 1) => (m_obj_loc[bunker_of_cargo_op[op], t] == bunker_start_loc[op])
+        );
+
+    // Непрерывность перемещения и швартовки.
+        forall (i in 1..n_operations : is_continuous_operation[i] == 1) 
+            forall (j in 1..(n_intervals - operations_duration[i] + 1))
+                forall (k in 1..(operations_duration[i] - 1))
+                    (op_start[i, j] == 1) => (
+                        (op_status[i, j + k] == 1)
+                            &&
+                        (op_status[i, j + operations_duration[i]] == 0)
+                    )
+            ;
+        
+        forall (i in 1..n_operations : is_continuous_operation[i] == 1)
+            forall (j in (n_intervals - operations_duration[i] + 2)..(n_intervals + 1)) (op_start[i, j] == 0)
+        ;
+    
+    // Конфликтующие операции.
+            forall (op in 1..n_operations, t in 0..(n_intervals + 1), conf_op in conflicting_operations[op]) (
+                (op_status[op, t] == 1) => (op_status[conf_op, t] == 0)
+            );
+    
+    // Окна непогоды.
+        forall (op in 1..n_operations, t in 1..n_intervals) (
+            (bad_weather[op, t] == 1) => (op_status[op, t] == 0)
+        );
+
+
+    // Грузообработка.
+        forall (t in 0..(n_intervals + 1)) (storage_used_volume[0, t] == 0); // Фиктивный объект.
+    
+        // Ограничения на вместимость.
+            // Максимальный объём.
+            forall (storage in 1..n_all_storage_sections, t in 0..(n_intervals + 1)) (
+                (storage_used_volume[storage, t]) <= max_storage_vol[storage]
+            );
+            // Неотрицательность объёма.
+            forall (storage in 1..n_all_storage_sections, t in 0..(n_intervals + 1)) (
+                0 <= storage_used_volume[storage, t]
+            );
+    
+        // Ограничения на граничные значения.
+            forall (storage in 1..n_all_storage_sections) ( // Initial values.
+                storage_used_volume[storage, 0] == initial_storage_vol[storage]
+            );
+    
+            forall (storage in 1..n_all_storage_sections // Final values.
+                                : final_storage_vol[storage] >= 0) (
+                    storage_used_volume[storage, n_intervals + 1] == final_storage_vol[storage]
+            );
+    
+        // Изменение грузов в хранилищах.
+            forall (t in 0..(n_intervals + 1)) (cargo_op_intensity[0, t] == 0); // Фиктивная операция.
+
+            forall (op in 1..n_operations, t in 0..(n_intervals + 1)) (cargo_op_intensity[op, t] >= 0);
+            forall (op in 1..n_operations, t in 0..(n_intervals + 1)) (cargo_op_intensity[op, t] <= loading_op_abs_delta[op]);
+    
+            // Связь с операциями грузообработки.
+                forall (op in 1..n_operations, t in 0..(n_intervals + 1) : (is_moving_operation[op] == 0)) (
+                    (cargo_op_intensity[op, t] > 0) => (op_status[op, t] == 1)
+                );
+                forall (op in 1..n_operations, t in 0..(n_intervals + 1) : (is_moving_operation[op] == 0)) (
+                    cargo_op_intensity[op, t] == 0
+                );
+                forall (op in 1..n_operations, t in 0..(n_intervals + 1) : (is_moving_operation[op] == 0)) (
+                    (op_status[op, t] == 1) => (cargo_op_intensity[op, t] > 0)
+                );
+    
+            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]) (
+                        cargo_op_intensity[loading_op_n[inv_op], t] *
+                        loading_op_local_direction[inv_op]
+                    )
+                )
+            );
+
+
+    // Фиксированные операции.  
+        forall (no in 1..n_fixed_op)
+            forall (t in fixed_op_start[no]..fixed_op_end[no])
+                ((op_status[fixed_op[no], t] == 1) &&
+                 (cargo_op_intensity[fixed_op[no], t] == fixed_op_intensity[no]))
+        ;
+        
+        forall (no in 1..n_fixed_op)
+            forall (t in fixed_op_start[no]..fixed_op_end[no])
+                forall (obj in fixed_op_resources[no]) (
+                    participation_as_resource[obj, t] == fixed_op[no]
+                
+            )
+        ;
+
+
+    // Оптимизация - сдвиг в начало.
+        forall (t in 1..n_intervals) (is_op_possible[0, t] == false); // Фиктивный объект.
+    
+        // Определение possible_resources_counter.
+            forall (counter in 1..n_resources_counters, t in 1..n_intervals) (
+                possible_resources_counter[counter, t] == sum (obj in objects_of_type[counter_type[counter]]) (
+                    (participation_as_resource[obj, t] == 0) &&
+                    (current_moving_operation[obj, t] == 0)  &&
+                    (m_obj_loc[obj, t] == operations_resources_start_loc[counter])
+                )
+            );
+    
+        // Достаточно ли свободных ресурсов для операции.
+    
+            forall (t in 1..n_intervals) (is_enough_free_resources[0, t] == false); // Фиктивный объект.
+    
+            forall (op in 1..n_operations, t in 1..n_intervals) (
+                is_enough_free_resources[op, t] == and (counter in counters_of_operation[op]) (
+                    possible_resources_counter[counter, t] >= required_counter_values[counter]
+                )
+            );
+            
+            forall (op in 1..n_operations, t in 1..n_intervals) (
+                is_cargo_op_not_exceeds_storage_limits[op, t] ==
+                    ((is_moving_operation[op] == 0) => (
+                        (storage_used_volume[operations_main_stor[op],      t] + loading_op_direction[op] >= 0) &&
+                        (storage_used_volume[operations_main_stor[op],      t] + loading_op_direction[op] <= max_storage_vol[operations_main_stor[op]]) &&
+                        (storage_used_volume[operations_secondary_stor[op], t] - loading_op_direction[op] >= 0) &&
+                        (storage_used_volume[operations_secondary_stor[op], t] - loading_op_direction[op] <= max_storage_vol[operations_secondary_stor[op]])
+                    ))
+            );
+    
+        // Определение is_op_possible.
+            forall (op in 1..n_operations, t in 1..n_intervals) (
+                is_op_possible[op, t] == (
+                    (bad_weather[op, t] == 0) &&                  // Погода не мешает.
+                    (m_obj_loc[main_obj_of_operation[op], t] == main_obj_start_loc[op])
+                                                                  && // Главный объект на месте.
+                    (current_moving_operation[main_obj_of_operation[op], t] == 0)
+                                                                  && // Главный объект не участвует в операции перемещеня.
+                    (is_enough_free_resources[op, t] == true)      && // Достаточно свободных ресурсов на нужном месте.
+                    (and (conf_op in conflicting_operations[op]) (op_status[conf_op, t] == false))
+                                                                  && // Не выполняется ни одной конфликтующей операции.
+                    ((is_moving_operation[op] == 1) => is_involved_in_cargo_op[main_obj_of_operation[op], t] == false)
+                                                                  && // Если это операция перемещения, то главный объект
+                                                                     // не участвует в операциях погрузки.
+                    (((is_mooring_op[op] == 1) && (operations_destination[op] mod 2 == 0)) => (
+                        current_moored_obj[operations_destination[op], t] == 0)
+                    )                                             && // Если это операция пришвартовки, то в этот интервал
+                                                                     // причал должен быть свободным.
+                    (is_cargo_op_not_exceeds_storage_limits[op, t] == 1)  && // Если это операция грузообработки, то она не выведет
+                                                                     // объём берегового хранилища и хранилища судна за
+                                                                     // границы дозволенного.
+                    (((is_moving_operation[op] == 0) && (main_obj_start_loc[op] mod 2 == 1)) =>
+                        ((current_moored_obj[twin_location[main_obj_start_loc[op]], t] == 0) ||
+                         (current_moored_obj[twin_location[main_obj_start_loc[op]], t] == main_obj_of_operation[op]))
+                    )                                             && // Если это операция грузообработки без пришвартовки,
+                                                                     // то причал должен быть свободен в этот интервал, либо
+                                                                     // главный объект должен быть уже условно пришвартован.
+                    (((bunker_of_cargo_op[op] != 0) && (op_status[op, t] == 0)) =>
+                        ((m_obj_loc[bunker_of_cargo_op[op], t] == bunker_start_loc[op]) &&
+                         (current_moving_operation[bunker_of_cargo_op[op], t] == 0))
+                    )                                                // Бункеровщик (если есть) находится в нужной локации
+                                                                     // и не участвует в операциях перемещения.
+                )
+            );
+    
+        // Сам критерий оптимизации - если если операцию можно было начать на 1 интервал раньше, то её нужно начать раньше.
+            forall (op in 1..n_operations, t in 2..n_intervals) (
+                ((op_start[op, t] == 1) && (is_fixed[op, t] == 0)) => (is_op_possible[op, t - 1] == 0)
+            );
+    
+    // Оптимизация - есть две соседние операции погрузки - первая операция должна быть максимально загруженной.
+        forall (op in 1..n_operations, t in 2..n_intervals) (
+            ((cargo_op_intensity[op, t - 1] != 0) && (cargo_op_intensity[op, t] != 0)) => (
+                (cargo_op_intensity[op, t - 1] == loading_op_abs_delta[op]) || // Операция достигла предела интенсивности.
+                (is_cargo_op_not_exceeds_storage_limits[op, t - 1] == 0)       // Или операция нарушит границы хранилищ
+                                                                           ||  // при увеличении интенсивности.
+                (is_fixed[op, t] == 1)                                         // Или операция фиксирована.
+            )
+        );
+    
+    // Оптимизация - судно возвращается откуда перед этим пришло -> оно сделало или делает что-то "полезное".
+        forall (t in 0..(n_intervals + 1)) (prev_m_obj_loc[0, t] == 1);
+        forall (t in 0..(n_intervals + 1)) (is_obj_involved_in_useful_operation[0, t] == 0);
+    
+        // Определение prev_m_obj_loc
+            forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
+                (m_obj_loc[obj, t - 1] != m_obj_loc[obj, t]) => (prev_m_obj_loc[obj, t] == m_obj_loc[obj, t - 1])
+            );
+            forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
+                (m_obj_loc[obj, t - 1] == m_obj_loc[obj, t]) => (prev_m_obj_loc[obj, t] == prev_m_obj_loc[obj, t - 1])
+            );
+            forall (obj in 1..n_moving_obj) (prev_m_obj_loc[obj, 0] == m_obj_loc[obj, 0]);
+    
+        // Определение is_obj_involved_in_useful_operation
+            forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
+                is_obj_involved_in_useful_operation[obj, t] == (
+                       (participation_as_resource[obj, t] != 0)
+                    || (or (op in related_cargo_op[obj]) (op_status[op, t] == 1))
+                    || (is_obj_involved_in_fixed_op[obj, t] == 1)
+                    || (or (op in related_unmooring_op[obj]) (op_status[op, t] == 1))
+                )
+            );
+            forall (obj in 1..n_moving_obj) (is_obj_involved_in_useful_operation[obj, 0] == 0);
+    
+        // Определение is_attended_useful_op_in_cur_loc
+            forall (t in 0..(n_intervals + 1)) (is_attended_useful_op_in_cur_loc[0, t] == 0);
+    
+            forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
+                is_attended_useful_op_in_cur_loc[obj, t] == (
+                    ((is_attended_useful_op_in_cur_loc[obj, t - 1] == 1) && (m_obj_loc[obj, t - 1] == m_obj_loc[obj, t])) // Предыдущее значение в текущей локации.
+                        ||
+                    (is_obj_involved_in_useful_operation[obj, t] == 1)
+                        ||
+                    (is_obj_involved_in_useful_operation[obj, t - 1] == 1) // Учитывает случай когда операция перемещения, из-за которой объект попал в локацию была нужна.
+                )
+            );
+    
+        // Сама оптимизация - если объект
+        forall (obj in 1..n_moving_obj, t in 2..(n_intervals + 1)) (
+            ((m_obj_loc[obj, t - 1] != m_obj_loc[obj, t]) && (prev_m_obj_loc[obj, t - 1] == m_obj_loc[obj, t])
+            ) => (is_attended_useful_op_in_cur_loc[obj, t - 1] == 1)
+        );
+    
+    // Оптимизация - если объект не может совершить в данной локации операции без выхода за границы хранилища, а так же если он
+    // может уйти только своим ходом, то он либо уходит немедленно, либо остаётся на месте навсегда.
+    
+        // Определение can_obj_theoretically_use_cargo_op.
+            forall (obj in 1..n_moving_obj, t in 1..(n_intervals + 1)) (
+                can_obj_theoretically_use_cargo_op[obj, t] == (
+                    (is_sections_of_moving_obj_empty[obj] == 1)
+                        ||
+                    or (section in sections_of_moving_obj[obj]) (
+                           (storage_used_volume[section, t - 1] + min_positive_cargo_val[section, main_location[m_obj_loc[obj, t]]] <= max_storage_vol[section])
+                        || (storage_used_volume[section, t - 1] + max_negative_cargo_val[section, main_location[m_obj_loc[obj, t]]] >= 0)
+                    )
+                )
+            );
+            forall (t in 0..(n_intervals + 1)) (can_obj_theoretically_use_cargo_op[0, t] == false);
+            forall (obj in 1..n_moving_obj) (can_obj_theoretically_use_cargo_op[obj, 0] == false);
+    
+        
+        forall (obj in 1..n_moving_obj) (is_obj_totally_terminated[obj, n_intervals + 1] == true);
+        forall (t in 0..(n_intervals + 1)) (is_obj_totally_terminated[0, t] == true);
+    
+        forall (obj in 1..n_moving_obj, t in 0..n_intervals) (
+            is_obj_totally_terminated[obj, t] == (
+                   (current_moving_operation[obj, t] == 0)
+                && (is_involved_in_cargo_op[obj, t] == 0)
+                && (is_obj_totally_terminated[obj, t + 1] == 1)
+            )
+        );
+    
+        // Само ограничение.
+        forall (obj in 1..n_moving_obj, t in 1..n_intervals) (
+            (   (can_obj_leave_loc_only_alone[obj, m_obj_loc[obj, t]] == 1)
+             && (can_obj_theoretically_use_cargo_op[obj, t] == 0)
+             && (is_fixed_op_planned_in_future[obj, m_obj_loc[obj, t], t] == 0)
+            ) =>
+            ((is_obj_totally_terminated[obj, t] == 1) || (current_moving_operation[obj, t] != 0))
+        );
+
+    // Критерий оптимизации
+        // В конце всё остановится.
+        (is_not_terminated[n_intervals + 1] == 0);
+    
+        // Действия ещё не остановились, если в текущий интервал что-нибудь происходит или они не остановятся в следующий интервал.
+        forall (t in 1..n_intervals) (
+            is_not_terminated[t] == (
+                (or (op in 1..n_operations) (op_status[op, t] == true))
+                    ||
+                (is_not_terminated[t + 1] == 1)
+            )
+        );
+        
+}
+
+execute {
+    writeln("op_status = ", op_status, ";");
+    writeln("m_obj_loc = ", m_obj_loc, ";");
+    writeln("op_start = ", op_start, ";");
+    writeln("is_not_terminated = ", is_not_terminated, ";");
+    writeln("storage_used_volume = ", storage_used_volume, ";");
+    
+    writeln("current_moving_operation = ", current_moving_operation, ";");
+    writeln("resources_counter = ", resources_counter, ";");
+    writeln("operation_of_counter = ", operation_of_counter, ";");
+    writeln("participation_as_resource = ", participation_as_resource, ";");
+    
+    writeln("is_involved_in_cargo_op = ", is_involved_in_cargo_op, ";");
+    
+    writeln("cargo_op_intensity = ", cargo_op_intensity, ";");
+    
+    writeln("is_op_possible = ", is_op_possible, ";");
+}
+