def run(self):
"""
Execute la création du réseau et emet les signaux en conséquent
"""
_log.Linfo("Début -- ThreadCreation.run")
_reseau = self.TC_moteur_reseau.GcreerReseau(self.TC_param)
# Enregistrement du réseau obtenu
_file_manager = FileManager()
_file_manager.FMviderEtats(_garder_etat_initial=False)
_file_manager.FMenregistrerEtat(_reseau=_reseau, _show_html=True)
# Ajout des statistiques relevant de cet état initial
from Controleur.Statistiques import Statistiques
_statistiques = Statistiques()
_statistiques.SajouterDonnees(_reseau, 0)
_file_manager.FMsauvegarderStatistiques()
# Envoie des signaux
self.TC_resultat.emit(_reseau)
self.TC_finished.emit()
_log.Linfo("Fin -- ThreadCreation.run")
def SlancerSimulation(self, _reseau, _show_html):
"""
Permet de lancer le processus de simulation de la vie du réseau. Cf diagramme d'activité pour connaitre son
fonctionnement algorithmique.
:param _reseau: Reseau, le réseau à traiter
:param _show_html: bool, Permet de définir si l'état du réseau doit être affiché pendant la simulation
:return: Reseau, le réseau une fois traité
"""
_log.Linfo("Début ## Simulateur.SlancerSimulation")
from Modele.Reseau import Reseau
if type(_reseau) is not Reseau:
_log.Lerror("Valeur Argument errone _reseau")
raise Exception("Valeur Argument errone _reseau")
if type(_show_html) is not bool:
_log.Lerror("Valeur Argument errone _show_html")
raise Exception("Valeur Argument errone _show_html")
from Controleur.Statistiques import Statistiques
_statistiques = Statistiques()
_file_manager = FileManager()
# Chrono pour savoir combien de temps la simulation a durée
_start = time.time()
_dernier_roulement = 0
_reseau_simulation = _reseau
self.S_duree_simulation = 0
self.S_duree_de_vie = 0
self.S_intervalle_roulement = 0
# Initialisation des compteurs
_etat = 0
_total = 1
_cycle = 0
while not self.__SmaximumAtteint():
_log.Linfo("Info ## Cycle " + str(_cycle))
self.S_connecteur.emit(Signaux.INITIALISATION_SIMULATION, dict())
_reseau_simulation = copy.deepcopy(_reseau)
# Détermination de l'intervalle de temps
self.__SdeterminationIntervalleTemps()
_text_progression = "Simulation en cours.. " \
"\nCycle " + str(_cycle) + \
"\nintervalle utilisé : " + str(self.S_intervalle_roulement) + " unité(s) de temps"
self.S_connecteur.emit(
Signaux.PROGRESSION_SIMULATION,
dict({
"avancee": 0,
"text": _text_progression
}))
# Configuration topologique du réseau (routage et ensemble dominant)
_reseau_simulation = self.SconfigurationTopologique(
_reseau_simulation)
_fin_de_vie_atteinte, _capteurs_deconnectes = self.SfinDeVieAtteinte(
_reseau_simulation, self.S_intervalle_roulement)
self.S_duree_de_vie = 0
# Tant que la fin de vie du réseau n'a pas été atteinte, on simule la consommation énergétique en
# enregistrant les étapes intermédiaires
while not _fin_de_vie_atteinte:
_log.Linfo("Info ## état " + str(_etat))
# Cas où le temps écoulé correspond à l'intervalle de temps de changement de rôles des capteurs :
# le rôle des capteurs est modifié et l'état est enregistré
if self.S_intervalle_roulement != 0:
if self.S_duree_de_vie == 0 \
or self.S_duree_de_vie - _dernier_roulement >= self.S_intervalle_roulement:
_dernier_roulement = self.S_duree_de_vie
_reseau_simulation = self.SconfigurationTopologique(
_reseau_simulation)
_etat += 1
_total += 1
_file_manager.FMenregistrerEtat(
_reseau_simulation, _show_html)
_statistiques.SajouterDonnees(_reseau_simulation,
_cycle,
self.S_duree_simulation)
self.S_connecteur.emit(
Signaux.NOUVEL_ETAT,
dict({
"etat": _etat,
"total": _total
}))
# On simule la consommation énergétique des capteurs puis on regarde si la fin de vie a été atteinte
_reseau_simulation = self.__SsimulationSurUnRoulement(
_reseau_simulation, _capteurs_deconnectes)
_fin_de_vie_atteinte, _capteurs_deconnectes = self.SfinDeVieAtteinte(
_reseau_simulation, self.S_intervalle_roulement)
_ratio = len(_capteurs_deconnectes) / _reseau.R_nbr_noeuds - (
1 - self.S_fin_de_vie)
self.S_connecteur.emit(
Signaux.PROGRESSION_SIMULATION,
dict({
"avancee": int(_ratio * 100),
"text": _text_progression
}))
# Fin premier While : la fin de vie du réseau a été atteinte, on sauvegarde les états et on recommence avec
# un nouvel intervalle
# Ajout de l'état de la fin de vie du réseau
_etat += 1
_total += 1
_file_manager.FMenregistrerEtat(_reseau_simulation, _show_html)
_statistiques.SajouterDonnees(_reseau_simulation, _cycle,
self.S_duree_simulation)
self.S_resultats.append(
dict({
"intervalle": self.S_intervalle_roulement,
"resultat": self.S_duree_de_vie
}))
_statistiques.SajouterResultat(self.S_intervalle_roulement,
self.S_duree_de_vie)
self.S_connecteur.emit(Signaux.NOUVEL_ETAT,
dict({
"etat": _etat,
"total": _total
}))
# On met la barre de progression à 100%
self.S_connecteur.emit(
Signaux.PROGRESSION_SIMULATION,
dict({
"avancee": 100,
"text": _text_progression
}))
self.S_duree_simulation += self.S_intervalle_recolte * 100 # Pour séparer les résultats d'un cycle à lautre
_cycle += 1
# Fin while, cad fin de la simulation, le maximum a été trouvé
# Si les étapes intermédiaires n'ont pas été enregistrées sous format html, en enregistre quand même le dernier
# état afin d'avoir le premier et le dernier état d'affiché
if not _show_html:
_etat += 1
_total += 1
_file_manager.FMenregistrerEtat(_reseau_simulation, True)
self.S_connecteur.emit(Signaux.NOUVEL_ETAT,
dict({
"etat": _etat,
"total": _total
}))
FileManager.FMsauvegarderStatistiques()
# Informations sur la durée de la simulation
_end = time.time()
_temps = (_end - _start) // 1
self.S_connecteur.emit(Signaux.FIN_SIMULATION,
dict({"duree": abs(_temps)}))
_log.Linfo("Info ## Fin simulation")
return _reseau_simulation