Introduction à Modgen

Acteurs

Tout d'abord, les modèles Modgen simulent la vie d'un acteur. Un acteur peut être n'importe quelle entité que le concepteur de modèle souhaite simuler. Ce peut être une personne, un logement, un plan de pension, etc.

Les acteurs sont définis par leurs :

• États
• Événements
• Fonctions
• Crochets

int age_int;	//FR Âge intègre

int age_int = {0} ;	//FR Âge intègre

//FR Année
MODELED_TIME modeled_year = COERCE(MODELED_TIME, year);

//FR Âge au début de l'année
int age_debut_annee = value_at_latest_change( annee, age_int);

actor Personne	//FR Personne
{
	void Start();	//FR Initialise une nouvelle personne
};

void Personne::Start()
{
}

actor Personne	//FR Personne
{
	//FR Commence Personne
	void Start( int nObs, logical lImmigrant, double dTempsDebut, logical lEnfant, Personne *prMere ); 
};  

/*NOTE(Personne.Start, FR)
	Cette fonction commence la personne.
*/
void Personne::Start( int nObs, bool bImmigrant, TIME tTempsDebut, bool bEnfant) 
{
	immigre_apres_recensement = bImmigrant;
	num_recense = nObs;

	ne_apres_recensement = bEnfant;

	time = CoarsenMantissa(tTempsDebut);
...
	vivant = TRUE;
	emigrant = FALSE;
   
	// Année 
	annee = (int) time;
};

actor Personne	//FR Personne
{
	void Finish();	//FR Termine Personne 
};  

void Personne::Finish()
{
    // Vide pour le moment
}

/* NOTE(Person.Finish,FR) 
	Fonction qui nettoie l'acteur, une fois qu'il a terminé.
*/
void Person::Finish()
{
	Person	*prChild = {NULL};
	int		 nIndex = {0};

	IMPLEMENT_HOOK();
...
	if ( tentative && sex == FEMALE ) 
	{
		mlChildren->FinishAll();
		mlChildrenAtHome->FinishAll();
		mlBiologicalChildren->FinishAll();
	}
}

actor Person	//FR Individu principal
{
	void Start( ...);	//FR Fonction qui lance l'acteur Personne
	void StartClockHere();	//FR Fonction fictive Start Clock

};

/* NOTE(Person.StartClockHere,FR) 
Fonction fictive qui permet d'initialiser l'horloge avant toutes 
les autres fonctions accrochées et fonctions dérivées.
*/
void Person::StartClockHere()
{
}

void Person::Start( ... )
{
...
	time = birth;
	StartClockHere(); 
...	
	year_of_birth = year;
	month_of_birth = month_of_year;
	day_of_birth = day_of_month;
...	
}

actor Person	//FR Individu principal
{
	//FR Initialise l'horloge à la naissance de l'acteur
	void StartClock();	

	hook StartClock, StartClockHere;
};

Ensembles d'acteurs

Les ensembles d'acteurs sont des collections d'acteurs maintenues dynamiquement par Modgen. Cela signifie que Modgen s'occupe de l'adhésion au groupe selon le critère fourni par Modgen. Les ensembles d'acteur peuvent être multidimensionnels. Dans ce cas, les dimensions sont constituées d'états des acteurs regroupés en ensembles. Pour chaque combinaison de valeur des dimensions, un sous-ensemble est créé. L'appartenance d'un acteur à un seul sous-ensemble est automatiquement maintenue par Modgen. Pour en savoir davantage sur les ensembles d'acteurs, vous pouvez vous référer au Guide du concepteur de Modgen.

Liens

Les liens définissent des relations entre acteurs de même type ou de type différents. Il peut y avoir des liens d'un acteur à un seul autre acteur, d'un acteur à plusieurs acteurs, ou de plusieurs acteurs à plusieurs acteurs. Dans tous les cas, les liens réciproques sont automatiquement créés et maintenus par Modgen. Cela implique que le code du modèle n'a qu'à assigner l'un des liens et le lien réciproque sera modifié pour refléter le changement.

Exemples de liens :

// Déclare le lien un-à-plusieurs pour l'appartenance à une famille 
link
	Person.lFamily	//FR Famille
	Family.mlMembers[]	//FR Membres de la famille 
;

// lien entre parents et enfants 
link 
	Person.mlChildren[]	//FR Enfants
	Person.mlParents[]	//FR Parents 
