/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N E T G E S T I O N D E S T R A I N E E S : */
/* */
/* */
/* Author of '$xrv/champs_5.LN$I' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1995??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E S T R A I N E E S : */
/* */
/*************************************************************************************************************************************/
#TestADef GENERER_LES_TRAINEES \
VRAI
DEFV(Local,DEFV(Logical,INIT(generer_les_trainees,GENERER_LES_TRAINEES)));
/* Indicateur disant si les trainees doivent etre generees. */
#define MODE_DE_GENERATION_DES_TRAINEES \
CALCUL_SIMPLIFIE_DES_TRAINEES \
/* Les deux modes principaux sont : */ \
/* */ \
/* 0 : CALCUL_STANDARD_DES_TRAINEES 'ADD2(...)', */ \
/* 1 : CALCUL_SIMPLIFIE_DES_TRAINEES 'MAX2(...)', */ \
/* */
#if ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
# undef MODE_DE_GENERATION_DES_TRAINEES
# define MODE_DE_GENERATION_DES_TRAINEES \
CALCUL_STANDARD_DES_TRAINEES
#Aif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
#Eif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
DEFV(Local,DEFV(Int,INIT(mode_de_generation_des_trainees,MODE_DE_GENERATION_DES_TRAINEES)));
/* Mode de generation des trainees (voir 'DenumeT07(...,types_de_calcul_de_trainees)' */
/* dans 'v $xiii/tri_image$DEF'). Le mode 'CALCUL_SIMPLIFIE_DES_TRAINEES' est le mode qui */
/* donne le plus simplement et le mieux l'effet attendu, tout cela sans problemes de */
/* renormalisation... */
#define FACTEUR_D_ATTENUATION_DES_TRAINEES \
GRO6(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(facteur_d_attenuation_des_trainees,FACTEUR_D_ATTENUATION_DES_TRAINEES)));
/* Facteur 'k' d'attenuation des trainees qui est applique aux trainees 'T'... */
#define FACTEUR_D_ATTENUATION_DES_IMAGES \
COMP(FACTEUR_D_ATTENUATION_DES_TRAINEES)
DEFV(Local,DEFV(Float,INIT(facteur_d_attenuation_des_images,FACTEUR_D_ATTENUATION_DES_IMAGES)));
/* Facteur '1-k' d'attenuation des trainees qui est applique aux images 'I' de la */
/* simulation... */
DEFV(Local,DEFV(Int,INIT(periode_d_attenuation_des_trainees,UN)));
/* En fait, pour des raisons d'arithmetiques elementaires, on ne peut pas appliquer */
/* n'importe quelle valeur d'attenuation (par exemple 0.999 et 0.99999 sont equivalentes */
/* puisqu'appliquees a 255, elles donnent toutes les deux 254...). Donc pour ces valeurs */
/* tres proches de 1, il faut faire quelque chose d'autre ; ainsi, l'attenuation pourra, */
/* si necessaire, n'etre appliquee qu'une image sur N, 'N' dependant de la proximite de */
/* 'facteur_d_attenuation_des_trainees' avec 1.0 (voir le programme 'v $xtc/trainees.01$c' */
/* qui permet de fixer 'facteur_d_attenuation_des_trainees'). */
#if ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
/* On notera qu'a compter du 20170125111231, ce 'if(...)' est inutile puisqu'en effet, */
/* 'RENORMALISATION_AUTOMATIQUE_DES_TRAINEES' est defini dans tous les cas, mais on ne */
/* sait jamais... */
# define RENORMALISATION_AUTOMATIQUE_DES_TRAINEES \
NE_PAS_RENORMALISER_LES_TRAINEES_CALCULEES_ITERATIVEMENT \
/* Afin de ne pas renormaliser automatiquement les trainees... */
#Aif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
# define RENORMALISATION_AUTOMATIQUE_DES_TRAINEES \
NE_PAS_RENORMALISER_LES_TRAINEES_CALCULEES_ITERATIVEMENT \
/* Afin de ne pas renormaliser automatiquement les trainees (introduit le 20170125111231). */
#Eif ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
#define TRAINEES_ROUGE \
ImageA1
#define TRAINEES_VERTE \
ImageA2
#define TRAINEES_BLEUE \
ImageA3
/* Definition des images contenant les cumuls utiles au calcul des trainees. */
#ifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
# define CUMUL_D_UNE_COMPOSANTE_POUR_LE_CALCUL_DES_TRAINEES(composante,cumul,trainee_du_BLANC_avant,trainee_du_BLANC_apres,num) \
Bblock \
PRINT_ATTENTION("sur 'SYSTEME_DPX5000_SPIX_CC' le calcul des trainees n'est pas implante"); \
Eblock \
/* Cumul d'une composante (non implante sur 'SYSTEME_DPX5000_SPIX_CC'). */
#Aifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
# define CUMUL_D_UNE_COMPOSANTE_POUR_LE_CALCUL_DES_TRAINEES(composante,cumul,trainee_du_BLANC_avant,trainee_du_BLANC_apres,num) \
Bblock \
Test(IL_FAUT(generer_les_trainees)) \
Bblock \
EGAL(trainee_du_BLANC_avant,trainee_du_BLANC_apres); \
/* Trainee courante du 'BLANC' avant l'appel de 'Icalcul_iteratif_des_trainees(...)' pour */ \
/* la composante courante ('ROUGE', 'VERTE' ou 'BLEUE'). */ \
EGAL(trainee_du_BLANC_apres \
,Icalcul_iteratif_des_trainees(composante \
,COND(DIVISIBLE(num,periode_d_attenuation_des_trainees) \
,facteur_d_attenuation_des_trainees \
,FU \
) \
,cumul \
,facteur_d_attenuation_des_images \
,composante \
,mode_de_generation_des_trainees \
,trainee_du_BLANC_avant \
,RENORMALISATION_AUTOMATIQUE_DES_TRAINEES \
) \
); \
/* Calcul de l'effet de trainee, ainsi que de l'"image" du 'BLANC' pour la composante */ \
/* courante ('ROUGE', 'VERTE' ou 'BLEUE'). Le processus est grossierement le suivant : */ \
/* */ \
/* composante = FAT*cumul + FAI*composante */ \
/* */ \
/* ou 'FAT' designe le parametre 'facteur_d_attenuation_des_trainees' et ou 'FAI' designe */ \
/* le parametre 'facteur_d_attenuation_des_images'... */ \
/* */ \
/* ATTENTION, avant le 1995062200, le facteur d'attenuation des images etait modifie */ \
/* lors de l'appel de 'Icalcul_iteratif_des_trainees(...)' de la facon suivante : */ \
/* */ \
/* ,COND(IFEQ(mode_de_generation_des_trainees \ */ \
/* ,CALCUL_STANDARD_DES_TRAINEES \ */ \
/* ) \ */ \
/* ,facteur_d_attenuation_des_images \ */ \
/* ,FU \ */ \
/* ) \ */ \
/* */ \
/* pour une raison assez mysterieuse. Il parait plus logique de transmettre tel quel */ \
/* le parametre 'facteur_d_attenuation_des_images' (cette modification a ete effectuee */ \
/* a cause de son utilisation dans 'v $xrr/N_corps.11$K'). */ \
CONVOLUTION_D_UNE_COMPOSANTE(composante); \
/* Puis, eventuellement, convolution du resultat... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Cumul d'une composante : */ \
/* */ \
/* composante <-- F(cumul,composante) */ \
/* */ \
/* ainsi, on ajoute a la composante courante la "somme ponderee" des composantes */ \
/* precedentes. Rappelons le principe general : */ \
/* */ \
/* soient : */ \
/* */ \
/* I : une image calculee a l'instant 'i' de la simulation, */ \
/* i */ \
/* */ \
/* T : une image calculee de trainee a l'instant 'j' de la simulation, */ \
/* j */ \
/* */ \
/* n+1 : le nombre d'images a cumuler pour le calcul d'une trainee, */ \
/* */ \
/* k : le facteur d'attenuation dans [0,1], */ \
/* */ \
/* Posons : */ \
/* */ \
/* n n-1 1 0 */ \
/* d = k + k +...+ k + k */ \
/* */ \
/* On a alors ('+' designant l'operation de "cumul de trainees" qui n'est pas forcement */ \
/* l'addition arithmetique) : */ \
/* */ \
/* 1 n n-1 1 0 */ \
/* T = ---.(I .k + I .k +...+ I .k + I .k ) */ \
/* p+n d p+0 p+1 p+n-1 p+n */ \
/* */ \
/* et : */ \
/* 1 n 2 1 0 */ \
/* T = ---.( I .k +...+ I .k + I .k + I .k ) */ \
/* p+n+1 d p+1 p+n-1 p+n p+n+1 */ \
/* */ \
/* d'ou : */ \
/* */ \
/* 1 n 1 0 */ \
/* T = k.T - ---.k .I + ---.k .I */ \
/* p+n+1 p+n d p+0 d p+n+1 */ \
/* */ \
/* Or malheureusement, ici, nous avons perdu la memoire des evenements passes, et donc */ \
/* nous approximons en : */ \
/* */ \
/* 1 0 */ \
/* T = k.T + ---.k .I */ \
/* p+n+1 p+n d p+n+1 */ \
/* */ \
/* En fait se pose de plus un grave probleme de "stabilite" des niveaux, car en effet */ \
/* il faut qu'ils restent dans [NOIR,BLANC]. Or une renormalisation "locale" entrainerait */ \
/* d'une image a une autre des fluctuations (par exemple sur les quarks reels). Reecrivons */ \
/* donc la formule precedente de la facon suivante : */ \
/* */ \
/* T = a.T + b.I */ \
/* m+1 m m+1 */ \
/* */ \
/* en developpant la formule de recurrence, et en utilisant les niveaux maximaux, nous */ \
/* trouvons la condition suivante afin de rester dans [NOIR,BLANC] : */ \
/* */ \
/* 0 1 2 m */ \
/* 1 = b.(a + a + a +...+ a ) */ \
/* */ \
/* d'ou : */ \
/* */ \
/* m+1 */ \
/* 1 - a */ \
/* 1 = b.---------- */ \
/* 1 - a */ \
/* */ \
/* m+1 */ \
/* et en faisant tendre 'm' vers l'infini, a devient negligeable : */ \
/* */ \
/* b */ \
/* 1 = ------- */ \
/* 1 - a */ \
/* */ \
/* d'ou la formule de recurrence de calcul des trainees : */ \
/* */ \
/* T = k.T + (1-k).I */ \
/* p+n+1 p+n p+n+1 */ \
/* */ \
/* la stabilite est alors garantie puisque : */ \
/* */ \
/* k + (1-k) = 1 */ \
/* */ \
/* Enfin, pour etre plus general (et puisque 'Icalcul_iteratif_des_trainees(...)' contient */ \
/* un 'TRON(...)' garantissant les niveaux dans [NOIR,BLANC]), on prend : */ \
/* */ \
/* T = a.T + b.I */ \
/* p+n+1 p+n p+n+1 */ \
/* */ \
/* On notera enfin que 'k' multiplie le cumul courant, et '1-k' l'image courante, et non */ \
/* pas l'inverse... */
#Eifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
#ifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
# define MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(cumul,composante) \
Bblock \
PRINT_ATTENTION("sur 'SYSTEME_DPX5000_SPIX_CC' le calcul des trainees n'est pas implante"); \
Eblock \
/* Mise a jour du cumul (non implante sur 'SYSTEME_DPX5000_SPIX_CC'). */
#Aifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
# define MISE_A_JOUR_D_UN_CUMUL_POUR_LE_CALCUL_DES_TRAINEES(cumul,composante) \
Bblock \
Test(IL_FAUT(generer_les_trainees)) \
Bblock \
CALS(Imove(cumul,composante)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Mise a jour du cumul, le 'cumul' donnant l'etat courant des trainees... */
#Eifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
#define RENORMALISER_BRUTALEMENT_LES_TRAINEES \
FAUX
DEFV(Local,DEFV(Logical,INIT(renormaliser_brutalement_les_trainees,RENORMALISER_BRUTALEMENT_LES_TRAINEES)));
/* Indicateur disant si les trainees doivent etre renormalisees brutalement (introduit */
/* le 20241121174308).. */
#define RENORMALISER_LES_TRAINEES \
VRAI
DEFV(Local,DEFV(Logical,INIT(renormaliser_les_trainees,RENORMALISER_LES_TRAINEES)));
/* Indicateur disant si les trainees doivent etre renormalisees en fonction de l'"image" */
/* du 'BLANC' renvoyee par 'Icalcul_iteratif_des_trainees(...)'. */
DEFV(Local,DEFV(genere_p,INIT(trainee_du_ROUGE_avant,NIVEAU_UNDEF)));
DEFV(Local,DEFV(genere_p,INIT(trainee_du_ROUGE_apres,NOIR)));
DEFV(Local,DEFV(genere_p,INIT(trainee_du_VERTE_avant,NIVEAU_UNDEF)));
DEFV(Local,DEFV(genere_p,INIT(trainee_du_VERTE_apres,NOIR)));
DEFV(Local,DEFV(genere_p,INIT(trainee_du_BLEUE_avant,NIVEAU_UNDEF)));
DEFV(Local,DEFV(genere_p,INIT(trainee_du_BLEUE_apres,NOIR)));
/* "Images" du 'BLANC' ('BLANC' designant le niveau maximal possible pour une composante */
/* 'ROUGE', 'VERTE' ou 'BLEUE') par le processus de calcul des trainees ; rappelons que */
/* 'Icalcul_iteratif_des_trainees' est, comme son nom l'indique, un processus iteratif. */
/* Cette fonction renvoie donc a chaque appel l'image courante du 'BLANC' suivant : */
/* */
/* I (BLANC) = k.I (BLANC) + (1-k).BLANC */
/* n+1 n */
/* */
/* ou 'I (BLANC)' designe l'image du 'BLANC' avant l'appel, */
/* n */
/* */
/* et 'I (BLANC)' designe l'image du 'BLANC' apres l'appel (voir le 'RETU(...)'). */
/* n+1 */
/* */
#ifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
# define RENORMALISATION_EVENTUELLE_D_UNE_COMPOSANTE(composante,trainee_du_BLANC_avant,trainee_du_BLANC_apres) \
Bblock \
PRINT_ATTENTION("sur 'SYSTEME_DPX5000_SPIX_CC' le calcul des trainees n'est pas implante"); \
Eblock \
/* Renormalisation eventuelle d'une composante (non implante sur 'SYSTEME_DPX5000_SPIX_CC'). */
#Aifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2
# define RENORMALISATION_EVENTUELLE_D_UNE_COMPOSANTE(composante,trainee_du_BLANC_avant,trainee_du_BLANC_apres) \
Bblock \
Test(I3ET(IL_FAUT(generer_les_trainees) \
,IL_FAUT(renormaliser_les_trainees) \
,IFEQ(mode_de_generation_des_trainees,CALCUL_STANDARD_DES_TRAINEES) \
) \
) \
Bblock \
Test(IL_FAUT(renormaliser_brutalement_les_trainees)) \
Bblock \
CALS(Irenormalisation(composante,composante)); \
/* Introduit le 20241121174308... */ \
Eblock \
ATes \
Bblock \
Test(IFET(IFGE(trainee_du_BLANC_apres,trainee_du_BLANC_avant) \
,IFGT(trainee_du_BLANC_apres,NOIR) \
) \
) \
Bblock \
CALS(Iscale(composante \
,INVE(______NORMALISE_NIVEAU(trainee_du_BLANC_apres)) \
,composante \
,FZERO \
) \
); \
/* On renormalise la composante courante, en remontant son niveau maximal en fonction de */ \
/* l'image du BLANC... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'image de trainee du 'BLANC' ne peut que croitre"); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Renormalisation eventuelle d'une composante en fonction de l'"image" de son niveau */ \
/* maximal (appele 'BLANC') par la fonction de trainee... */
#Eifdef BUG_SYSTEME_DPX5000_SPIX_CC_LACT11_ZONE_DE_SWAP_2