236 lines
11 KiB
C++
236 lines
11 KiB
C++
/**
|
|
* @file FactoryGraphManager.hpp
|
|
* @author The ARTIS Development Team
|
|
* See the AUTHORS or Authors.txt file
|
|
*/
|
|
|
|
/*
|
|
* ARTIS - the multimodeling and simulation environment
|
|
* This file is a part of the ARTIS environment
|
|
*
|
|
* Copyright (C) 2013-2023 ULCO http://www.univ-littoral.fr
|
|
*
|
|
* This program 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, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef ARTIS_FACTORY_FACTORY_GRAPH_MANAGER_HPP
|
|
#define ARTIS_FACTORY_FACTORY_GRAPH_MANAGER_HPP
|
|
|
|
#include "Base.hpp"
|
|
#include "FactoryGraphManagerParameters.hpp"
|
|
#include "ItemStock.hpp"
|
|
#include "JsonReader.hpp"
|
|
#include "PoolRouter.hpp"
|
|
#include "Router.hpp"
|
|
#include "Stock.hpp"
|
|
|
|
#include <artis-star/kernel/pdevs/GraphManager.hpp>
|
|
|
|
namespace artis::factory {
|
|
|
|
class FactoryGraphManager
|
|
: public artis::pdevs::GraphManager<artis::common::DoubleTime, artis::common::NoParameters, FactoryGraphManagerParameters> {
|
|
public:
|
|
enum sub_models {
|
|
GENERATOR, ROUTER, POOL_ROUTER, MACHINE = 10000, ITEM_STOCK = 20000, STOCK = 30000
|
|
};
|
|
|
|
FactoryGraphManager(Coordinator *coordinator, const artis::common::NoParameters ¶meters,
|
|
const FactoryGraphManagerParameters &graph_parameters) :
|
|
artis::pdevs::GraphManager<artis::common::DoubleTime, artis::common::NoParameters, FactoryGraphManagerParameters>(
|
|
coordinator, parameters, graph_parameters) {
|
|
unsigned int machine_index = 0;
|
|
|
|
ProductionOrderGeneratorParameters generator_parameters{graph_parameters.get_programs(),
|
|
graph_parameters.factory._generator._random_seed,
|
|
graph_parameters.factory._generator._min_send_speed_rate,
|
|
graph_parameters.factory._generator._max_send_speed_rate,
|
|
graph_parameters.factory._generator._po_number,
|
|
graph_parameters.factory._generator._po_order};
|
|
|
|
_generator = new GeneratorSimulator("G", generator_parameters);
|
|
_router = new RouterSimulator("R", {graph_parameters.factory._pools.size()});
|
|
|
|
this->add_child(ROUTER, _router);
|
|
this->add_child(GENERATOR, _generator);
|
|
|
|
// item stocks
|
|
for (const auto &p: graph_parameters.factory._stocks) {
|
|
_item_stocks.push_back(
|
|
new ItemStockSimulator("I_S_" + std::to_string(p._id),
|
|
ItemStockParameters{graph_parameters.get_item_stock(p._id),
|
|
graph_parameters.get_machines_to_item_stock(p._id)}));
|
|
this->add_child(ITEM_STOCK + p._id, _item_stocks.back());
|
|
}
|
|
|
|
// intermediate stocks
|
|
for (const auto &p: graph_parameters.factory._pools) {
|
|
unsigned int pool_id = std::get<0>(p);
|
|
for (const auto &s: std::get<3>(p)) {
|
|
_stocks[std::make_pair(pool_id, s._id)] = new StockSimulator(
|
|
"S_" + std::to_string(pool_id) + "_" + std::to_string(s._id),
|
|
StockParameters{graph_parameters.get_machines_to_in_stock(pool_id, s._id),
|
|
graph_parameters.get_machines_to_out_stock(pool_id, s._id),
|
|
s._capacity});
|
|
this->add_child(STOCK + pool_id * 100 + s._id, _stocks[std::make_pair(pool_id, s._id)]);
|
|
}
|
|
}
|
|
|
|
// pool + machines
|
|
for (const auto &p: graph_parameters.factory._pools) {
|
|
unsigned int pool_id = std::get<0>(p);
|
|
std::map<unsigned int, unsigned int> capacities;
|
|
|
|
for (const auto &m: std::get<2>(p)) {
|
|
capacities[m->machine_id] = m->capacity;
|
|
}
|
|
_pool_routers.push_back(
|
|
new PoolRouterSimulator("P_R_" + std::to_string(pool_id), PoolRouterParameters{std::get<1>(p), capacities}));
|
|
this->add_child(POOL_ROUTER + std::get<0>(p), _pool_routers.back());
|
|
out({_router, artis::factory::Router::outputs::OUT_P + pool_id})
|
|
>> in({_pool_routers.back(), artis::factory::PoolRouter::inputs::IN});
|
|
out({_pool_routers.back(), artis::factory::PoolRouter::outputs::OUT})
|
|
>> in({_router, artis::factory::Router::inputs::IN_P + pool_id});
|
|
|
|
// machines
|
|
for (const auto &m: std::get<2>(p)) {
|
|
switch (m->machine_type) {
|
|
case PROCESSOR: {
|
|
auto &processor_parameters = (ProcessorParameters &) (*m);
|
|
auto new_processor = new ProcessorSimulator(
|
|
"M_" + std::to_string(m->pool_id) + "_" + std::to_string(m->machine_id), processor_parameters);
|
|
|
|
_processors.push_back(new_processor);
|
|
this->add_child(MACHINE + machine_index, new_processor);
|
|
|
|
// connection processor <-> pool router
|
|
out({_pool_routers.back(), artis::factory::PoolRouter::outputs::OUT_M + m->machine_id})
|
|
>> in({new_processor, artis::factory::Processor::inputs::IN});
|
|
out({new_processor, artis::factory::Processor::outputs::OUT})
|
|
>> in({_pool_routers.back(), artis::factory::PoolRouter::inputs::IN_M + m->machine_id});
|
|
|
|
// connection processor <-> item stock
|
|
std::vector<unsigned int> item_stocks;
|
|
|
|
for (const auto &q: processor_parameters.in_out) {
|
|
for (const auto &r: q.second._ins) {
|
|
if (r._source._pool_id == -1) {
|
|
item_stocks.push_back(r._source._stock_id);
|
|
}
|
|
}
|
|
}
|
|
for (const auto &q: item_stocks) {
|
|
out({new_processor, artis::factory::Processor::outputs::OUT_ITEM_DEMAND + q})
|
|
>> in({_item_stocks.back(), artis::factory::ItemStock::inputs::IN + m->machine_id});
|
|
out({_item_stocks.back(), artis::factory::ItemStock::outputs::OUT + m->machine_id})
|
|
>> in({new_processor, artis::factory::Processor::inputs::IN_ITEM});
|
|
}
|
|
// connection processor <-> intermediate stock
|
|
std::vector<std::pair<unsigned int, unsigned int>> stocks;
|
|
|
|
for (const auto &q: processor_parameters.in_out) {
|
|
for (const auto &r: q.second._outs) {
|
|
auto u = std::make_pair((unsigned int) r._destination._pool_id, r._destination._stock_id);
|
|
|
|
if (r._destination._pool_id != -1 and std::find(stocks.cbegin(), stocks.cend(), u) == stocks.cend()) {
|
|
stocks.push_back(u);
|
|
}
|
|
}
|
|
}
|
|
for (const auto &q: stocks) {
|
|
out({new_processor, artis::factory::Processor::outputs::OUT_STOCK + (q.first * 100 + q.second)})
|
|
>> in({_stocks[q], artis::factory::Stock::inputs::IN});
|
|
out({new_processor, artis::factory::Processor::outputs::OUT_STOCK_AVAILABLE + (q.first * 100 + q.second)})
|
|
>> in({_stocks[q], artis::factory::Stock::inputs::IN_STOCK_AVAILABLE + m->machine_id});
|
|
out({_stocks[q], artis::factory::Stock::outputs::OUT_STOCK_AVAILABLE + m->machine_id})
|
|
>> in(
|
|
{new_processor, artis::factory::Processor::inputs::IN_STOCK_AVAILABLE + (q.first * 100 + q.second)});
|
|
}
|
|
stocks.clear();
|
|
for (const auto &q: processor_parameters.in_out) {
|
|
for (const auto &r: q.second._ins) {
|
|
auto u = std::make_pair((unsigned int) r._source._pool_id, r._source._stock_id);
|
|
|
|
if (r._source._pool_id != -1 and std::find(stocks.cbegin(), stocks.cend(), u) == stocks.cend()) {
|
|
stocks.push_back(u);
|
|
}
|
|
}
|
|
}
|
|
for (const auto &q: stocks) {
|
|
out({new_processor, artis::factory::Processor::outputs::OUT_STOCK_DEMAND + (q.first * 100 + q.second)})
|
|
>> in({_stocks[q], artis::factory::Stock::inputs::IN_DEMAND + m->machine_id});
|
|
out({_stocks[q], artis::factory::Stock::outputs::OUT + m->machine_id})
|
|
>> in({new_processor, artis::factory::Processor::inputs::IN_STOCK});
|
|
}
|
|
++machine_index;
|
|
break;
|
|
}
|
|
case SINK: {
|
|
auto new_sink = new SinkSimulator(
|
|
"M_" + std::to_string(m->pool_id) + "_" + std::to_string(m->machine_id), (SinkParameters &) (*m));
|
|
|
|
_sinks.push_back(new_sink);
|
|
this->add_child(MACHINE + machine_index, new_sink);
|
|
|
|
// connection sink <-> pool router
|
|
out({_pool_routers.back(), artis::factory::PoolRouter::outputs::OUT_M + m->machine_id})
|
|
>> in({new_sink, artis::factory::Sink::inputs::IN});
|
|
out({new_sink, artis::factory::Sink::outputs::OUT})
|
|
>> in({_pool_routers.back(), artis::factory::PoolRouter::inputs::FINISH});
|
|
++machine_index;
|
|
break;
|
|
}
|
|
case SEPARATOR: {
|
|
// TODO
|
|
break;
|
|
}
|
|
case COMBINER : {
|
|
// TODO
|
|
break;
|
|
}
|
|
case CONVEYOR : {
|
|
// TODO
|
|
break;
|
|
}
|
|
default: {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
out({_generator, artis::factory::ProductionOrderGenerator::outputs::OUT})
|
|
>> in({_router, artis::factory::Router::inputs::IN});
|
|
}
|
|
|
|
private:
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::ProductionOrderGenerator, artis::factory::ProductionOrderGeneratorParameters> GeneratorSimulator;
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::Router, artis::factory::RouterParameters> RouterSimulator;
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::PoolRouter, artis::factory::PoolRouterParameters> PoolRouterSimulator;
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::Processor, artis::factory::ProcessorParameters> ProcessorSimulator;
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::Sink, artis::factory::SinkParameters> SinkSimulator;
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::ItemStock, artis::factory::ItemStockParameters> ItemStockSimulator;
|
|
typedef artis::pdevs::Simulator<artis::common::DoubleTime, artis::factory::Stock, artis::factory::StockParameters> StockSimulator;
|
|
|
|
GeneratorSimulator *_generator;
|
|
RouterSimulator *_router;
|
|
std::vector<PoolRouterSimulator *> _pool_routers;
|
|
std::vector<ProcessorSimulator *> _processors;
|
|
std::vector<SinkSimulator *> _sinks;
|
|
std::vector<ItemStockSimulator *> _item_stocks;
|
|
std::map<std::pair<unsigned int, unsigned int>, StockSimulator *> _stocks;
|
|
};
|
|
|
|
}
|
|
|
|
#endif //ARTIS_FACTORY_FACTORY_GRAPH_MANAGER_HPP
|