;

// lien entre la personne et son(sa) conjoint(e) 
link Person.lSpouse;	//FR Conjoint(e)

Pour de plus amples renseignements sur les liens, vous pouvez vous référer au Guide du concepteur de Modgen 12.

Paramètres

Les paramètres permettent à l'utilisateur du modèle d'avoir un certain contrôle sur la simulation. Les paramètres devraient être utilisés partout où le concepteur souhaite donner du contrôle à l'utilisateur du modèle. Le fait de permettre à l'utilisateur du modèle de préciser des hasards pour contrôler différents aspects de la simulation, par exemple, donne à l'utilisateur la possibilité d'explorer différents scénarios.

Il existe deux grandes catégories de paramètres :

• paramètres
• paramètres générés par le modèle

parameters 
{
	//FR hazard total de mortalité (m total) 
	double MortHazard[MODELED_AGE][SEX];
};

parameters 
{
	//FR Hasards de mortalité résiduels 
	model_generated double 
		ResidualMortHazard[MODELED_AGE][SEX];
};

Tableaux

Les tableaux forment la sortie des modèles Modgen. Il existe deux types différents de tableaux :

• tableaux : Les tableaux croisés d'un modèle génèrent des résultats agrégés d'une simulation.
• tableaux d'utilisateurs : Ces tableaux sont mal nommés. Il ne s'agit pas ici des utilisateurs des modèles mais des utilisateurs de Modgen. Autrement dit, il s'agit des concepteurs de modèles! Les tableaux d'utilisateurs permettent aux concepteurs de modèle de créer du code qui calcule la valeur de chaque cellule. Pour chaque tableau d'utilisateur, du code doit être placé dans une fonction « UserTables » pour contrôler le contenu du tableau. Typiquement ce code lit et combine des valeurs de différents tableaux pour en créer d'autres.

Groupes de tableaux ou de paramètres

Il est possible de regrouper certains symboles en groupes. Ces groupes servent surtout à regrouper les symboles dans l'interface du modèle mais sont également décrits dans l'aide générée par Modgen du modèle. Les symboles qu'il est possible de grouper sont :

• paramètres du modèle
• paramètres générés par le modèle
• tableaux et tableaux d'utilisateurs

L'appartenance d'un symbole à un groupe doit être précisée dans la déclaration du groupe. Notons qu'un groupe peut toujours contenir un autre groupe du même genre, ce qui permet de créer une hiérarchie.

Exemple d'un groupe de paramètres :

parameter_group DEMOGRAPHIE	//FR Paramètres démographiques
{
	HasardMortalite, HasardNatalite, AgeMaximal, ProbabiliteGarcon, VariationFecondite
};

Exemple d'un groupe de tableaux :

table_group TableauxDemographiques {	//FR Tableaux démographiques
    TauxNaissance,
    Population,
    Population5Ans
};

Types

Les symboles de type sont des symboles de support. Ils ne sont pas essentiels à la simulation puisqu'ils ne jouent aucun rôle précis dans le déroulement d'un modèle. Toutefois, ils sont partout puisqu'ils servent à définir d'autres symboles comme les états ou les paramètres. Ils servent également à donner des étiquettes aux tableaux. Il y a trois catégories de symboles de types :

• Classifications
• Étendues (« range »)
• Partitions

classification LANGUE2 
{
	//FR francophone
	L2_FRANCO,
	//FR non francophone
	L2_NON_FRANCO
};

range AGE_NATALITE {15, 49} ;	//FR Âge pour les taux de natalité

//FR Groupes d'âge
partition GROUPE_AGE 
{ 
	5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100 
};

Lecture des paramètres

La première étape d'une simulation d'un modèle de cas ou basé sur le temps est la lecture des paramètres. Il n'est pas nécessaire de créer une fonction globale dans le code du modèle pour gérer la lecture ou la modification interactive des paramètres. Cela est fournit par Modgen.

Validation des paramètres

Modgen comprend des fonctions permettant au concepteur de valider et modifier les valeurs des paramètres fournies par l'utilisateur. Pour de plus amples renseignements sur ces fonctions, vous pouvez vous référer au Guide du concepteur de Modgen 12.

Pré-simulation

