formatting
This commit is contained in:
parent
a8d50e1f81
commit
5b0e17ce52
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -51,19 +51,22 @@ class ControllerDB:
|
|||
# break
|
||||
# break
|
||||
# list_dct = [{'140': ['1.4.5.1']}]
|
||||
list_dct = [{'133': ['1.4.4.1']}]
|
||||
# list_dct = [{'2': ['1.1.3']}]
|
||||
# list_dct = [{'135': ['1.3.2.1']}]
|
||||
for idx_exp, dct in enumerate(list_dct):
|
||||
self.add_experiment_1(idx_exp, self.dct_parameter['n_max_trial'],
|
||||
dct)
|
||||
print(f'Inserted experiment for exp {idx_exp}!')
|
||||
|
||||
def add_experiment_1(self, idx_exp, n_max_trial,
|
||||
dct_list_init_remove_firm_prod):
|
||||
dct_lst_init_remove_firm_prod):
|
||||
e = Experiment(
|
||||
idx_exp=idx_exp,
|
||||
n_sample=int(self.dct_parameter['n_sample']),
|
||||
n_iter=int(self.dct_parameter['n_iter']),
|
||||
n_max_trial=n_max_trial,
|
||||
dct_list_init_remove_firm_prod=dct_list_init_remove_firm_prod)
|
||||
dct_lst_init_remove_firm_prod=dct_lst_init_remove_firm_prod)
|
||||
db_session.add(e)
|
||||
db_session.commit()
|
||||
|
||||
|
|
|
|||
119
firm.py
119
firm.py
|
|
@ -3,7 +3,7 @@ import math
|
|||
|
||||
|
||||
class FirmAgent(ap.Agent):
|
||||
def setup(self, code, name, type_region, revenue_log, a_list_product):
|
||||
def setup(self, code, name, type_region, revenue_log, a_lst_product):
|
||||
self.firm_network = self.model.firm_network
|
||||
self.product_network = self.model.product_network
|
||||
|
||||
|
|
@ -11,81 +11,72 @@ class FirmAgent(ap.Agent):
|
|||
self.name = name
|
||||
self.type_region = type_region
|
||||
self.revenue_log = revenue_log
|
||||
self.a_list_product = a_list_product
|
||||
self.dct_prod_capacity = dict.fromkeys(self.a_list_product)
|
||||
self.a_lst_product = a_lst_product
|
||||
self.dct_prod_capacity = dict.fromkeys(self.a_lst_product)
|
||||
|
||||
self.a_list_up_product_removed = ap.AgentList(self.model, [])
|
||||
self.a_list_product_disrupted = ap.AgentList(self.model, [])
|
||||
self.a_list_product_removed = ap.AgentList(self.model, [])
|
||||
self.a_lst_up_product_removed = ap.AgentList(self.model, [])
|
||||
self.a_lst_product_disrupted = ap.AgentList(self.model, [])
|
||||
self.a_lst_product_removed = ap.AgentList(self.model, [])
|
||||
|
||||
self.dct_num_trial_up_product_removed = {}
|
||||
self.dct_n_trial_up_product_removed = {}
|
||||
self.dct_request_prod_from_firm = {}
|
||||
|
||||
def remove_edge_to_cus_remove_cus_up_prod(self, remove_product):
|
||||
list_out_edges = list(
|
||||
lst_out_edge = list(
|
||||
self.firm_network.graph.out_edges(
|
||||
self.firm_network.positions[self], keys=True, data='Product'))
|
||||
for n1, n2, key, product_code in list_out_edges:
|
||||
for n1, n2, key, product_code in lst_out_edge:
|
||||
if product_code == remove_product.code:
|
||||
# remove edge
|
||||
# print(n1, n2, key, product_code)
|
||||
self.firm_network.graph.remove_edge(n1, n2, key)
|
||||
|
||||
# remove customer up product conditionally
|
||||
customer = ap.AgentIter(self.model, n2).to_list()[0]
|
||||
list_in_edges = list(
|
||||
lst_in_edge = list(
|
||||
self.firm_network.graph.in_edges(n2,
|
||||
keys=True,
|
||||
data='Product'))
|
||||
select_edges = [
|
||||
edge for edge in list_in_edges
|
||||
lst_select_in_edge = [
|
||||
edge for edge in lst_in_edge
|
||||
if edge[-1] == remove_product.code
|
||||
]
|
||||
# print(select_edges)
|
||||
p_remove = math.exp(-1 * len(select_edges))
|
||||
if self.model.nprandom.choice([True, False], p=[p_remove, 1-p_remove]):
|
||||
print(self.name, remove_product.code, 'affect', customer.name)
|
||||
prod_remove = math.exp(-1 * len(lst_select_in_edge))
|
||||
if self.model.nprandom.choice([True, False],
|
||||
p=[prod_remove,
|
||||
1 - prod_remove]):
|
||||
print(self.name, remove_product.code, 'affect',
|
||||
customer.name)
|
||||
if remove_product not in \
|
||||
customer.a_list_up_product_removed:
|
||||
customer.a_list_up_product_removed.append(
|
||||
customer.a_lst_up_product_removed:
|
||||
customer.a_lst_up_product_removed.append(
|
||||
remove_product)
|
||||
customer.dct_num_trial_up_product_removed[
|
||||
customer.dct_n_trial_up_product_removed[
|
||||
remove_product] = 0
|
||||
|
||||
# # disrupt customer
|
||||
# customer = ap.AgentIter(self.model, n2).to_list()[0]
|
||||
# for product in customer.a_list_product:
|
||||
# if product in remove_product.a_successors():
|
||||
# if product not in customer.a_list_product_disrupted:
|
||||
# customer.a_list_product_disrupted.append(
|
||||
# product)
|
||||
# print(customer.a_list_product_disrupted.code)
|
||||
|
||||
def seek_alt_supply(self):
|
||||
for product in self.a_list_up_product_removed:
|
||||
for product in self.a_lst_up_product_removed:
|
||||
print(f"{self.name} seek alt supply for {product.code}")
|
||||
if self.dct_num_trial_up_product_removed[
|
||||
if self.dct_n_trial_up_product_removed[
|
||||
product] <= self.model.int_n_max_trial:
|
||||
# select a list of candidate firm that has the product
|
||||
candidate_alt_supply = self.model.a_list_total_firms.select([
|
||||
product in firm.a_list_product
|
||||
and product not in firm.a_list_product_removed
|
||||
for firm in self.model.a_list_total_firms
|
||||
candidate_alt_supply = self.model.a_lst_total_firms.select([
|
||||
product in firm.a_lst_product
|
||||
and product not in firm.a_lst_product_removed
|
||||
for firm in self.model.a_lst_total_firms
|
||||
])
|
||||
# print(candidate_alt_supply)
|
||||
# print(candidate_alt_supply.name)
|
||||
# print(candidate_alt_supply.a_list_product.code)
|
||||
if not candidate_alt_supply:
|
||||
continue
|
||||
# select based on size
|
||||
list_prob = [
|
||||
lst_prob = [
|
||||
size / sum(candidate_alt_supply.revenue_log)
|
||||
for size in candidate_alt_supply.revenue_log
|
||||
]
|
||||
select_alt_supply = self.model.nprandom.choice(
|
||||
candidate_alt_supply, p=list_prob)
|
||||
print(f"{self.name} selct alt supply for {product.code} from {select_alt_supply.name}")
|
||||
assert product in select_alt_supply.a_list_product, \
|
||||
candidate_alt_supply, p=lst_prob)
|
||||
print(
|
||||
f"{self.name} selct alt supply for {product.code} from {select_alt_supply.name}"
|
||||
)
|
||||
assert product in select_alt_supply.a_lst_product, \
|
||||
f"{select_alt_supply} \
|
||||
does not produce requested product {product}"
|
||||
|
||||
|
|
@ -104,32 +95,36 @@ class FirmAgent(ap.Agent):
|
|||
select_alt_supply.dct_request_prod_from_firm.items()
|
||||
})
|
||||
|
||||
self.dct_num_trial_up_product_removed[product] += 1
|
||||
self.dct_n_trial_up_product_removed[product] += 1
|
||||
|
||||
def handle_request(self):
|
||||
print(self.name, 'handle_request')
|
||||
for product, list_firm in self.dct_request_prod_from_firm.items():
|
||||
for product, lst_firm in self.dct_request_prod_from_firm.items():
|
||||
if self.dct_prod_capacity[product] > 0:
|
||||
if len(list_firm) == 0:
|
||||
if len(lst_firm) == 0:
|
||||
continue
|
||||
elif len(list_firm) == 1:
|
||||
self.accept_request(list_firm[0], product)
|
||||
elif len(list_firm) > 1:
|
||||
elif len(lst_firm) == 1:
|
||||
self.accept_request(lst_firm[0], product)
|
||||
elif len(lst_firm) > 1:
|
||||
# handling based on connection
|
||||
# TBC
|
||||
# handling based on size
|
||||
list_size = [firm.revenue_log for firm in list_firm]
|
||||
list_prob = [size / sum(list_size) for size in list_size]
|
||||
select_customer = self.model.nprandom.choice(list_firm,
|
||||
p=list_prob)
|
||||
lst_firm_size = [firm.revenue_log for firm in lst_firm]
|
||||
lst_prob = [
|
||||
size / sum(lst_firm_size) for size in lst_firm_size
|
||||
]
|
||||
select_customer = self.model.nprandom.choice(lst_firm,
|
||||
p=lst_prob)
|
||||
self.accept_request(select_customer, product)
|
||||
# print(product.code, [firm.name for firm in list_firm])
|
||||
|
||||
def accept_request(self, down_firm, product):
|
||||
# if self.model.nprandom.choice([True, False], p=[0.1, 0.9]):
|
||||
lst_f_s = [firm.revenue_log for firm in self.model.a_list_total_firms if product in firm.a_list_product]
|
||||
p_accept = self.revenue_log / sum(lst_f_s)
|
||||
if self.model.nprandom.choice([True, False], p=[p_accept, 1-p_accept]):
|
||||
lst_firm_size = [
|
||||
firm.revenue_log for firm in self.model.a_lst_total_firms
|
||||
if product in firm.a_lst_product
|
||||
]
|
||||
prod_accept = self.revenue_log / sum(lst_firm_size)
|
||||
if self.model.nprandom.choice([True, False],
|
||||
p=[prod_accept, 1 - prod_accept]):
|
||||
self.firm_network.graph.add_edges_from([
|
||||
(self.firm_network.positions[self],
|
||||
self.firm_network.positions[down_firm], {
|
||||
|
|
@ -138,12 +133,14 @@ class FirmAgent(ap.Agent):
|
|||
])
|
||||
self.dct_prod_capacity[product] -= 1
|
||||
self.dct_request_prod_from_firm[product].remove(down_firm)
|
||||
down_firm.a_list_up_product_removed.remove(product)
|
||||
print(f"{self.name} accept {product.code} request from {down_firm.name}")
|
||||
down_firm.a_lst_up_product_removed.remove(product)
|
||||
print(
|
||||
f"{self.name} accept {product.code} request from {down_firm.name}"
|
||||
)
|
||||
|
||||
def clean_before_trial(self):
|
||||
self.dct_request_prod_from_firm = {}
|
||||
|
||||
def clean_before_time_step(self):
|
||||
self.dct_num_trial_up_product_removed = {}
|
||||
self.a_list_up_product_removed = ap.AgentList(self.model, [])
|
||||
self.dct_n_trial_up_product_removed = {}
|
||||
self.a_lst_up_product_removed = ap.AgentList(self.model, [])
|
||||
|
|
|
|||
309
model.py
309
model.py
|
|
@ -5,33 +5,9 @@ import random
|
|||
import networkx as nx
|
||||
from firm import FirmAgent
|
||||
from product import ProductAgent
|
||||
from orm import db_session, Sample, Result
|
||||
from orm import db_session, Result
|
||||
import platform
|
||||
|
||||
sample = 0
|
||||
seed = 0
|
||||
n_iter = 10
|
||||
# dct_list_init_remove_firm_prod = {133: ['1.4.4.1'], 2: ['1.1.3']}
|
||||
# dct_list_init_remove_firm_prod = {
|
||||
# 135: ['1.3.2.1'],
|
||||
# 133: ['1.4.4.1'],
|
||||
# 2: ['1.1.3']
|
||||
# }
|
||||
dct_list_init_remove_firm_prod = {
|
||||
'140': ['1.4.5.1'],
|
||||
'135': ['1.3.2.1'],
|
||||
'133': ['1.4.4.1'],
|
||||
'2': ['1.1.3']
|
||||
}
|
||||
n_max_trial = 5
|
||||
dct_sample_para = {
|
||||
'sample': sample,
|
||||
'seed': seed,
|
||||
'n_iter': n_iter,
|
||||
'n_max_trial': n_max_trial,
|
||||
'dct_list_init_remove_firm_prod': dct_list_init_remove_firm_prod,
|
||||
}
|
||||
|
||||
|
||||
class Model(ap.Model):
|
||||
def setup(self):
|
||||
|
|
@ -41,7 +17,7 @@ class Model(ap.Model):
|
|||
self.nprandom = np.random.default_rng(self.p.seed)
|
||||
self.int_n_iter = int(self.p.n_iter)
|
||||
self.int_n_max_trial = int(self.p.n_max_trial)
|
||||
self.dct_list_remove_firm_prod = self.p.dct_list_init_remove_firm_prod
|
||||
self.dct_lst_remove_firm_prod = self.p.dct_lst_init_remove_firm_prod
|
||||
|
||||
# init graph bom
|
||||
BomNodes = pd.read_csv('BomNodes.csv', index_col=0)
|
||||
|
|
@ -77,68 +53,51 @@ class Model(ap.Model):
|
|||
|
||||
# add edge to G_firm according to G_bom
|
||||
for node in nx.nodes(G_Firm):
|
||||
# print(node, '-' * 20)
|
||||
for product_code in G_Firm.nodes[node]['Product_Code']:
|
||||
# print(product_code)
|
||||
for succ_product_code in list(G_bom.successors(product_code)):
|
||||
# print(succ_product_code)
|
||||
list_succ_firms = Firm['Code'][Firm[succ_product_code] ==
|
||||
# for each product of a certain firm
|
||||
# get each successor (finished product) of this product
|
||||
# get a list of firm producing this successor
|
||||
lst_succ_firm = Firm['Code'][Firm[succ_product_code] ==
|
||||
1].to_list()
|
||||
list_revenue_log = [
|
||||
lst_succ_firm_size = [
|
||||
G_Firm.nodes[succ_firm]['Revenue_Log']
|
||||
for succ_firm in list_succ_firms
|
||||
for succ_firm in lst_succ_firm
|
||||
]
|
||||
# list_prob = [
|
||||
# (v - min(list_revenue_log) + 1) /
|
||||
# (max(list_revenue_log) - min(list_revenue_log) + 1)
|
||||
# for v in list_revenue_log
|
||||
# ]
|
||||
# list_flag = [
|
||||
# self.nprandom.choice([1, 0], p=[prob, 1 - prob])
|
||||
# for prob in list_prob
|
||||
# ]
|
||||
# # print(list(zip(list_succ_firms,list_flag,list_prob)))
|
||||
# list_added_edges = [(node, succ_firm, {
|
||||
# 'Product': product_code
|
||||
# }) for succ_firm, flag in zip(list_succ_firms, list_flag)
|
||||
# if flag == 1]
|
||||
list_prob = [
|
||||
size / sum(list_revenue_log)
|
||||
for size in list_revenue_log
|
||||
lst_prob = [
|
||||
size / sum(lst_succ_firm_size)
|
||||
for size in lst_succ_firm_size
|
||||
]
|
||||
list_f_same_p = Firm['Code'][Firm[product_code] ==
|
||||
# select multiple successors based on relative size of this firm
|
||||
lst_same_prod_firm = Firm['Code'][Firm[product_code] ==
|
||||
1].to_list()
|
||||
list_f_size_same_p = [
|
||||
lst_same_prod_firm_size = [
|
||||
G_Firm.nodes[f]['Revenue_Log']
|
||||
for f in list_f_same_p
|
||||
for f in lst_same_prod_firm
|
||||
]
|
||||
share = G_Firm.nodes[node]['Revenue_Log'] / sum(list_f_size_same_p)
|
||||
num_succ_f = round(share * len(list_succ_firms)) if round(share * len(list_succ_firms)) > 0 else 1
|
||||
list_choose_firm = self.nprandom.choice(list_succ_firms, num_succ_f,
|
||||
p=list_prob)
|
||||
list_choose_firm = list(set(list_choose_firm))
|
||||
list_added_edges = [(node, succ_firm, {
|
||||
share = G_Firm.nodes[node]['Revenue_Log'] / sum(
|
||||
lst_same_prod_firm_size)
|
||||
n_succ_firm = round(share * len(lst_succ_firm)) if round(
|
||||
share * len(lst_succ_firm)) > 0 else 1 # at least one
|
||||
lst_choose_firm = self.nprandom.choice(lst_succ_firm,
|
||||
n_succ_firm,
|
||||
p=lst_prob)
|
||||
lst_choose_firm = list(
|
||||
set(lst_choose_firm
|
||||
)) # nprandom.choice may have duplicates
|
||||
lst_add_edge = [(node, succ_firm, {
|
||||
'Product': product_code
|
||||
}) for succ_firm in list_choose_firm]
|
||||
G_Firm.add_edges_from(list_added_edges)
|
||||
# print('-' * 20)
|
||||
}) for succ_firm in lst_choose_firm]
|
||||
G_Firm.add_edges_from(lst_add_edge)
|
||||
|
||||
self.firm_network = ap.Network(self, G_Firm)
|
||||
self.product_network = ap.Network(self, G_bom)
|
||||
# print([node.label for node in self.firm_network.nodes])
|
||||
# print([list(self.firm_network.graph.predecessors(node))
|
||||
# for node in self.firm_network.nodes])
|
||||
# print([self.firm_network.graph.nodes[node.label]['Name']
|
||||
# for node in self.firm_network.nodes])
|
||||
# print([v for v in self.firm_network.graph.nodes(data=True)])
|
||||
|
||||
# init product
|
||||
for ag_node, attr in self.product_network.graph.nodes(data=True):
|
||||
product_agent = ProductAgent(self,
|
||||
code=ag_node.label,
|
||||
name=attr['Name'])
|
||||
self.product_network.add_agents([product_agent], [ag_node])
|
||||
self.a_list_total_products = ap.AgentList(self,
|
||||
product = ProductAgent(self, code=ag_node.label, name=attr['Name'])
|
||||
self.product_network.add_agents([product], [ag_node])
|
||||
self.a_lst_total_products = ap.AgentList(self,
|
||||
self.product_network.agents)
|
||||
|
||||
# init firm
|
||||
|
|
@ -149,201 +108,164 @@ class Model(ap.Model):
|
|||
name=attr['Name'],
|
||||
type_region=attr['Type_Region'],
|
||||
revenue_log=attr['Revenue_Log'],
|
||||
a_list_product=self.a_list_total_products.select([
|
||||
a_lst_product=self.a_lst_total_products.select([
|
||||
code in attr['Product_Code']
|
||||
for code in self.a_list_total_products.code
|
||||
for code in self.a_lst_total_products.code
|
||||
]))
|
||||
# init capacity based on discrete uniform distribution
|
||||
# list_out_edges = list(
|
||||
# self.firm_network.graph.out_edges(ag_node,
|
||||
# keys=True,
|
||||
# data='Product'))
|
||||
# for product in firm_agent.a_list_product:
|
||||
# capacity = len([
|
||||
# edge for edge in list_out_edges if edge[-1] ==
|
||||
# product.code])
|
||||
# firm_agent.dct_prod_capacity[product] = capacity
|
||||
for product in firm_agent.a_list_product:
|
||||
# init extra capacity based on discrete uniform distribution
|
||||
for product in firm_agent.a_lst_product:
|
||||
firm_agent.dct_prod_capacity[product] = self.nprandom.integers(
|
||||
firm_agent.revenue_log / 5, firm_agent.revenue_log / 5 + 2)
|
||||
# print(firm_agent.name, firm_agent.dct_prod_capacity)
|
||||
|
||||
self.firm_network.add_agents([firm_agent], [ag_node])
|
||||
self.a_list_total_firms = ap.AgentList(self, self.firm_network.agents)
|
||||
# print(list(zip(self.a_list_total_firms.code,
|
||||
# self.a_list_total_firms.name,
|
||||
# self.a_list_total_firms.capacity)))
|
||||
self.a_lst_total_firms = ap.AgentList(self, self.firm_network.agents)
|
||||
|
||||
# init dct_list_remove_firm_prod (from string to agent)
|
||||
t_dct = {}
|
||||
for firm_code, list_product in self.dct_list_remove_firm_prod.items():
|
||||
firm = self.a_list_total_firms.select(
|
||||
self.a_list_total_firms.code == firm_code)[0]
|
||||
t_dct[firm] = self.a_list_total_products.select([
|
||||
code in list_product
|
||||
for code in self.a_list_total_products.code
|
||||
for firm_code, lst_product in self.dct_lst_remove_firm_prod.items():
|
||||
firm = self.a_lst_total_firms.select(
|
||||
self.a_lst_total_firms.code == firm_code)[0]
|
||||
t_dct[firm] = self.a_lst_total_products.select([
|
||||
code in lst_product for code in self.a_lst_total_products.code
|
||||
])
|
||||
self.dct_list_remove_firm_prod = t_dct
|
||||
self.dct_list_disrupt_firm_prod = t_dct
|
||||
self.dct_lst_remove_firm_prod = t_dct
|
||||
self.dct_lst_disrupt_firm_prod = t_dct
|
||||
|
||||
# init output
|
||||
self.list_dct_list_remove_firm_prod = []
|
||||
self.list_dct_list_disrupt_firm_prod = []
|
||||
self.lst_dct_lst_remove_firm_prod = []
|
||||
self.lst_dct_lst_disrupt_firm_prod = []
|
||||
|
||||
# set the initial firm product that are removed
|
||||
for firm, a_list_product in self.dct_list_remove_firm_prod.items():
|
||||
for product in a_list_product:
|
||||
assert product in firm.a_list_product, \
|
||||
for firm, a_lst_product in self.dct_lst_remove_firm_prod.items():
|
||||
for product in a_lst_product:
|
||||
assert product in firm.a_lst_product, \
|
||||
f"product {product.code} not in firm {firm.code}"
|
||||
firm.a_list_product_removed.append(product)
|
||||
firm.a_lst_product_removed.append(product)
|
||||
|
||||
# draw network
|
||||
# self.draw_network()
|
||||
|
||||
def update(self):
|
||||
self.a_list_total_firms.clean_before_time_step()
|
||||
self.a_lst_total_firms.clean_before_time_step()
|
||||
# output
|
||||
self.list_dct_list_remove_firm_prod.append(
|
||||
(self.t, self.dct_list_remove_firm_prod))
|
||||
self.list_dct_list_disrupt_firm_prod.append(
|
||||
(self.t, self.dct_list_disrupt_firm_prod))
|
||||
self.lst_dct_lst_remove_firm_prod.append(
|
||||
(self.t, self.dct_lst_remove_firm_prod))
|
||||
self.lst_dct_lst_disrupt_firm_prod.append(
|
||||
(self.t, self.dct_lst_disrupt_firm_prod))
|
||||
|
||||
# stop simulation if reached terminal number of iteration
|
||||
if self.t == self.int_n_iter or len(
|
||||
self.dct_list_remove_firm_prod) == 0:
|
||||
self.dct_lst_remove_firm_prod) == 0:
|
||||
self.int_stop_times = self.t
|
||||
print(self.int_stop_times, self.t)
|
||||
self.stop()
|
||||
|
||||
def step(self):
|
||||
# shuffle self.dct_list_remove_firm_prod
|
||||
# dct_key_list = list(self.dct_list_remove_firm_prod.keys())
|
||||
# self.nprandom.shuffle(dct_key_list)
|
||||
# self.dct_list_remove_firm_prod = {
|
||||
# key: self.dct_list_remove_firm_prod[key].shuffle()
|
||||
# for key in dct_key_list
|
||||
# }
|
||||
# print(self.dct_list_remove_firm_prod)
|
||||
|
||||
print('\n', '=' * 20, 'step', self.t, '=' * 20)
|
||||
print(
|
||||
'dct_list_remove_firm_prod', {
|
||||
key.name: value.code
|
||||
for key, value in self.dct_list_remove_firm_prod.items()
|
||||
for key, value in self.dct_lst_remove_firm_prod.items()
|
||||
})
|
||||
|
||||
# remove_edge_to_cus_and_cus_up_prod
|
||||
for firm, a_list_product in self.dct_list_remove_firm_prod.items():
|
||||
for product in a_list_product:
|
||||
for firm, a_lst_product in self.dct_lst_remove_firm_prod.items():
|
||||
for product in a_lst_product:
|
||||
firm.remove_edge_to_cus_remove_cus_up_prod(product)
|
||||
|
||||
for n_trial in range(self.int_n_max_trial):
|
||||
print('=' * 10, 'trial', n_trial, '=' * 10)
|
||||
# seek_alt_supply
|
||||
# shuffle self.a_list_total_firms
|
||||
self.a_list_total_firms = self.a_list_total_firms.shuffle()
|
||||
for firm in self.a_list_total_firms:
|
||||
if len(firm.a_list_up_product_removed) > 0:
|
||||
# print(firm.name)
|
||||
# print(firm.a_list_up_product_removed.code)
|
||||
# shuffle self.a_lst_total_firms
|
||||
self.a_lst_total_firms = self.a_lst_total_firms.shuffle()
|
||||
for firm in self.a_lst_total_firms:
|
||||
if len(firm.a_lst_up_product_removed) > 0:
|
||||
firm.seek_alt_supply()
|
||||
|
||||
# handle_request
|
||||
# shuffle self.a_list_total_firms
|
||||
self.a_list_total_firms = self.a_list_total_firms.shuffle()
|
||||
for firm in self.a_list_total_firms:
|
||||
# shuffle self.a_lst_total_firms
|
||||
self.a_lst_total_firms = self.a_lst_total_firms.shuffle()
|
||||
for firm in self.a_lst_total_firms:
|
||||
if len(firm.dct_request_prod_from_firm) > 0:
|
||||
firm.handle_request()
|
||||
|
||||
# reset dct_request_prod_from_firm
|
||||
self.a_list_total_firms.clean_before_trial()
|
||||
self.a_lst_total_firms.clean_before_trial()
|
||||
# do not use:
|
||||
# self.a_list_total_firms.dct_request_prod_from_firm = {} why?
|
||||
# self.a_lst_total_firms.dct_request_prod_from_firm = {} why?
|
||||
|
||||
# based on a_list_up_product_removed,
|
||||
# update a_list_product_disrupted / a_list_product_removed
|
||||
# update dct_list_disrupt_firm_prod / dct_list_remove_firm_prod
|
||||
self.dct_list_remove_firm_prod = {}
|
||||
self.dct_list_disrupt_firm_prod = {}
|
||||
for firm in self.a_list_total_firms:
|
||||
if len(firm.a_list_up_product_removed) > 0:
|
||||
print(firm.name, 'a_list_up_product_removed', [
|
||||
product.code for product in firm.a_list_up_product_removed
|
||||
# based on a_lst_up_product_removed
|
||||
# update a_lst_product_disrupted / a_lst_product_removed
|
||||
# update dct_lst_disrupt_firm_prod / dct_lst_remove_firm_prod
|
||||
self.dct_lst_remove_firm_prod = {}
|
||||
self.dct_lst_disrupt_firm_prod = {}
|
||||
for firm in self.a_lst_total_firms:
|
||||
if len(firm.a_lst_up_product_removed) > 0:
|
||||
print(firm.name, 'a_lst_up_product_removed', [
|
||||
product.code for product in firm.a_lst_up_product_removed
|
||||
])
|
||||
for product in firm.a_list_product:
|
||||
for product in firm.a_lst_product:
|
||||
n_up_product_removed = 0
|
||||
for up_product_removed in firm.a_list_up_product_removed:
|
||||
for up_product_removed in firm.a_lst_up_product_removed:
|
||||
if product in up_product_removed.a_successors():
|
||||
n_up_product_removed += 1
|
||||
if n_up_product_removed == 0:
|
||||
continue
|
||||
else:
|
||||
# update a_list_product_disrupted / dct_list_disrupt_firm_prod
|
||||
if product not in firm.a_list_product_disrupted:
|
||||
firm.a_list_product_disrupted.append(product)
|
||||
if firm in self.dct_list_disrupt_firm_prod.keys():
|
||||
self.dct_list_disrupt_firm_prod[firm].append(
|
||||
# update a_lst_product_disrupted / dct_lst_disrupt_firm_prod
|
||||
if product not in firm.a_lst_product_disrupted:
|
||||
firm.a_lst_product_disrupted.append(product)
|
||||
if firm in self.dct_lst_disrupt_firm_prod.keys():
|
||||
self.dct_lst_disrupt_firm_prod[firm].append(
|
||||
product)
|
||||
else:
|
||||
self.dct_list_disrupt_firm_prod[
|
||||
self.dct_lst_disrupt_firm_prod[
|
||||
firm] = ap.AgentList(
|
||||
self.model, [product])
|
||||
# update a_list_product_removed / dct_list_remove_firm_prod
|
||||
# update a_lst_product_removed / dct_list_remove_firm_prod
|
||||
# mark disrupted firm as removed based conditionally
|
||||
lost_percent = n_up_product_removed / len(
|
||||
product.a_predecessors())
|
||||
list_revenue_log = self.a_list_total_firms.revenue_log
|
||||
std_size = (firm.revenue_log - min(list_revenue_log) +
|
||||
1) / (max(list_revenue_log) -
|
||||
min(list_revenue_log) + 1)
|
||||
p_remove = 1 - std_size * (1 - lost_percent)
|
||||
flag = self.nprandom.choice([1, 0],
|
||||
p=[p_remove, 1 - p_remove])
|
||||
# flag = 1
|
||||
if flag == 1:
|
||||
firm.a_list_product_removed.append(product)
|
||||
# if firm in
|
||||
# self.dct_list_remove_firm_prod[firm] = firm.a_list_product_removed
|
||||
if firm in self.dct_list_remove_firm_prod.keys():
|
||||
self.dct_list_remove_firm_prod[firm].append(
|
||||
lst_size = self.a_lst_total_firms.revenue_log
|
||||
std_size = (firm.revenue_log - min(lst_size) +
|
||||
1) / (max(lst_size) - min(lst_size) + 1)
|
||||
prod_remove = 1 - std_size * (1 - lost_percent)
|
||||
if self.nprandom.choice(
|
||||
[True, False], p=[prod_remove, 1 - prod_remove]):
|
||||
firm.a_lst_product_removed.append(product)
|
||||
if firm in self.dct_lst_remove_firm_prod.keys():
|
||||
self.dct_lst_remove_firm_prod[firm].append(
|
||||
product)
|
||||
else:
|
||||
self.dct_list_remove_firm_prod[
|
||||
self.dct_lst_remove_firm_prod[
|
||||
firm] = ap.AgentList(
|
||||
self.model, [product])
|
||||
|
||||
# # update the firm that is removed
|
||||
# self.dct_list_remove_firm_prod = {}
|
||||
# for firm in self.a_list_total_firms:
|
||||
# if len(firm.a_list_product_removed) > 0:
|
||||
# self.dct_list_remove_firm_prod[
|
||||
# firm] = firm.a_list_product_removed
|
||||
# print(self.dct_list_remove_firm_prod)
|
||||
print(
|
||||
'dct_list_remove_firm_prod', {
|
||||
key.name: value.code
|
||||
for key, value in self.dct_list_remove_firm_prod.items()
|
||||
for key, value in self.dct_lst_remove_firm_prod.items()
|
||||
})
|
||||
|
||||
def end(self):
|
||||
print('/' * 20, 'output', '/' * 20)
|
||||
print('dct_list_remove_firm_prod')
|
||||
for t, dct in self.list_dct_list_remove_firm_prod:
|
||||
for firm, a_list_product in dct.items():
|
||||
for product in a_list_product:
|
||||
for t, dct in self.lst_dct_lst_remove_firm_prod:
|
||||
for firm, a_lst_product in dct.items():
|
||||
for product in a_lst_product:
|
||||
print(t, firm.name, product.code)
|
||||
print('dct_list_disrupt_firm_prod')
|
||||
for t, dct in self.list_dct_list_disrupt_firm_prod:
|
||||
for firm, a_list_product in dct.items():
|
||||
for product in a_list_product:
|
||||
print('dct_lst_disrupt_firm_prod')
|
||||
for t, dct in self.lst_dct_lst_disrupt_firm_prod:
|
||||
for firm, a_lst_product in dct.items():
|
||||
for product in a_lst_product:
|
||||
print(t, firm.name, product.code)
|
||||
|
||||
qry_result = db_session.query(Result).filter_by(s_id=self.sample.id)
|
||||
if qry_result.count() == 0:
|
||||
lst_result_info = []
|
||||
for t, dct in self.list_dct_list_disrupt_firm_prod:
|
||||
for firm, a_list_product in dct.items():
|
||||
for product in a_list_product:
|
||||
# print(t, firm.name, product.code)
|
||||
for t, dct in self.lst_dct_lst_disrupt_firm_prod:
|
||||
for firm, a_lst_product in dct.items():
|
||||
for product in a_lst_product:
|
||||
db_r = Result(s_id=self.sample.id,
|
||||
id_firm=firm.code,
|
||||
id_product=product.code,
|
||||
|
|
@ -352,11 +274,10 @@ class Model(ap.Model):
|
|||
lst_result_info.append(db_r)
|
||||
db_session.bulk_save_objects(lst_result_info)
|
||||
db_session.commit()
|
||||
for t, dct in self.list_dct_list_remove_firm_prod:
|
||||
for firm, a_list_product in dct.items():
|
||||
for product in a_list_product:
|
||||
# print(t, firm.name, product.code)
|
||||
# only firm disrupted can be removed
|
||||
for t, dct in self.lst_dct_lst_remove_firm_prod:
|
||||
for firm, a_lst_product in dct.items():
|
||||
for product in a_lst_product:
|
||||
# only firm disrupted can be removed theoretically
|
||||
qry_f_p = db_session.query(Result).filter(
|
||||
Result.s_id == self.sample.id,
|
||||
Result.id_firm == firm.code,
|
||||
|
|
@ -364,8 +285,8 @@ class Model(ap.Model):
|
|||
if qry_f_p.count() == 1:
|
||||
qry_f_p.update({"is_removed": True})
|
||||
db_session.commit()
|
||||
self.sample.is_done_flag, self.sample.computer_name = 1, platform.node(
|
||||
)
|
||||
self.sample.is_done_flag = 1
|
||||
self.sample.computer_name = platform.node()
|
||||
self.sample.stop_t = self.int_stop_times
|
||||
db_session.commit()
|
||||
|
||||
|
|
@ -401,7 +322,3 @@ class Model(ap.Model):
|
|||
edge_label,
|
||||
font_size=4)
|
||||
plt.savefig("network.png")
|
||||
|
||||
|
||||
# model = Model(dct_sample_para)
|
||||
# model.run()
|
||||
|
|
|
|||
2
orm.py
2
orm.py
|
|
@ -45,7 +45,7 @@ class Experiment(Base):
|
|||
|
||||
# variables
|
||||
n_max_trial = Column(Integer, nullable=False)
|
||||
dct_list_init_remove_firm_prod = Column(PickleType, nullable=False)
|
||||
dct_lst_init_remove_firm_prod = Column(PickleType, nullable=False)
|
||||
|
||||
sample = relationship('Sample', back_populates='experiment', lazy='dynamic')
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue