mesa/my_model.py

import json
from random import shuffle
import platform

import networkx as nx
import pandas as pd
from mesa import Model
from mesa.space import MultiGrid, NetworkGrid
from mesa.datacollection import DataCollector

import numpy as np
from mesa_viz_tornado.modules import NetworkModule

from firm import FirmAgent
from orm import db_session, Result
from product import ProductAgent

from mesa.visualization import ModularServer


class MyModel(Model):
    def __init__(self, params):
        # 属性
        self.is_prf_size = params['prf_size']
        self.prf_conn = params['prf_conn']
        self.cap_limit_prob_type = params['cap_limit_prob_type']
        self.cap_limit_level = params['cap_limit_level']
        self.diff_new_conn = params['diff_new_conn']

        self.firm_network = nx.MultiDiGraph()  # 有向多重图
        self.firm_prod_network = nx.MultiDiGraph()
        self.product_network = nx.MultiDiGraph()  # 有向多重图

        # NetworkGrid 用于管理网格
        # NetworkX 图对象
        self.t = 0
        self.network_graph = nx.MultiDiGraph()
        self.grid = NetworkGrid(self.network_graph)

        self.data_collector = DataCollector(
            agent_reporters={"Product": "name"}
        )

        # initialize graph bom
        self.G_bom = nx.adjacency_graph(json.loads(params['g_bom']))

        # Create the firm-product network graph
        self.G_FirmProd = nx.MultiDiGraph()
        # Create the firm network graph
        self.G_Firm = nx.MultiDiGraph()

        self.company_agents = []
        self.product_agents = []

        self.nprandom = np.random.default_rng(params['seed'])

        # Initialize parameters from `params`
        self.sample = params['sample']
        self.int_stop_ts = 0
        self.int_n_iter = int(params['n_iter'])
        self.dct_lst_init_disrupt_firm_prod = params['dct_lst_init_disrupt_firm_prod']

        # external variable
        self.int_n_max_trial = int(params['n_max_trial'])
        self.is_prf_size = bool(params['prf_size'])
        self.remove_t = int(params['remove_t'])
        self.int_netw_prf_n = int(params['netw_prf_n'])

        # 方法执行
        self.initialize_product_network(params)
        self.initialize_firm_network()
        self.initialize_firm_product_network()
        self.add_edges_to_firm_network()
        self.connect_unconnected_nodes()
        self.resource_integration()
        self.j_comp_consumed_produced()
        self.initialize_agents()
        self.initialize_disruptions()

    def initialize_product_network(self, params):
        try:
            self.product_network = nx.adjacency_graph(json.loads(params['g_bom']))
        except Exception as e:
            print(f"Failed to initialize product network: {e}")
        # 赋予 产业的量
        # 产业种类
        data = pd.read_csv('input_data/input_product_data/BomNodes.csv')
        data['Code'] = data['Code'].astype('string')
        self.type2 = data
        self.id_code = data.groupby('Code')['Index'].apply(list)
        # 设备c折旧比值
        ###

    def initialize_firm_network(self):
        # Read the firm data

        firm = pd.read_csv("input_data/input_firm_data/Firm_amended.csv")

        firm['Code'] = firm['Code'].astype(str)

        firm.fillna(0, inplace=True)

        firm_attr = firm.loc[:, ["Code", "Type_Region", "Revenue_Log"]]

        firm_industry_relation = pd.read_csv("input_data/firm_industry_relation.csv")
        firm_industry_relation['Firm_Code'] = firm_industry_relation['Firm_Code'].astype('string')

        firm_product = []

        grouped = firm_industry_relation.groupby('Firm_Code')['Product_Code'].apply(list)
        firm_product.append(grouped)

        firm_attr['Product_Code'] = firm_attr['Code'].map(grouped)
        firm_attr.set_index('Code', inplace=True)

        grouped = firm_industry_relation.groupby('Firm_Code')
        self.firm_prod_labels_dict = {code: group['Product_Code'].tolist() for code, group in grouped}

        # 遍历'Product_Code' 与 index 交换
        for index, row in firm_attr.iterrows():
            id_index_list = []
            for i in row['Product_Code']:
                for key_values in self.id_code.items():
                    if int(key_values[0]) == i:
                        for id in key_values[1]:
                            id_index_list.append(id)
                        firm_attr.at[index, 'Product_Code'] = id_index_list

        self.G_Firm.add_nodes_from(firm["Code"])
        # Assign attributes to the firm nodes
        firm_labels_dict = {code: firm_attr.loc[code].to_dict() for code in self.G_Firm.nodes}
        nx.set_node_attributes(self.G_Firm, firm_labels_dict)

        self.Firm = firm

    def initialize_firm_product_network(self):

        firm_industry_relation = pd.read_csv("input_data/firm_industry_relation.csv")
        firm_industry_relation['Firm_Code'] = firm_industry_relation['Firm_Code'].astype('string')
        firm_industry_relation['Product_Code'] = firm_industry_relation['Product_Code'].apply(lambda x: [x])
        # 将 'firm_prod' 表中的每一行作为图中的节点
        self.G_FirmProd.add_nodes_from(firm_industry_relation.index)
        # 为每个节点分配属性

        # 遍历'Product_Code' 与 index 交换
        for index, row in firm_industry_relation.iterrows():
            id_index_list = []
            for i in row['Product_Code']:
                for key_values in self.id_code.items():
                    if int(key_values[0]) == i:
                        for id in key_values[1]:
                            id_index_list.append(id)
                        firm_industry_relation.at[index, 'Product_Code'] = id_index_list

        firm_prod_labels_dict = {code: firm_industry_relation.loc[code].to_dict() for code in
                                 firm_industry_relation.index}
        nx.set_node_attributes(self.G_FirmProd, firm_prod_labels_dict)

    def add_edges_to_firm_network(self):
        """ Add edges between firms based on the product BOM relationships """
        # Add edges to G_Firm according to G_bom
        for node in nx.nodes(self.G_Firm):
            lst_pred_product_code = []
            for product_code in self.G_Firm.nodes[node]['Product_Code']:
                lst_pred_product_code += list(self.G_bom.predecessors(product_code))
            lst_pred_product_code = list(set(lst_pred_product_code))
            lst_pred_product_code = list(sorted(lst_pred_product_code))  # Ensure consistency

            for pred_product_code in lst_pred_product_code:
                # Get a list of firms producing the component (pred_product_code)
                lst_pred_firm = [firm_code for firm_code, product in self.firm_prod_labels_dict.items() if
                                 pred_product_code in product]

                # Select multiple suppliers (multi-sourcing)
                n_pred_firm = self.int_netw_prf_n
                if n_pred_firm > len(lst_pred_firm):
                    n_pred_firm = len(lst_pred_firm)

                if self.is_prf_size:
                    # 获取 firm 的 size 列表
                    lst_pred_firm_size = [self.G_Firm.nodes[pred_firm]['Revenue_Log'] for pred_firm in lst_pred_firm]
                    # 检查 lst_pred_firm_size 是否为空或总和为 0
                    if len(lst_pred_firm_size) == 0 or sum(lst_pred_firm_size) == 0:
                        # print("警告: lst_pred_firm_size 为空或总和为 0，无法生成概率分布")
                        lst_choose_firm = []  # 返回空结果，或根据需要处理
                    else:
                        # 计算总和
                        sum_pred_firm_size = sum(lst_pred_firm_size)
                        # 归一化生成 lst_prob
                        lst_prob = [size / sum_pred_firm_size for size in lst_pred_firm_size]
                        # 使用 np.isclose() 确保概率总和接近 1
                        if not np.isclose(sum(lst_prob), 1.0):
                            # print(f"警告: 概率总和为 {sum(lst_prob)}，现在进行修正")
                            lst_prob = [prob / sum(lst_prob) for prob in lst_prob]
                        # 确保没有负值或 0
                        lst_prob = [max(0, prob) for prob in lst_prob]
                        # 根据修正后的概率选择 firm
                        lst_choose_firm = self.nprandom.choice(lst_pred_firm, n_pred_firm, replace=False, p=lst_prob)
                else:
                    # 直接进行随机选择
                    lst_choose_firm = self.nprandom.choice(lst_pred_firm, n_pred_firm, replace=False)

                # Add edges from predecessor firms to current node (firm)
                lst_add_edge = [(pred_firm, node, {'Product': pred_product_code}) for pred_firm in lst_choose_firm]
                self.G_Firm.add_edges_from(lst_add_edge)

                # Add edges to firm-product network
                self.add_edges_to_firm_product_network(node, pred_product_code, lst_choose_firm)

    def add_edges_to_firm_product_network(self, node, pred_product_code, lst_choose_firm):
        """ Helper function to add edges to the firm-product network """
        set_node_prod_code = set(self.G_Firm.nodes[node]['Product_Code'])
        set_pred_succ_code = set(self.G_bom.successors(pred_product_code))
        lst_use_pred_prod_code = list(set_node_prod_code & set_pred_succ_code)

        if len(lst_use_pred_prod_code) == 0:
            print("错误")

        pred_node_list = []
        for pred_firm in lst_choose_firm:
            for n, v in self.G_FirmProd.nodes(data=True):
                for v1 in v['Product_Code']:
                    if v1 == pred_product_code and v['Firm_Code'] == pred_firm:
                        pred_node_list.append(n)
            if len(pred_node_list) != 0:
                pred_node = pred_node_list[0]
            else:
                pred_node = -1
            current_node_list = []
            for use_pred_prod_code in lst_use_pred_prod_code:
                for n, v in self.G_FirmProd.nodes(data=True):
                    for v1 in v['Product_Code']:
                        if v1 == use_pred_prod_code and v['Firm_Code'] == node:
                            current_node_list.append(n)
            if len(current_node_list) != 0:
                current_node = current_node_list[0]
            else:
                current_node = -1
            if current_node != -1 and pred_node != -1:
                self.G_FirmProd.add_edge(pred_node, current_node)

    def connect_unconnected_nodes(self):
        """ Connect unconnected nodes in the firm network """
        for node in nx.nodes(self.G_Firm):
            if self.G_Firm.degree(node) == 0:
                current_node_list = []
                for product_code in self.G_Firm.nodes[node]['Product_Code']:
                    for n, v in self.G_FirmProd.nodes(data=True):
                        for v1 in v['Product_Code']:
                            if v['Firm_Code'] == node and v1 == product_code:
                                current_node_list.append(n)
                    if len(current_node_list) != 0:
                        current_node = current_node_list[0]
                    else:
                        current_node = -1
                    lst_succ_product_code = list(self.G_bom.successors(product_code))

                    for succ_product_code in lst_succ_product_code:
                        lst_succ_firm = [firm_code for firm_code, product in self.firm_prod_labels_dict.items() if
                                         succ_product_code in product]

                        n_succ_firm = self.int_netw_prf_n
                        if n_succ_firm > len(lst_succ_firm):
                            n_succ_firm = len(lst_succ_firm)

                        if self.is_prf_size:
                            lst_succ_firm_size = [self.G_Firm.nodes[succ_firm]['Revenue_Log'] for succ_firm in
                                                  lst_succ_firm]
                            if len(lst_succ_firm_size) == 0 or sum(lst_succ_firm_size) == 0:
                                # print("警告: lst_pred_firm_size 为空或总和为 0，无法生成概率分布")
                                lst_choose_firm = []  # 返回空结果，或根据需要处理
                            else:
                                # 计算总和
                                sum_pred_firm_size = sum(lst_succ_firm_size)
                                # 归一化生成 lst_prob
                                lst_prob = [size / sum_pred_firm_size for size in lst_succ_firm_size]
                                # 使用 np.isclose() 确保概率总和接近 1
                                if not np.isclose(sum(lst_prob), 1.0):
                                    # print(f"警告: 概率总和为 {sum(lst_prob)}，现在进行修正")
                                    lst_prob = [prob / sum(lst_prob) for prob in lst_prob]

                                # 确保没有负值或 0
                                lst_prob = [max(0, prob) for prob in lst_prob]

                                lst_choose_firm = self.nprandom.choice(lst_succ_firm, n_succ_firm, replace=False,
                                                                       p=lst_prob)
                        else:
                            lst_choose_firm = self.nprandom.choice(lst_succ_firm, n_succ_firm, replace=False)

                        lst_add_edge = [(node, succ_firm, {'Product': product_code}) for succ_firm in
                                        lst_choose_firm]
                        self.G_Firm.add_edges_from(lst_add_edge)

                        # Add edges to firm-product network
                        succ_node_list = []
                        for succ_firm in lst_choose_firm:
                            for n, v in self.G_FirmProd.nodes(data=True):
                                for v1 in v['Product_Code']:
                                    if v1 == succ_product_code and v['Firm_Code'] == succ_firm:
                                        succ_node_list.append(n)
                            if len(succ_node_list) != 0:
                                succ_node = succ_node_list[0]
                            else:
                                succ_node = -1

                            if current_node != -1 and succ_node != -1:
                                self.G_FirmProd.add_edge(current_node, succ_node)

        self.sample.g_firm = json.dumps(nx.adjacency_data(self.G_Firm))
        self.firm_network = self.G_Firm  # 直接使用 networkx 图对象
        self.firm_prod_network = self.G_FirmProd  # 直接使用 networkx 图对象

    def initialize_agents(self):
        """ Initialize agents and add them to the model. """

        for ag_node, attr in self.product_network.nodes(data=True):
            # 产业种类

            type2 = self.type2[self.type2["Index"] == ag_node]["产业种类"]
            # depreciation ratio 折旧比值
            # product_id = product_id.iloc[0]
            product = ProductAgent(ag_node, self, name=attr['Name'], type2=type2)
            self.add_agent(product)
            # self.grid.place_agent(product, ag_node)
            ##print(f"Product agent created: {product.name}, ID: {product.unique_id}")

        for ag_node, attr in self.firm_network.nodes(data=True):
            a_lst_product = [agent for agent in self.product_agents if agent.unique_id in attr['Product_Code']]
            firm_id = self.Firm['Code'] == ag_node
            n_equip_c = self.Firm.loc[firm_id, '设备数量'].values[0]

            demand_quantity = self.data_consumed[self.data_consumed['Firm_Code'] == ag_node]

            production_output = self.data_produced[self.data_consumed['Firm_Code'] == ag_node]

            # c购买价格？ 数据预处理
            # c_price = self.Firm.loc[self.Firm['Code'] == ag_node, 'c_price'].values[0]

            # 资源 资源库存信息 利用 firm_resource
            R = self.firm_resource_R.loc[firm_id].to_list()[0]
            P = self.firm_resource_P.loc[firm_id].to_list()[0]
            C = self.firm_resource_C.loc[firm_id].to_list()[0]

            firm_agent = FirmAgent(
                ag_node, self,
                type_region=attr['Type_Region'],
                revenue_log=attr['Revenue_Log'],
                n_equip_c=n_equip_c,
                a_lst_product=a_lst_product,
                demand_quantity=demand_quantity,
                production_output=production_output,
                # c_price=c_price,
                R=R,
                P=P,
                C=C
            )
            self.add_agent(firm_agent)

            ##print(f"Firm agent created: {firm_agent.unique_id}, Products: {[p.name for p in a_lst_product]}")
            # self.grid.place_agent(firm_agent, ag_node)

    def initialize_disruptions(self):
        # 初始化一部字典，用于存储每个公司及其对应的受干扰产品列表
        t_dct = {}

        # 遍历初始公司-产品干扰数据，将其转化为基于公司和产品的映射
        for firm_code, lst_product in self.dct_lst_init_disrupt_firm_prod.items():
            # 从 company_agents 列表中选择指定公司
            firms = [firm for firm in self.company_agents if firm.unique_id == firm_code]
            firm = firms[0] if firms else None

            # 从总产品列表中选择该公司受干扰的产品
            disrupted_products = [product for product in self.product_agents if product.unique_id in lst_product]

            # 将公司与其受干扰的产品映射到字典中
            if firm is not None:
                t_dct[firm] = disrupted_products

        # 更新 self.dct_lst_init_disrupt_firm_prod 字典，存储公司及其受干扰的产品
        self.dct_lst_init_disrupt_firm_prod = t_dct

        # 设置初始受干扰的公司产品状态
        for firm, a_lst_product in self.dct_lst_init_disrupt_firm_prod.items():
            for product in a_lst_product:
                # 确保产品存在于公司的生产状态字典中
                assert product in firm.dct_prod_up_prod_stat.keys(), \
                    f"Product {product.code} not in firm {firm.code}"

                # 将产品状态更新为干扰状态，并记录干扰时间
                firm.dct_prod_up_prod_stat[product]['p_stat'].append(('D', self.t))

    def add_agent(self, agent):
        if isinstance(agent, FirmAgent):
            self.company_agents.append(agent)
        elif isinstance(agent, ProductAgent):
            self.product_agents.append(agent)

    def resource_integration(self):
        data_R = pd.read_csv("input_data/input_firm_data/firms_materials.csv")
        data_C = pd.read_csv("input_data/input_firm_data/firms_devices.csv")
        data_P = pd.read_csv("input_data/input_firm_data/firms_products.csv")
        device_salvage_values = pd.read_csv('input_data/device_salvage_values.csv')

        self.device_salvage_values = device_salvage_values

        data_merged_C = pd.merge(data_C, device_salvage_values, on='设备id', how='left')

        firm_resource_R = (data_R.groupby('Firm_Code')[['材料id', '材料数量']]
                           .apply(lambda x: x.values.tolist()))
        firm_resource_C = (data_merged_C.groupby('Firm_Code')[['设备id', '设备数量', '设备残值']]
                           .apply(lambda x: x.values.tolist()))

        firm_resource_P = (data_P.groupby('Firm_Code')[['产品id', '产品数量']]
                           .apply(lambda x: x.values.tolist()))

        self.firm_resource_R = firm_resource_R
        self.firm_resource_C = firm_resource_C
        self.firm_resource_P = firm_resource_P

    def j_comp_consumed_produced(self):
        # 着重修改这 然后考虑逻辑 如何传递值
        data_consumed = pd.read_csv('input_data/input_firm_data/firms_materials.csv')
        data_produced = pd.read_csv('input_data/input_firm_data/firms_products.csv')

        data_not_consumed = data_consumed.groupby('Firm_Code')[['消耗材料id', '材料数量']] \
            .apply(lambda x: dict(zip(x['消耗材料id'], x['材料数量']))) \
            .reset_index(name='Material_not_Consumed')

        # 这里简单设置为折半 考虑 企业的设备量
        # 可以引入 换算率 也就是 材料——计算产品比例 通过上游产业 现在假设为 2:1 的比例
        data_consumed = data_consumed.groupby('Firm_Code')[['消耗材料id', '材料数量']] \
            .apply(lambda x: dict(zip(x['消耗材料id'], x['材料数量'] / 2))) \
            .reset_index(name='Material_not_Consumed')

        self.data_consumed = data_consumed
        self.data_produced = data_consumed / 2

    def step(self):
        # 1. Remove edge to customer and disrupt customer up product
        for firm in self.company_agents:
            for prod in firm.dct_prod_up_prod_stat.keys():
                status, ts = firm.dct_prod_up_prod_stat[prod]['p_stat'][-1]
                if status == 'D' and ts == self.t - 1:
                    firm.remove_edge_to_cus(prod)

        for firm in self.company_agents:
            for prod in firm.dct_prod_up_prod_stat.keys():
                for up_prod in firm.dct_prod_up_prod_stat[prod]['s_stat'].keys():
                    if firm.dct_prod_up_prod_stat[prod]['s_stat'][up_prod]['set_disrupt_firm']:
                        firm.disrupt_cus_prod(prod, up_prod)

        # 2. Trial Process
        for n_trial in range(self.int_n_max_trial):
            shuffle(self.company_agents)  # 手动打乱代理顺序

            is_stop_trial = True
            for firm in self.company_agents:
                lst_seek_prod = []
                for prod in firm.dct_prod_up_prod_stat.keys():
                    status = firm.dct_prod_up_prod_stat[prod]['p_stat'][-1][0]
                    if status == 'D':
                        for supply in firm.dct_prod_up_prod_stat[prod]['s_stat'].keys():
                            if not firm.dct_prod_up_prod_stat[prod]['s_stat'][supply]['stat']:
                                lst_seek_prod.append(supply)
                lst_seek_prod = list(set(lst_seek_prod))
                if len(lst_seek_prod) > 0:
                    is_stop_trial = False
                for supply in lst_seek_prod:
                    firm.seek_alt_supply(supply)
            if is_stop_trial:
                break

            # Handle requests
            shuffle(self.company_agents)  # 手动打乱代理顺序
            for firm in self.company_agents:
                if len(firm.dct_request_prod_from_firm) > 0:
                    firm.handle_request()

            # Reset dct_request_prod_from_firm
            for firm in self.company_agents:
                firm.clean_before_trial()

        # 3. 判断是否需要购买资源 判断是否需要购买机器
        purchase_material_firms = {}
        purchase_machinery_firms = {}
        material_list = []
        machinery_list = []
        list_seek_material_firm = []  # 每一个收到请求的企业
        list_seek_machinery_firm = []  # 每一个收到请求的企业

        for firm in self.company_agents:
            # 资源
            for sub_list in firm.R:
                if sub_list[1] <= firm.s_r:
                    required_material_quantity = firm.S_r - sub_list[1]
                    (material_list.append([sub_list[0], required_material_quantity]))
                    purchase_material_firms[firm] = material_list
            # 设备
            for sub_list in firm.C:
                # 对于设备的required_machinery_quantity 要有所改变 根据残值而言！ 每一个周期固定减少残值值 x  firm 里面定义
                sub_list[2] -= firm.x
                if sub_list[2] <= 0:  # 残值小于等于 0 时
                    sub_list[1] -= 1
                    required_machinery_quantity = 1  # 补回原来的量 也就是 1
                    (machinery_list
                     .append([sub_list[0], required_machinery_quantity]))
                    purchase_machinery_firms[firm] = machinery_list

            # 寻源并发送请求 决定是否接受供应 并更新
            for material_firm_key, sub_list_values in purchase_material_firms.items():
                for mater_list in sub_list_values:
                    result = material_firm_key.seek_material_supply(mater_list[0])
                    # 如果 result 不等于 -1，才将其添加到 list_seek_material_firm 列表中
                    if result != -1:
                        list_seek_material_firm.append(result)

                    if len(list_seek_material_firm) != 0:
                        for seek_material_firm in list_seek_material_firm:
                            seek_material_firm.handle_material_request(mater_list)  # 更新产品
                            for R_list in firm.R:
                                R_list[1] = firm.S_r

            for machinery_firm, sub_list in purchase_machinery_firms.items():
                for machi_list in sub_list:
                    # 执行一次调用 machinery_firm.seek_machinery_supply(machinery_list[0])
                    result = machinery_firm.seek_machinery_supply(machi_list[0])
                    # 如果 result 不等于 -1，才将其添加到 list_seek_machinery_firm 列表中
                    if result != -1:
                        list_seek_machinery_firm.append(result)

                    if len(list_seek_machinery_firm) != 0:
                        for seek_machinery_firm in list_seek_machinery_firm:
                            seek_machinery_firm.handle_machinery_request(machi_list)
                            for C_list, C0_list in zip(firm.C, firm.C0):
                                C_list[1] = C0_list[1]  # 赋值回去
                                C_list[2] = C0_list[2]
            # 消耗资源过程
            # 这里需要修改
            for r_id, r_nums in firm.R.items():
                for consumed_id, consumed_nums in firm.c_consumption:
                    if consumed_id == r_id:
                        r_nums = r_nums - consumed_nums

            # 生产产品过程
            for p_id, p_nums in firm.P.items():
                for product_id, product_nums in firm.c_consumption:
                    if product_id == p_id:
                        p_nums = p_nums + product_nums

            firm.refresh_R()
            # 刷新 C状态
            firm.refresh_C()
            # 刷新  P状态
            firm.refresh_P()
        # Increment the time step
        self.t += 1

    def end(self):
        # print('/' * 20, 'output', '/' * 20)

        qry_result = db_session.query(Result).filter_by(s_id=self.sample.id)
        if qry_result.count() == 0:
            lst_result_info = []
            for firm in self.company_agents:
                for prod, dct_status_supply in \
                        firm.dct_prod_up_prod_stat.items():
                    lst_is_normal = [stat == 'N' for stat, _
                                     in dct_status_supply['p_stat']]
                    if not all(lst_is_normal):
                        # print(f"{firm.name} {prod.code}:")
                        # print(dct_status_supply['p_stat'])
                        for status, ts in dct_status_supply['p_stat']:
                            db_r = Result(s_id=self.sample.id,
                                          id_firm=firm.unique_id,
                                          id_product=prod.unique_id,
                                          ts=ts,
                                          status=status)
                            lst_result_info.append(db_r)
            db_session.bulk_save_objects(lst_result_info)
            db_session.commit()
        self.sample.is_done_flag = 1
        self.sample.computer_name = platform.node()
        self.sample.stop_t = self.int_stop_ts
        db_session.commit()