Après la lecture des paramètres vient la phase de pré-simulation. La phase de pré-simulation ne fera rien du tout à moins que le concepteur du modèle ait défini une fonction « PreSimulation » ou plus. Notons qu'il est possible de créer plus d'une fonction « PreSimulation » afin d'avoir plus de modularité. Dans une version future de Modgen, il sera même possible de préciser l'ordre d'exécution des fonctions PreSimulation d'un modèle.

Habituellement, les fonctions «PreSimulation » servent à calculer les paramètres générés par le modèle. À ce stade, il n'y a toujours qu'un seul fil d'exécution alors on peut modifier les paramètres générés par le modèle sans craindre les collisions entre différents fils d'exécution. De plus, il est impossible pour une fonction « PreSimulation » de modifier les acteurs, puisque les acteurs n'ont pas encore été créés.

Exemple :

parameters 
{
	//FR Hasards de mortalité totaux ( m total) 
	double MortHazard[MODELED_AGE][SEX];

	//FR Hasards de mortalité due à la maladie X de la population(mx)
	double MortHazardX[MODELED_AGE][SEX];

	//FR Hasards de mortalité due à la maladie C de la population(mc)
	double MortHazardC[MODELED_AGE][SEX];

	//FR Hasards de mortalité résiduels 
	model_generated double 
		ResidualMortHazard[MODELED_AGE][SEX];
};

void PreSimulation()
{	int nAge = {0};
	int nSex = {0};
	int nTime = {0};

	for (nAge = 0; nAge < SIZE(MODELED_AGE); nAge++)
	{
		for (nSex = 0; nSex < SIZE(SEX); nSex++)
		{
			// Calcul des hazards de mortalité résiduels 
			ResidualMortHazard[nAge][nSex] = 
				MortHazard[nAge][nSex] 
					– MortHazardC[nAge][nSex] 
					– MortHazardX[nAge][nSex];
		}
	}
}

Simulation

Une fois la pré-simulation terminée commence la phase de simulation. Le modèle doit absolument contenir une fonction « Simulation ». Typiquement, dans le cas d'un modèle de cas, il s'agira simplement d'une boucle appelant la fonction « CaseSimulation » pour chaque cas du modèle.

Exemple :

void Simulation()
{
	long  lCase = 0;
	
	for ( lCase = 0; lCase < CASES() && !gbInterrupted && !gbCancelled && !gbErrors; lCase++ )
	{
		StartCase(); 
		CaseSimulation(); 
		SignalCase();
	}
}

La fonction « Simulation » est plus compliquée pour un modèle basé sur le temps, parce qu'elle doit également créer la population de début. Elle doit également contenir la boucle d'événements contenue dans la fonction « CaseSimulation » présentée ci-bas pour les modèles de cas.

Notons que cette fonction est incluse dans les modèles créés par un des assistants de création d'un modèle de Modgen.

// boucle d'événements pour le cas actuel 
while ( !gpoEventQueue->Empty() ) 
{
	if ( gbCancelled || gbErrors)
	{
		// en cas d'erreurs, ferme le cas, détruis tous les acteurs 
		gpoEventQueue->FinishAllActors();
	}
	else 
	{
		// avance le temps des acteurs au temps de l'événement suivant	
		gpoEventQueue->WaitUntil( gpoEventQueue->NextEvent() );
	
		// exécute l'événement suivant 
		gpoEventQueue->Implement();
	}
}

PostSimulation

Au besoin, le concepteur de modèles peut définir une fonction « PostSimulation ». Si elle est définie, cette fonction est exécutée après la phase de simulation, mais avant la tabulation des données. Il est rare que cette fonction soit utile. Toutefois, si des variables globales sont utilisées dans le modèle, il peut être utile de les réinitialiser dans cette fonction. De cette façon, si l'utilisateur redémarre une simulation sans avoir fermé le modèle, les variables globales sont initialisées aux mêmes valeurs que lors de la première simulation.

Tabulation

La dernière phase produit les tableaux. Cette expression est toutefois trompeuse puisque la tabulation dans Modgen est faite au fur et à mesure. Il s'agit simplement ici d'enregistrer les tableaux produits pendant la simulation dans la base de données de sortie.

Toutefois, les tableaux d'utilisateurs sont calculés à cette étape avant d'être enregistrés dans la base de données. C'est à cette étape que sont exécutées les fonctions « UserTables » créées par le concepteur du modèle pour calculer les valeurs des cellules des tableaux d'utilisateur.