/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E L ' A U T O - R E G U L A T I O N D U M O D E L E : */
/* */
/* */
/* Author of '$xrq/nucleon.LL.2$I' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 1992??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E S D ' A U T O - R E G U L A T I O N : */
/* */
/*************************************************************************************************************************************/
#define REGUL1(x) \
MUL2(FLOT(x),taux_d_auto_regulation)
#define REGUL0(x) \
NEUT(x)
#define REGUL9(x) \
DIVZ(FLOT(x),taux_d_auto_regulation)
/* Ces trois procedures correspondent aux trois cas de figure possibles, a savoir : */
/* */
/* REGUL1 : diminuer / augmenter */
/* REGUL0 : rien / rien */
/* REGUL9 : augmenter / diminuer */
/* . . */
/* /|\ /|\ */
/* | | */
/* ___________| | */
/* | _____________| */
/* | | */
/* | | */
/* suivant qu'il a trop ou pas assez de particules... */
/* ---- --------- */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E N T A T I V E D ' A U T O - R E G U L A T I O N D E L A D E N S I T E D E P A R T I C U L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef AUTO_REGULER_LE_MODELE \
VRAI
DEFV(Local,DEFV(Logical,INIT(auto_reguler_le_modele,AUTO_REGULER_LE_MODELE)));
/* Indicateur precisant si l'auto-regulation est activable ('VRAI') ou pas ('FAUX'). */
#define COEFFICIENT_D_AUTO_REGULATION \
GRO4(GRO10(FU))
DEFV(Local,DEFV(Float,INIT(coefficient_d_auto_regulation,COEFFICIENT_D_AUTO_REGULATION)));
/* Coefficient controlant la fonction utilisee lorsqu'il y a trop de particules. Alors, */
/* pour augmenter l'effet, il suffit d'augmenter ce coefficient. ATTENTION : il y avait */
/* autrefois : */
/* */
/* #define COEFFICIENT_D_AUTO_REGULATION \ */
/* GRO7(FRA10(FU)) */
/* */
/* valeur qui presentait la propriete suivante : */
/* */
/* f(1/2)=1/f(2) */
/* */
/* ou 'f(...)' represente la fonction que l'on definit ici. Or malheureusement, cette */
/* valeur ne regulait pas assez vite, et le nombre de particules croissait encore assez */
/* vite... */
#define DEMI_EXPOSANT_D_AUTO_REGULATION \
UN
DEFV(Local,DEFV(Positive,INIT(demi_exposant_d_auto_regulation,DEMI_EXPOSANT_D_AUTO_REGULATION)));
/* Coefficient controlant la fonction utilisee lorsqu'il n'y a pas assez de particules. */
/* Alors, pour augmenter l'effet, il suffit de dimunuer ce coefficient, sachant que, */
/* malheureusement 1 est le minimum... */
DEFV(Local,DEFV(Logical,INIT(auto_regulation_en_cours,FAUX)));
/* Indicateur precisant si l'auto-regulation est active ('VRAI') ou pas encore ('FAUX') ; */
/* notons d'ailleurs qu'une fois que ce processus est declenche, il ne s'arrete plus... */
#define FACTEUR_NEUTRE_D_AUTO_REGULATION \
FU
DEFV(Local,DEFV(Float,INIT(taux_d_auto_regulation,FACTEUR_NEUTRE_D_AUTO_REGULATION)));
/* Facteur de variation des differents nombres d'evenements et probabilites affectes par */
/* la procedure 'AUTO_REGULATION'. Ce taux est calcule dynamiquement. ATTENTION, on notera */
/* qu'il est reference dans : */
/* */
/* $xrq/nucleon.La.1$I, */
/* $xrq/nucleon.La.2$I, */
/* $xrq/meson.Lb.2$I, */
/* $xrq/nucleon.Lb.1$I, */
/* $xrq/nucleon.Lb.2$I, */
/* */
/* uniquement a cause de '$xrq/nucleon.LL.1$I', et donc pour se simplifier la vie... */
#define SEUIL_D_AUTO_REGULATION \
MOIT(nombre_maximal_de_particules_dans_le_proton) \
/* Nombre de particules qui est le seuil au-dela duquel on enclenche le processus */ \
/* d'auto-regulation (pour ne plus jamais l'arreter...). On notera que ce parametre n'est */ \
/* pas affecte par 'tSCALE(...)' car en effet, il correspond a un etat d'equilibre du */ \
/* systeme, auquel cas le nombre de particules est independant de la duree de l'observation. */
#define SEUIL_DU_PARAMETRE_D_AUTO_REGULATION \
FU \
/* Seuil de 'PARAMETRE_D_AUTO_REGULATION' destine a decouper la fonction d'auto-regulation */ \
/* en deux morceaux... */
#define PARAMETRE_D_AUTO_REGULATION \
DIVI(FLOT(nombre_instantane_de_particules),FLOT(SEUIL_D_AUTO_REGULATION)) \
/* Variable destinee a calculer la fonction d'auto-regulation... */
#define ___AUTO_REGULATION \
Bblock \
EGAL(taux_d_auto_regulation,FACTEUR_NEUTRE_D_AUTO_REGULATION); \
/* A priori, on initialise de facon a ce que l'auto-regulation soit ineffective... */ \
Test(IL_FAUT(auto_reguler_le_modele)) \
Bblock \
Test(IFGT(nombre_instantane_de_particules,SEUIL_D_AUTO_REGULATION)) \
Bblock \
EGAL(auto_regulation_en_cours,VRAI); \
/* Lorsque le nombre total de particules excede la moitie (arbitraire...) du maximum */ \
/* prevu, on met en marche (a moins qu'il y fut deja) le processus d'auto-regulation... */ \
Eblock \
ATes \
Bblock \
/* Lorsque le nombre total de particules n'excede pas la moitie (arbitraire...) du maximum */ \
/* prevu, on laisse inchange l'etat de l'auto-regulation : */ \
/* */ \
/* 1-si elle n'etait pas encore active, elle reste inactive, */ \
/* 2-si elle etait active, elle le reste (ainsi, on peut esperer que le nombre de particules */ \
/* va re-augmenter...). */ \
/* */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
EGAL(auto_regulation_en_cours,FAUX); \
/* Lorsqu'il ne faut pas auto-reguler le modele, le processus est systematiquement */ \
/* desactive... */ \
Eblock \
ETes \
\
Test(EST_VRAI(auto_regulation_en_cours)) \
Bblock \
/* Cas ou l'auto-regulation est active : le taux est calcule dynamiquement en fonction du */ \
/* nombre de particules par rapport a un certain seuil, le nombre de particules etant */ \
/* renormalise par rapport a ce seuil, ce qui donne 'PARAMETRE_D_AUTO_REGULATION'... */ \
/* */ \
/* . */ \
/* /|\ */ \
/* | */ \
/* | * . */ \
/* | * pas | . morceaux non utilises */ \
/* | * assez . / */ \
/* | * de | ./ */ \
/* | * particules . trop */ \
/* | | de */ \
/* | * . particules */ \
/* | | */ \
/* | * . */ \
/* | * | . */ \
/* 1.0 | - - - - - * * * < - - - - FACTEUR_NEUTRE_D_AUTO_REGULATION */ \
/* | . | * */ \
/* | * */ \
/* | . | * */ \
/* | * */ \
/* | . | * * * * * * * * * * * * * * * */ \
/* |-----------------------------------------------------------> */ \
/* | . 1.0 PARAMETRE_D_AUTO_REGULATION */ \
/* | (x) */ \
/* | ^ */ \
/* | . |___ SEUIL_DU_PARAMETRE_D_AUTO_REGULATION */ \
/* | \ */ \
/* | \ */ \
/* | . morceaux non utilises */ \
/* | */ \
/* */ \
/* Cette fonction est construite par raccordement de deux morceaux ; a gauche de 1, elle */ \
/* est constituee de l'inverse d'un monome translate et de degre pair, alors qu'a droite de */ \
/* 1, il s'agit d'une courbe rationnelle du troisieme degre. */ \
Test(IFGE(PARAMETRE_D_AUTO_REGULATION,SEUIL_DU_PARAMETRE_D_AUTO_REGULATION)) \
Bblock \
/* Cas ou l'auto-regulation est active et ou il y a trop de particules : on va reduire */ \
/* les nombres d'evenements ainsi que les probabilites de creation, et on va augmenter */ \
/* les probabilites de collisions... */ \
EGAL(taux_d_auto_regulation \
,DIVZ(PARAMETRE_D_AUTO_REGULATION \
,AXPB(AXPB(coefficient_d_auto_regulation \
,PARAMETRE_D_AUTO_REGULATION \
,SOUS(INVE(FACTEUR_NEUTRE_D_AUTO_REGULATION) \
,DOUB(MUL2(coefficient_d_auto_regulation,SEUIL_DU_PARAMETRE_D_AUTO_REGULATION)) \
) \
) \
,PARAMETRE_D_AUTO_REGULATION \
,MUL2(coefficient_d_auto_regulation,EXP2(SEUIL_DU_PARAMETRE_D_AUTO_REGULATION)) \
) \
) \
); \
/* Calcul du morceau de fonction correspondant a "trop de particules"... */ \
/* */ \
/* x */ \
/* y = ---------------- avec x E ]1,+INFINI[ */ \
/* 2 */ \
/* a.x + b.x + c */ \
/* */ \
/* (ou 'a' represente 'coefficient_d_auto_regulation'). */ \
/* */ \
/* Le maximum de la fonction est obtenu pour : */ \
/* */ \
/* ____ */ \
/* / c */ \
/* x = \ / --- = SEUIL_DU_PARAMETRE_D_AUTO_REGULATION */ \
/* \/ a */ \
/* */ \
/* 1 */ \
/* y = --------------- = FACTEUR_NEUTRE_D_AUTO_REGULATION */ \
/* ____ */ \
/* / */ \
/* 2.\/ a.c + b */ \
/* */ \
/* d'ou 'b' et 'c' en fonction de 'a' (qui designe 'coefficient_d_auto_regulation'). */ \
TRACE_D_UN_EVENEMENT(Prin6("REGULATION trop de particules (%d/%d) [Regul1(%g)=%g,Regul9(%g)=%g]" \
,nombre_instantane_de_particules \
,SEUIL_D_AUTO_REGULATION \
,FU,REGUL1(FU) \
,FU,REGUL9(FU) \
) \
); \
Eblock \
ATes \
Bblock \
/* Cas ou l'auto-regulation est active et ou il n'y a pas assez de particules : on va */ \
/* augmenter les nombres d'evenements ainsi que les probabilites de creation, et on va */ \
/* reduire les probabilites de collisions... */ \
EGAL(taux_d_auto_regulation \
,DIVZ(FACTEUR_NEUTRE_D_AUTO_REGULATION \
,SOUS(FACTEUR_NEUTRE_D_AUTO_REGULATION \
,PUIX(SOUS(PARAMETRE_D_AUTO_REGULATION,SEUIL_DU_PARAMETRE_D_AUTO_REGULATION) \
,DOUB(demi_exposant_d_auto_regulation) \
) \
) \
) \
); \
/* Calcul du morceau de fonction correspondant a "pas assez de particules"... */ \
/* */ \
/* 1 */ \
/* y = ---------------- avec x E [0,1] */ \
/* 2.n */ \
/* 1 - (x - 1) */ \
/* */ \
/* (ou 'n' represente 'demi_exposant_d_auto_regulation) */ \
/* */ \
TRACE_D_UN_EVENEMENT(Prin6("REGULATION pas assez de particules (%d/%d) [Regul1(%g)=%g,Regul9(%g)=%g]" \
,nombre_instantane_de_particules \
,SEUIL_D_AUTO_REGULATION \
,FU,REGUL1(FU) \
,FU,REGUL9(FU) \
) \
); \
Eblock \
ETes \
\
Test(IZLE(taux_d_auto_regulation)) \
Bblock \
PRINT_ERREUR("le facteur d'auto-regulation est negatif ou nul"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
/* Cas ou l'auto-regulation n'est pas encore activee... */ \
Eblock \
ETes \
Eblock \
/* Tentative d'auto-regulation du nombre de particules presentes en jouant sur certaines */ \
/* probabilites et sur certains nombres d'evenements... */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(AUTO_REGULATION,A,___AUTO_REGULATION))
EFonctionI