stn_task_management.h

// Copyright 2023 The SOLA authors
//
// This file is part of DAISI.
//
// DAISI is free software: you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation; version 2.
//
// DAISI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
// Public License for more details.
//
// You should have received a copy of the GNU General Public License along with DAISI. If not, see
// <https://www.gnu.org/licenses/>.
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef DAISI_CPPS_LOGICAL_TASK_MANAGEMENT_STN_TASK_MANAGEMENT_H_
#define DAISI_CPPS_LOGICAL_TASK_MANAGEMENT_STN_TASK_MANAGEMENT_H_
 
#include <memory>
 
#include "auction_based_task_management.h"
#include "cpps/amr/amr_mobility_helper.h"
#include "cpps/amr/physical/material_flow_functionality_mapping.h"
#include "datastructure/simple_temporal_network.tpp"
#include "stn_task_management_components.h"
 
namespace daisi::cpps::logical {
 
class StnTaskManagement
    : public AuctionBasedTaskManagement,
      private daisi::datastructure::SimpleTemporalNetwork<StnTaskManagementVertex,
                                                          StnTaskManagementEdge> {
public:
  struct StnInsertionPoint : public InsertionPoint {
    StnTaskManagementVertex previous_finish;
    std::optional<StnTaskManagementVertex> next_start;
    int new_index;
  };
 
  StnTaskManagement(const AmrDescription &amr_description, const Topology &topology,
                    const daisi::util::Pose &pose);
 
  ~StnTaskManagement() override = default;
 
  bool hasTasks() const override;
 
  daisi::material_flow::Task getCurrentTask() const override;
 
  bool setNextTask() override;
 
  bool canAddTask(const daisi::material_flow::Task &task,
                  std::shared_ptr<InsertionPoint> insertion_point = nullptr) override;
 
  bool addTask(const daisi::material_flow::Task &task,
               std::shared_ptr<InsertionPoint> insertion_point = nullptr) override;
  std::pair<MetricsComposition, std::shared_ptr<InsertionPoint>> getLatestCalculatedInsertionInfo()
      const override;
 
  void setCurrentTime(const daisi::util::Duration &now);
 
  using VertexIterator = std::vector<StnTaskManagementVertex>::iterator;
 
  struct TaskInsertInfo {
    daisi::material_flow::Task task;
 
    // for each order their location at the end of their execution
    std::vector<daisi::material_flow::Location> end_locations;
 
    MetricsComposition metrics_composition;
  };
 
protected:
  std::optional<daisi::material_flow::Task> current_task_;
 
  std::optional<daisi::material_flow::Location> current_task_end_location_;
 
  daisi::util::Duration current_task_expected_finish_time_ = 0.0;
 
  std::vector<TaskInsertInfo> current_ordering_;
 
  Metrics current_total_metrics_;
 
  std::vector<TaskInsertInfo>::iterator newest_task_insert_info_;
 
  daisi::util::Duration time_now_ = 0;
 
  std::optional<std::pair<MetricsComposition, std::shared_ptr<InsertionPoint>>>
      latest_calculated_insertion_info_;
 
  bool solve() override;
 
  void addPrecedenceConstraintBetweenTask(const StnTaskManagementVertex &start_vertex,
                                          const std::string &precedence_task_name);
 
  void addDurationConstraints(const StnTaskManagementVertex &start_vertex,
                              const StnTaskManagementVertex &finish_vertex,
                              const daisi::material_flow::Order &order,
                              const TaskInsertInfo &task_insert_info);
 
  void updateGetToStartDurationConstraint(int task_index_to_update);
 
  util::Duration calcGetToStartDuration(int task_index_to_update);
 
  void addOrderingConstraintBetweenTasks(StnInsertionPoint insertion_point,
                                         TaskInsertInfo &task_insert_info);
 
  std::optional<std::pair<MetricsComposition, std::shared_ptr<StnInsertionPoint>>> addBestOrdering(
      StnTaskManagement::TaskInsertInfo &task_insert_info);
 
  std::vector<StnInsertionPoint> calcInsertionPoints();
 
  void updateCurrentOrdering();
 
  daisi::util::Position getLastPositionBefore(int task_index);
 
  daisi::util::Duration calcOrderDurationForInsert(const daisi::material_flow::Order &order,
                                                   const TaskInsertInfo &task_insert_info) const;
 
  void insertOrderPropertiesIntoMetrics(const daisi::material_flow::Order &order, Metrics &metrics,
                                        const TaskInsertInfo &task_insert_info,
                                        int task_ordering_index);
 
  // simple helper
  VertexIterator getVertexIteratorOfOrder(const daisi::material_flow::Order &order, bool start);
  int getVertexIndexOfOrder(const daisi::material_flow::Order &order, bool start);
  const StnTaskManagementVertex &getVertexOfOrder(const daisi::material_flow::Order &order,
                                                  bool start);
 
private:
  void updateOriginConstraints(const daisi::util::Duration &time_difference);
};
 
}  // namespace daisi::cpps::logical
 
#endif