diff --git a/models/BaseBehaviour/BaseBehaviour.py b/models/BaseBehaviour/BaseBehaviour.py new file mode 100644 index 0000000..b0d7327 --- /dev/null +++ b/models/BaseBehaviour/BaseBehaviour.py @@ -0,0 +1,40 @@ +import settings +from nxsim import BaseNetworkAgent +from .. import networkStatus + +settings.init() + + +class BaseBehaviour(BaseNetworkAgent): + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + self._attrs = {} + + @property + def attrs(self): + now = self.env.now + if now not in self._attrs: + self._attrs[now] = {} + return self._attrs[now] + + @attrs.setter + def attrs(self, value): + self._attrs[self.env.now] = value + + def run(self): + while True: + self.step(self.env.now) + yield self.env.timeout(settings.timeout) + + def step(self, now): + networkStatus['agent_%s'% self.id] = self.to_json() + + def to_json(self): + final = {} + for stamp, attrs in self._attrs.items(): + for a in attrs: + if a not in final: + final[a] = {} + final[a][stamp] = attrs[a] + return final \ No newline at end of file diff --git a/models/BaseBehaviour/__init__.py b/models/BaseBehaviour/__init__.py new file mode 100644 index 0000000..7494c75 --- /dev/null +++ b/models/BaseBehaviour/__init__.py @@ -0,0 +1 @@ +from .BaseBehaviour import BaseBehaviour diff --git a/models/BassModel/BassModel.py b/models/BassModel/BassModel.py new file mode 100644 index 0000000..d252613 --- /dev/null +++ b/models/BassModel/BassModel.py @@ -0,0 +1,49 @@ +import settings +import random +from ..BaseBehaviour import * +from .. import sentimentCorrelationNodeArray + +settings.init() + + +class BassModel(BaseBehaviour): + """ + Settings: + innovation_prob + + imitation_prob + """ + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + self.innovation_prob = settings.innovation_prob + self.imitation_prob = settings.imitation_prob + sentimentCorrelationNodeArray[self.id][self.env.now]=0 + + def step(self, now): + self.behaviour() + super().step(now) + + def behaviour(self): + # Outside effects + if random.random() < settings.innovation_prob: + if self.state['id'] == 0: + self.state['id'] = 1 + sentimentCorrelationNodeArray[self.id][self.env.now]=1 + else: + pass + + self.attrs['status'] = self.state['id'] + return + + # Imitation effects + if self.state['id'] == 0: + aware_neighbors = self.get_neighboring_agents(state_id=1) + num_neighbors_aware = len(aware_neighbors) + if random.random() < (settings.imitation_prob*num_neighbors_aware): + self.state['id'] = 1 + sentimentCorrelationNodeArray[self.id][self.env.now]=1 + + else: + pass + self.attrs['status'] = self.state['id'] diff --git a/models/BassModel/__init__.py b/models/BassModel/__init__.py new file mode 100644 index 0000000..b7babd9 --- /dev/null +++ b/models/BassModel/__init__.py @@ -0,0 +1 @@ +from .BassModel import BassModel diff --git a/models/BigMarketModel/BigMarketModel.py b/models/BigMarketModel/BigMarketModel.py new file mode 100644 index 0000000..7d32db1 --- /dev/null +++ b/models/BigMarketModel/BigMarketModel.py @@ -0,0 +1,108 @@ +import settings +import random +from ..BaseBehaviour import * + +settings.init() + + +class BigMarketModel(BaseBehaviour): + """ + Settings: + Names: + enterprises [Array] + + tweet_probability_enterprises [Array] + Users: + tweet_probability_users + + tweet_relevant_probability + + tweet_probability_about [Array] + + sentiment_about [Array] + """ + + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + self.enterprises = settings.enterprises + self.type = "" + self.number_of_enterprises = len(settings.enterprises) + + if self.id < self.number_of_enterprises: # Enterprises + self.state['id']=self.id + self.type="Enterprise" + self.tweet_probability = settings.tweet_probability_enterprises[self.id] + else: # normal users + self.state['id']=self.number_of_enterprises + self.type="User" + self.tweet_probability = settings.tweet_probability_users + self.tweet_relevant_probability = settings.tweet_relevant_probability + self.tweet_probability_about = settings.tweet_probability_about # List + self.sentiment_about = settings.sentiment_about # List + + def step(self, now): + + if(self.id < self.number_of_enterprises): # Enterprise + self.enterpriseBehaviour() + else: # Usuario + self.userBehaviour() + for i in range(self.number_of_enterprises): # So that it never is set to 0 if there are not changes (logs) + self.attrs['sentiment_enterprise_%s'% self.enterprises[i]] = self.sentiment_about[i] + + super().step(now) + + def enterpriseBehaviour(self): + + if random.random()< self.tweet_probability: # Tweets + aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises) #Nodes neighbour users + for x in aware_neighbors: + if random.uniform(0,10) < 5: + x.sentiment_about[self.id] += 0.1 # Increments for enterprise + else: + x.sentiment_about[self.id] -= 0.1 # Decrements for enterprise + + # Establecemos limites + if x.sentiment_about[self.id] > 1: + x.sentiment_about[self.id] = 1 + if x.sentiment_about[self.id]< -1: + x.sentiment_about[self.id] = -1 + + x.attrs['sentiment_enterprise_%s'% self.enterprises[self.id]] = x.sentiment_about[self.id] + + def userBehaviour(self): + + if random.random() < self.tweet_probability: # Tweets + if random.random() < self.tweet_relevant_probability: # Tweets something relevant + # Tweet probability per enterprise + for i in range(self.number_of_enterprises): + random_num = random.random() + if random_num < self.tweet_probability_about[i]: + # The condition is fulfilled, sentiments are evaluated towards that enterprise + if self.sentiment_about[i] < 0: + # NEGATIVO + self.userTweets("negative",i) + elif self.sentiment_about[i] == 0: + # NEUTRO + pass + else: + # POSITIVO + self.userTweets("positive",i) + + def userTweets(self,sentiment,enterprise): + aware_neighbors = self.get_neighboring_agents(state_id=self.number_of_enterprises) #Nodes neighbours users + for x in aware_neighbors: + if sentiment == "positive": + x.sentiment_about[enterprise] +=0.003 + elif sentiment == "negative": + x.sentiment_about[enterprise] -=0.003 + else: + pass + + # Establecemos limites + if x.sentiment_about[enterprise] > 1: + x.sentiment_about[enterprise] = 1 + if x.sentiment_about[enterprise] < -1: + x.sentiment_about[enterprise] = -1 + + x.attrs['sentiment_enterprise_%s'% self.enterprises[enterprise]] = x.sentiment_about[enterprise] diff --git a/models/BigMarketModel/SISaModel.py b/models/BigMarketModel/SISaModel.py new file mode 100644 index 0000000..5aeee8c --- /dev/null +++ b/models/BigMarketModel/SISaModel.py @@ -0,0 +1,96 @@ +import settings +import random +import numpy as np +from ..BaseBehaviour import * + +settings.init() + + +class SISaModel(BaseBehaviour): + """ + Settings: + neutral_discontent_spon_prob + + neutral_discontent_infected_prob + + neutral_content_spong_prob + + neutral_content_infected_prob + + discontent_neutral + + discontent_content + + variance_d_c + + content_discontent + + variance_c_d + + content_neutral + + standard_variance + """ + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + + self.neutral_discontent_spon_prob = np.random.normal(settings.neutral_discontent_spon_prob, + settings.standard_variance) + self.neutral_discontent_infected_prob = np.random.normal(settings.neutral_discontent_infected_prob, + settings.standard_variance) + self.neutral_content_spon_prob = np.random.normal(settings.neutral_content_spon_prob, settings.standard_variance) + self.neutral_content_infected_prob = np.random.normal(settings.neutral_content_infected_prob, + settings.standard_variance) + + self.discontent_neutral = np.random.normal(settings.discontent_neutral, settings.standard_variance) + self.discontent_content = np.random.normal(settings.discontent_content, settings.variance_d_c) + + self.content_discontent = np.random.normal(settings.content_discontent, settings.variance_c_d) + self.content_neutral = np.random.normal(settings.content_neutral, settings.standard_variance) + + def step(self, now): + if self.state['id'] == 0: + self.neutral_behaviour() + if self.state['id'] == 1: + self.discontent_behaviour() + if self.state['id'] == 2: + self.content_behaviour() + + self.attrs['status'] = self.state['id'] + super().step(now) + + def neutral_behaviour(self): + # Spontaneous effects + if random.random() < self.neutral_discontent_spon_prob: + self.state['id'] = 1 + if random.random() < self.neutral_content_spon_prob: + self.state['id'] = 2 + + # Infected + discontent_neighbors = self.get_neighboring_agents(state_id=1) + if random.random() < len(discontent_neighbors) * self.neutral_discontent_infected_prob: + self.state['id'] = 1 + content_neighbors = self.get_neighboring_agents(state_id=2) + if random.random() < len(content_neighbors) * self.neutral_content_infected_prob: + self.state['id'] = 2 + + def discontent_behaviour(self): + # Healing + if random.random() < self.discontent_neutral: + self.state['id'] = 0 + + # Superinfected + content_neighbors = self.get_neighboring_agents(state_id=2) + if random.random() < len(content_neighbors) * self.discontent_content: + self.state['id'] = 2 + + def content_behaviour(self): + # Healing + if random.random() < self.content_neutral: + self.state['id'] = 0 + + # Superinfected + discontent_neighbors = self.get_neighboring_agents(state_id=1) + if random.random() < len(discontent_neighbors) * self.content_discontent: + self.state['id'] = 1 diff --git a/models/BigMarketModel/__init__.py b/models/BigMarketModel/__init__.py new file mode 100644 index 0000000..82169f5 --- /dev/null +++ b/models/BigMarketModel/__init__.py @@ -0,0 +1,2 @@ +from .BigMarketModel import BigMarketModel +from .SISaModel import SISaModel diff --git a/models/IndependentCascadeModel/IndependentCascadeModel.py b/models/IndependentCascadeModel/IndependentCascadeModel.py new file mode 100644 index 0000000..8a70c4c --- /dev/null +++ b/models/IndependentCascadeModel/IndependentCascadeModel.py @@ -0,0 +1,56 @@ +import settings +import random +from ..BaseBehaviour import * +from .. import sentimentCorrelationNodeArray + +settings.init() + + +class IndependentCascadeModel(BaseBehaviour): + """ + Settings: + innovation_prob + + imitation_prob + """ + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + self.innovation_prob = settings.innovation_prob + self.imitation_prob = settings.imitation_prob + self.time_awareness = 0 + sentimentCorrelationNodeArray[self.id][self.env.now]=0 + + def step(self,now): + self.behaviour() + super().step(now) + + def behaviour(self): + aware_neighbors_1_time_step=[] + # Outside effects + if random.random() < settings.innovation_prob: + if self.state['id'] == 0: + self.state['id'] = 1 + sentimentCorrelationNodeArray[self.id][self.env.now]=1 + self.time_awareness = self.env.now #To know when they have been infected + else: + pass + + self.attrs['status'] = self.state['id'] + return + + # Imitation effects + if self.state['id'] == 0: + aware_neighbors = self.get_neighboring_agents(state_id=1) + for x in aware_neighbors: + if x.time_awareness == (self.env.now-1): + aware_neighbors_1_time_step.append(x) + num_neighbors_aware = len(aware_neighbors_1_time_step) + if random.random() < (settings.imitation_prob*num_neighbors_aware): + self.state['id'] = 1 + sentimentCorrelationNodeArray[self.id][self.env.now]=1 + else: + pass + + self.attrs['status'] = self.state['id'] + return diff --git a/models/IndependentCascadeModel/__init__.py b/models/IndependentCascadeModel/__init__.py new file mode 100644 index 0000000..3966e7a --- /dev/null +++ b/models/IndependentCascadeModel/__init__.py @@ -0,0 +1 @@ +from .IndependentCascadeModel import IndependentCascadeModel diff --git a/models/ModelM2/ControlModelM2.py b/models/ModelM2/ControlModelM2.py new file mode 100644 index 0000000..54170a5 --- /dev/null +++ b/models/ModelM2/ControlModelM2.py @@ -0,0 +1,143 @@ +import settings +import random +import numpy as np +from ..BaseBehaviour import * +from .. import init_states + +settings.init() + + +class ControlModelM2(BaseBehaviour): + """ + Settings: + prob_neutral_making_denier + + prob_infect + + prob_cured_healing_infected + + prob_cured_vaccinate_neutral + + prob_vaccinated_healing_infected + + prob_vaccinated_vaccinate_neutral + + prob_generate_anti_rumor + """ + + # Init infected + init_states[random.randint(0, settings.number_of_nodes-1)] = {'id':1} + init_states[random.randint(0, settings.number_of_nodes-1)] = {'id':1} + + # Init beacons + init_states[random.randint(0, settings.number_of_nodes-1)] = {'id': 4} + init_states[random.randint(0, settings.number_of_nodes-1)] = {'id': 4} + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + + self.prob_neutral_making_denier = np.random.normal(settings.prob_neutral_making_denier, settings.standard_variance) + + self.prob_infect = np.random.normal(settings.prob_infect, settings.standard_variance) + + self.prob_cured_healing_infected = np.random.normal(settings.prob_cured_healing_infected, settings.standard_variance) + self.prob_cured_vaccinate_neutral = np.random.normal(settings.prob_cured_vaccinate_neutral, settings.standard_variance) + + self.prob_vaccinated_healing_infected = np.random.normal(settings.prob_vaccinated_healing_infected, settings.standard_variance) + self.prob_vaccinated_vaccinate_neutral = np.random.normal(settings.prob_vaccinated_vaccinate_neutral, settings.standard_variance) + self.prob_generate_anti_rumor = np.random.normal(settings.prob_generate_anti_rumor, settings.standard_variance) + + def step(self, now): + + if self.state['id'] == 0: # Neutral + self.neutral_behaviour() + elif self.state['id'] == 1: # Infected + self.infected_behaviour() + elif self.state['id'] == 2: # Cured + self.cured_behaviour() + elif self.state['id'] == 3: # Vaccinated + self.vaccinated_behaviour() + elif self.state['id'] == 4: # Beacon-off + self.beacon_off_behaviour() + elif self.state['id'] == 5: # Beacon-on + self.beacon_on_behaviour() + + self.attrs['status'] = self.state['id'] + super().step(now) + + def neutral_behaviour(self): + + # Infected + infected_neighbors = self.get_neighboring_agents(state_id=1) + if len(infected_neighbors)>0: + if random.random() < self.prob_neutral_making_denier: + self.state['id'] = 3 # Vaccinated making denier + + def infected_behaviour(self): + + # Neutral + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_infect: + neighbor.state['id'] = 1 # Infected + + def cured_behaviour(self): + + # Vaccinate + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_cured_vaccinate_neutral: + neighbor.state['id'] = 3 # Vaccinated + + # Cure + infected_neighbors = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors: + if random.random() < self.prob_cured_healing_infected: + neighbor.state['id'] = 2 # Cured + + def vaccinated_behaviour(self): + + # Cure + infected_neighbors = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors: + if random.random() < self.prob_cured_healing_infected: + neighbor.state['id'] = 2 # Cured + + # Vaccinate + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_cured_vaccinate_neutral: + neighbor.state['id'] = 3 # Vaccinated + + # Generate anti-rumor + infected_neighbors_2 = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors_2: + if random.random() < self.prob_generate_anti_rumor: + neighbor.state['id'] = 2 # Cured + + def beacon_off_behaviour(self): + infected_neighbors = self.get_neighboring_agents(state_id=1) + if len(infected_neighbors) > 0: + self.state['id'] == 5 # Beacon on + + def beacon_on_behaviour(self): + + # Cure (M2 feature added) + infected_neighbors = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors: + if random.random() < self.prob_generate_anti_rumor: + neighbor.state['id'] = 2 # Cured + neutral_neighbors_infected = neighbor.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors_infected: + if random.random() < self.prob_generate_anti_rumor: + neighbor.state['id'] = 3 # Vaccinated + infected_neighbors_infected = neighbor.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors_infected: + if random.random() < self.prob_generate_anti_rumor: + neighbor.state['id'] = 2 # Cured + + # Vaccinate + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_cured_vaccinate_neutral: + neighbor.state['id'] = 3 # Vaccinated diff --git a/models/ModelM2/SpreadModelM2.py b/models/ModelM2/SpreadModelM2.py new file mode 100644 index 0000000..aac29a2 --- /dev/null +++ b/models/ModelM2/SpreadModelM2.py @@ -0,0 +1,107 @@ +import settings +import random +import numpy as np +from ..BaseBehaviour import * +from .. import init_states + +settings.init() + + +class SpreadModelM2(BaseBehaviour): + """ + Settings: + prob_neutral_making_denier + + prob_infect + + prob_cured_healing_infected + + prob_cured_vaccinate_neutral + + prob_vaccinated_healing_infected + + prob_vaccinated_vaccinate_neutral + + prob_generate_anti_rumor + """ + + init_states[random.randint(0, settings.number_of_nodes)] = {'id':1} + init_states[random.randint(0, settings.number_of_nodes)] = {'id':1} + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + + self.prob_neutral_making_denier = np.random.normal(settings.prob_neutral_making_denier, settings.standard_variance) + + self.prob_infect = np.random.normal(settings.prob_infect, settings.standard_variance) + + self.prob_cured_healing_infected = np.random.normal(settings.prob_cured_healing_infected, settings.standard_variance) + self.prob_cured_vaccinate_neutral = np.random.normal(settings.prob_cured_vaccinate_neutral, settings.standard_variance) + + self.prob_vaccinated_healing_infected = np.random.normal(settings.prob_vaccinated_healing_infected, settings.standard_variance) + self.prob_vaccinated_vaccinate_neutral = np.random.normal(settings.prob_vaccinated_vaccinate_neutral, settings.standard_variance) + self.prob_generate_anti_rumor = np.random.normal(settings.prob_generate_anti_rumor, settings.standard_variance) + + def step(self, now): + + if self.state['id'] == 0: # Neutral + self.neutral_behaviour() + elif self.state['id'] == 1: # Infected + self.infected_behaviour() + elif self.state['id'] == 2: # Cured + self.cured_behaviour() + elif self.state['id'] == 3: # Vaccinated + self.vaccinated_behaviour() + + self.attrs['status'] = self.state['id'] + super().step(now) + + def neutral_behaviour(self): + + # Infected + infected_neighbors = self.get_neighboring_agents(state_id=1) + if len(infected_neighbors)>0: + if random.random() < self.prob_neutral_making_denier: + self.state['id'] = 3 # Vaccinated making denier + + def infected_behaviour(self): + + # Neutral + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_infect: + neighbor.state['id'] = 1 # Infected + + def cured_behaviour(self): + + # Vaccinate + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_cured_vaccinate_neutral: + neighbor.state['id'] = 3 # Vaccinated + + # Cure + infected_neighbors = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors: + if random.random() < self.prob_cured_healing_infected: + neighbor.state['id'] = 2 # Cured + + def vaccinated_behaviour(self): + + # Cure + infected_neighbors = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors: + if random.random() < self.prob_cured_healing_infected: + neighbor.state['id'] = 2 # Cured + + # Vaccinate + neutral_neighbors = self.get_neighboring_agents(state_id=0) + for neighbor in neutral_neighbors: + if random.random() < self.prob_cured_vaccinate_neutral: + neighbor.state['id'] = 3 # Vaccinated + + # Generate anti-rumor + infected_neighbors_2 = self.get_neighboring_agents(state_id=1) + for neighbor in infected_neighbors_2: + if random.random() < self.prob_generate_anti_rumor: + neighbor.state['id'] = 2 # Cured diff --git a/models/ModelM2/__init__.py b/models/ModelM2/__init__.py new file mode 100644 index 0000000..970738b --- /dev/null +++ b/models/ModelM2/__init__.py @@ -0,0 +1,2 @@ +from .ControlModelM2 import ControlModelM2 +from .SpreadModelM2 import SpreadModelM2 diff --git a/models/SentimentCorrelationModel/SentimentCorrelationModel.py b/models/SentimentCorrelationModel/SentimentCorrelationModel.py new file mode 100644 index 0000000..a4b5021 --- /dev/null +++ b/models/SentimentCorrelationModel/SentimentCorrelationModel.py @@ -0,0 +1,109 @@ +import settings +import random +from ..BaseBehaviour import * +from .. import sentimentCorrelationNodeArray + +settings.init() + + +class SentimentCorrelationModel(BaseBehaviour): + """ + Settings: + outside_effects_prob + + anger_prob + + joy_prob + + sadness_prob + + disgust_prob + """ + + def __init__(self, environment=None, agent_id=0, state=()): + super().__init__(environment=environment, agent_id=agent_id, state=state) + self.outside_effects_prob = settings.outside_effects_prob + self.anger_prob = settings.anger_prob + self.joy_prob = settings.joy_prob + self.sadness_prob = settings.sadness_prob + self.disgust_prob = settings.disgust_prob + self.time_awareness=[] + for i in range(4): #In this model we have 4 sentiments + self.time_awareness.append(0) #0-> Anger, 1-> joy, 2->sadness, 3 -> disgust + sentimentCorrelationNodeArray[self.id][self.env.now]=0 + + def step(self, now): + self.behaviour() + super().step(now) + + def behaviour(self): + + angry_neighbors_1_time_step=[] + joyful_neighbors_1_time_step=[] + sad_neighbors_1_time_step=[] + disgusted_neighbors_1_time_step=[] + + angry_neighbors = self.get_neighboring_agents(state_id=1) + for x in angry_neighbors: + if x.time_awareness[0] > (self.env.now-500): + angry_neighbors_1_time_step.append(x) + num_neighbors_angry = len(angry_neighbors_1_time_step) + + joyful_neighbors = self.get_neighboring_agents(state_id=2) + for x in joyful_neighbors: + if x.time_awareness[1] > (self.env.now-500): + joyful_neighbors_1_time_step.append(x) + num_neighbors_joyful = len(joyful_neighbors_1_time_step) + + sad_neighbors = self.get_neighboring_agents(state_id=3) + for x in sad_neighbors: + if x.time_awareness[2] > (self.env.now-500): + sad_neighbors_1_time_step.append(x) + num_neighbors_sad = len(sad_neighbors_1_time_step) + + disgusted_neighbors = self.get_neighboring_agents(state_id=4) + for x in disgusted_neighbors: + if x.time_awareness[3] > (self.env.now-500): + disgusted_neighbors_1_time_step.append(x) + num_neighbors_disgusted = len(disgusted_neighbors_1_time_step) + + anger_prob= settings.anger_prob+(len(angry_neighbors_1_time_step)*settings.anger_prob) + joy_prob= settings.joy_prob+(len(joyful_neighbors_1_time_step)*settings.joy_prob) + sadness_prob = settings.sadness_prob+(len(sad_neighbors_1_time_step)*settings.sadness_prob) + disgust_prob = settings.disgust_prob+(len(disgusted_neighbors_1_time_step)*settings.disgust_prob) + outside_effects_prob= settings.outside_effects_prob + + num = random.random() + + if(numanger_prob): + + self.state['id'] = 2 + sentimentCorrelationNodeArray[self.id][self.env.now]=2 + self.time_awareness[self.state['id']-1] = self.env.now + elif (numjoy_prob+anger_prob): + + + self.state['id'] = 3 + sentimentCorrelationNodeArray[self.id][self.env.now]=3 + self.time_awareness[self.state['id']-1] = self.env.now + elif (numsadness_prob+anger_prob+joy_prob): + + + self.state['id'] = 4 + sentimentCorrelationNodeArray[self.id][self.env.now]=4 + self.time_awareness[self.state['id']-1] = self.env.now + + self.attrs['sentiment'] = self.state['id'] diff --git a/models/SentimentCorrelationModel/__init__.py b/models/SentimentCorrelationModel/__init__.py new file mode 100644 index 0000000..df4341c --- /dev/null +++ b/models/SentimentCorrelationModel/__init__.py @@ -0,0 +1 @@ +from .SentimentCorrelationModel import SentimentCorrelationModel diff --git a/models/__init__.py b/models/__init__.py new file mode 100644 index 0000000..ac9a29c --- /dev/null +++ b/models/__init__.py @@ -0,0 +1,8 @@ +from .models import * +from .BaseBehaviour import * +from .BassModel import * +from .BigMarketModel import * +from .IndependentCascadeModel import * +from .ModelM2 import * +from .SentimentCorrelationModel import * + diff --git a/models/models.py b/models/models.py new file mode 100644 index 0000000..de78646 --- /dev/null +++ b/models/models.py @@ -0,0 +1,13 @@ +import settings + +settings.init() + +global networkStatus +networkStatus = {} # Dict that will contain the status of every agent in the network + +sentimentCorrelationNodeArray=[] +for x in range(0, settings.number_of_nodes): + sentimentCorrelationNodeArray.append({'id':x}) +# Initialize agent states. Let's assume everyone is normal. +init_states = [{'id': 0, } for _ in range(settings.number_of_nodes)] + # add keys as as necessary, but "id" must always refer to that state category diff --git a/models.py b/models_org.py similarity index 100% rename from models.py rename to models_org.py diff --git a/soil.py b/soil.py index 43a4b5f..007ce2d 100644 --- a/soil.py +++ b/soil.py @@ -9,7 +9,6 @@ import math import json settings.init() # Loads all the data from settings -models.init() # Loads the models and network variables #################### # Network creation #