/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S F A M I L L E S D E P A R T I C U L E S : */
/* */
/* */
/* Author of '$xrq/nucleon.L8$I' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 1991??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S E N S E M B L E S D E P A R T I C U L E S : */
/* */
/*************************************************************************************************************************************/
/* Nota : suivant que l'on est 'FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_01' ou */
/* 'FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_02' 'nombre_instantane_de_particules' */
/* est defini soit explicitement soit implicitement dans 'CREATION_D_UNE_LISTE(...)'... */
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_quarks_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_d_anti_quarks_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_quarks_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_d_anti_quarks_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_gluons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_gluons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_d_electrons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_d_anti_electrons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_d_electrons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_d_anti_electrons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_neutrinos_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_neutrinos_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_photons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_photons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_z0s_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_z0s_VIRTUELs,ZERO)));
/* Compteurs instantes des particules par categorie (on notera la presence des anti-quarks */
/* REELs et des gluons REELs uniquement par symetrie...). Ils sont donc incrementes et */
/* decrementes au cours du temps... */
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_quarks_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_d_anti_quarks_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_quarks_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_d_anti_quarks_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_gluons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_gluons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_d_electrons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_d_anti_electrons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_d_electrons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_d_anti_electrons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_neutrinos_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_neutrinos_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_photons_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_photons_VIRTUELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_z0s_REELs,ZERO)));
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_z0s_VIRTUELs,ZERO)));
/* Compteurs total des particules par categorie (on notera la presence des anti-quarks */
/* REELs et des gluons REELs uniquement par symetrie...). Ils ne sont donc qu'incrementes */
/* et jamais decrementes au cours du temps... */
DEFV(Local,DEFV(Positive,INIT(nombre_total_de_particules,ZERO)));
/* Compteur global des particules (de toute nature...) qui ne fait donc l'objet que */
/* d'incrementations... */
#ifdef FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_01
# define PREMIERE_PARTICULE \
UN \
/* Numero de la premiere particule de la liste... */
# define NOMBRE_MAXIMAL_DE_QUARKS_ET_D_ANTI_QUARKS_DANS_LE_PROTON \
GRO1(FRA1(NOMBRE_MAXIMAL_DE_GLUONS_DANS_LE_PROTON)) \
/* Nombre maximal de quarks (REELs ou VIRTUELs) presents dans le proton a un instant donne. */
# define NOMBRE_MAXIMAL_DE_GLUONS_DANS_LE_PROTON \
DIX_MILLE \
/* Nombre maximal de gluons (REELs ou VIRTUELs) presents dans le proton a un instant donne. */
# define NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON \
ADD2(NOMBRE_MAXIMAL_DE_QUARKS_ET_D_ANTI_QUARKS_DANS_LE_PROTON,NOMBRE_MAXIMAL_DE_GLUONS_DANS_LE_PROTON) \
/* Nombre maximal de particules (quarks et gluons, REELs, VIRTUELs ou"INEXISTANTs") */ \
/* presentes dans le proton. */
# define ACCES_PARTICULE(particule_courante) \
COND(IFINff(particule_courante \
,PREMIERE_PARTICULE \
,LSTX(PREMIERE_PARTICULE,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON) \
) \
,ADRESSE(ITb1(liste_des_particules,INDX(particule_courante,PREMIERE_PARTICULE))) \
,ADRESSE(debordement_de_la_liste_des_particules) \
) \
/* Acces a une particule de numero donne dans la liste avec validation. On notera que l'on */ \
/* ecrit 'COND(ADRESSE(...))' et non pas 'ADRESSE(COND(...))' parce que certains */ \
/* compilateurs l'interdisent... */
DEFV(Local,DEFV(particule,DTb1(liste_des_particules,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON)));
/* "Liste" des particules (quarks et gluons, REELs, VIRTUELs ou "INEXISTANTs") presentes */
/* dans le proton. */
DEFV(Local,DEFV(particule,debordement_de_la_liste_des_particules));
/* Au cas ou la liste precedente serait saturee... */
DEFV(Local,DEFV(Positive,INIT(nombre_instantane_de_particules,ZERO)));
/* Compteur instantane des particules (de toute nature...) qui fait donc l'objet */
/* d'incrementations et de decrementations... */
# define ENSEMBLE_DES_PARTICULES(sequence) \
Bblock \
DEFV(Positive,INIT(particule_courante,UNDEF)); \
/* Numero de la particule courante dans la liste... */ \
DoIn(particule_courante \
,PREMIERE_PARTICULE \
,LSTX(PREMIERE_PARTICULE,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON) \
,I \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument sur chaque position a priori, quel que soit son */ \
/* etat (INEXISTANT, REEL ou VIRTUEL). */ \
Eblock \
EDoI \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble de particules, quel que soit leur */ \
/* etat (INEXISTANT, REEL ou VIRTUEL). */
# define CREATION_D_UNE_PARTICULE(particule_creee) \
Bblock \
DEFV(Positive,INIT(particule_courante,PREMIERE_PARTICULE)); \
/* Numero de la particule courante dans la liste... */ \
Tant(IFET(IFNE(NATURE(PARTICULE_COURANTE),PARTICULE_INEXISTANTE) \
,IFLT(particule_courante \
,LSTX(PREMIERE_PARTICULE,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON) \
) \
) \
) \
Bblock \
/* ATTENTION : on utilise 'IFLT(particule_courante,...)' afin que */ \
/* 'ACCES_PARTICULE(particule_courante)' ne provoque pas un debordement de la */ \
/* liste lorsque 'particule_courante' atteint sa valeur maximale qui est */ \
/* 'LSTX(PREMIERE_PARTICULE,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON)'... */ \
INCR(particule_courante,I); \
/* Passage a l'element suivant de la liste... */ \
Eblock \
ETan \
Test(IFLT(particule_courante \
,LSTX(PREMIERE_PARTICULE,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON) \
) \
) \
Bblock \
EGAL(particule_creee,PARTICULE_COURANTE); \
/* Envoi de la premiere particule INEXISTANTe trouvee, */ \
NATURE_D_UNE_PARTICULE(particule_creee,PARTICULE_NAISSANTE); \
/* Et on indique ainsi que cette particule a ete allouee... */ \
INCR(nombre_instantane_de_particules,I); \
INCR(nombre_total_de_particules,I); \
/* Et comptage instantane et global des particules en presence... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la liste des particules est saturee"); \
CAL1(Prer1("(%d particules)\n",nombre_instantane_de_particules)); \
EGAL(particule_creee,ADRESSE(debordement_de_la_liste_des_particules)); \
/* Ou du "debordement" si la liste des particules est saturee... */ \
Eblock \
ETes \
Eblock \
/* Creation d'une particule (REELle ou VIRTUELle) a partir d'une particule INEXISTANTe. */
# define DESTRUCTION_D_UNE_PARTICULE(particule_a_detruire) \
Bblock \
Test(IFNE(particule_a_detruire,ADRESSE(debordement_de_la_liste_des_particules))) \
Bblock \
Test(IFINff(particule_a_detruire \
,ACCES_PARTICULE(PREMIERE_PARTICULE) \
,ACCES_PARTICULE(LSTX(PREMIERE_PARTICULE,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON)) \
) \
) \
Bblock \
Test(IFNE(NATURE(particule_a_detruire),PARTICULE_INEXISTANTE)) \
Bblock \
DECR(nombre_instantane_de_particules,I); \
/* Decomptage global des particules en presence... */ \
NATURE_D_UNE_PARTICULE(particule_a_detruire,PARTICULE_INEXISTANTE); \
/* Et on libere tout betement la particule... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la particule a detruire est INEXISTANT"); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la particule a detruire est bizarre"); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
/* La zone de debordement ne peut etre detruite... */ \
Eblock \
ETes \
Eblock \
/* Destruction d'une particule... */
# define INITIALISATION_DE_L_ENSEMBLE_DES_PARTICULES \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(INITIALISATION_D_UNE_PARTICULE_INEXISTANTE(PARTICULE_COURANTE); \
) \
); \
/* Initialisation a priori de la particule courante... */ \
Eblock \
/* Initialisation de la liste des particules presentes dans le proton (INEXISTANTs). */
#Aifdef FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_01
#Eifdef FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_01
#ifdef FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_02
# define NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON \
GRO4(MILLE) \
/* Nombre maximal de particules (quarks et gluons, REELs, VIRTUELs ou"INEXISTANTs") */ \
/* presentes dans le proton. */
# define SUIVANT(particule_courante) \
SUIVANT_DANS_UNE_LISTE(ASI1(particule_courante,ensemble))
# define PRECEDENT(particule_courante) \
PRECEDENT_DANS_UNE_LISTE(ASI1(particule_courante,ensemble))
# define VALIDATION(particule_courante) \
VALIDATION_D_UN_ELEMENT_D_UNE_LISTE(ASI1(particule_courante,ensemble))
/* Procedures d'acces aux particules suivantes et precedentes. La procedure */
/* 'VALIDATION(...)' a ete introduite le 20031103120919... */
# define ACCES_PARTICULE(particule_courante) \
ACCES_A_UN_ELEMENT_D_UNE_LISTE(particule_courante) \
/* Acces a une particule donnee... */
CREATION_D_UNE_LISTE(particule
,premiere_particule,derniere_particule
,nombre_instantane_de_particules
,debordement_de_la_liste_des_particules
,PARTICULE_NON_DEFINIE
);
/* Creation de la liste des particules... */
# define ENSEMBLE_DES_PARTICULES(sequence) \
Bblock \
PARCOURS_D_UNE_LISTE(particule \
,premiere_particule,derniere_particule \
,nombre_instantane_de_particules \
,debordement_de_la_liste_des_particules \
,PARTICULE_NON_DEFINIE \
,SUIVANT,PRECEDENT,VALIDATION \
,particule_courante \
,BLOC(sequence) \
); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble de particules, quel que soit leur */ \
/* etat (INEXISTANT, REEL ou VIRTUEL). */
# define CREATION_D_UNE_PARTICULE(particule_creee) \
Bblock \
INSERTION_ELEMENT(particule \
,premiere_particule,derniere_particule \
,nombre_instantane_de_particules \
,debordement_de_la_liste_des_particules \
,PARTICULE_NON_DEFINIE \
,SUIVANT,PRECEDENT,VALIDATION \
,particule_creee \
,BLOC(NATURE_D_UNE_PARTICULE(particule_creee,PARTICULE_NAISSANTE);) \
); \
INCR(nombre_total_de_particules,I); \
/* Et comptage global des particules en presence... */ \
Eblock \
/* Creation d'une particule (REELle ou VIRTUELle) a partir d'une particule INEXISTANTe. */
# define DESTRUCTION_D_UNE_PARTICULE(particule_a_detruire) \
Bblock \
DESTRUCTION_ELEMENT(particule \
,premiere_particule,derniere_particule \
,nombre_instantane_de_particules \
,debordement_de_la_liste_des_particules \
,PARTICULE_NON_DEFINIE \
,SUIVANT,PRECEDENT,VALIDATION \
,particule_a_detruire \
,BLOC(Test(IFNE(NATURE(particule_a_detruire),PARTICULE_INEXISTANTE)) \
Bblock \
NATURE_D_UNE_PARTICULE(particule_a_detruire,PARTICULE_INEXISTANTE); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la particule a detruire est INEXISTANT"); \
Eblock \
ETes \
) \
); \
Eblock \
/* Destruction d'une particule... */
# define INITIALISATION_DE_L_ENSEMBLE_DES_PARTICULES \
Bblock \
Eblock \
/* Initialisation de la liste des particules presentes dans le proton (INEXISTANTs). */
#Aifdef FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_02
#Eifdef FACON_DE_GERER_LES_ENSEMBLES_DE_PARTICULES_VERSION_02
#define PARTICULE_COURANTE \
ACCES_PARTICULE(particule_courante) \
/* Definition de la particule courante lors de 'ENSEMBLE_DES_PARTICULES(...)'. */
DEFV(Local,DEFV(Positive,INIT(nombre_maximal_de_particules_dans_le_proton,NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON)));
/* Nombre maximal de particules (quarks et gluons, REELs, VIRTUELs ou"INEXISTANTs") */
/* presentes dans le proton. Il est utilise dans 'AUTO_REGULATION'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* L I M I T A T I O N E V E N T U E L L E D E L A P O P U L A T I O N : */
/* */
/*************************************************************************************************************************************/
#ifdef __VERSION__GENERATION_D_UN_DI_ELECTRON
# define NOMBRE_MAXIMAL_DE_PHOTONS_REELS_DU_DI_ELECTRON \
NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON
DEFV(Local,DEFV(Positive,INIT(nombre_maximal_de_photons_REELs_du_di_electron
,NOMBRE_MAXIMAL_DE_PHOTONS_REELS_DU_DI_ELECTRON
)
)
);
/* Nombre maximal de photons REELs dans un "di-electron" a un instant donne. */
# define NOMBRE_MAXIMAL_DE_PHOTONS_VIRTUELS_DU_DI_ELECTRON \
NOMBRE_MAXIMAL_DE_PARTICULES_DANS_LE_PROTON
DEFV(Local,DEFV(Positive,INIT(nombre_maximal_de_photons_VIRTUELs_du_di_electron
,NOMBRE_MAXIMAL_DE_PHOTONS_VIRTUELS_DU_DI_ELECTRON
)
)
);
/* Nombre maximal de photons VIRTUELs dans un "di-electron" a un instant donne. */
# define NOMBRE_MAXIMAL_DE_Z0S_REELS_DU_DI_ELECTRON \
UN
DEFV(Local,DEFV(Positive,INIT(nombre_maximal_de_z0s_REELs_du_di_electron
,NOMBRE_MAXIMAL_DE_Z0S_REELS_DU_DI_ELECTRON
)
)
);
/* Nombre maximal de z0s REELs dans un "di-electron" a un instant donne. */
# define NOMBRE_MAXIMAL_DE_Z0S_VIRTUELS_DU_DI_ELECTRON \
UN
DEFV(Local,DEFV(Positive,INIT(nombre_maximal_de_z0s_VIRTUELs_du_di_electron
,NOMBRE_MAXIMAL_DE_Z0S_VIRTUELS_DU_DI_ELECTRON
)
)
);
/* Nombre maximal de z0s VIRTUELs dans un "di-electron" a un instant donne. */
#Aifdef __VERSION__GENERATION_D_UN_DI_ELECTRON
#Eifdef __VERSION__GENERATION_D_UN_DI_ELECTRON
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T D E P R E S E N C E D A N S L ' U N I V E R S P O U R U N E P A R T I C U L E : */
/* */
/*************************************************************************************************************************************/
/* Les '..._VERSION_0[12](...)' sont passees de 'define' a 'nodefine' le 20030222110715 */
/* afin de ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#nodefine EXTENSION_DE_L_UNIVERS_VERSION_01(dimension) \
GRO10(FRA8(dimension)) \
/* Afin que l'univers des particules soit superieur a l'univers visible... */
#nodefine EST_HORS_DE_L_UNIVERS_VERSION_01(particule) \
I3OU(IFEXff(COORDONNEES(particule,x) \
,EXTENSION_DE_L_UNIVERS_VERSION_01(ASD2(espace_physique,origine,x)) \
,EXTENSION_DE_L_UNIVERS_VERSION_01(ASD2(espace_physique,extremite,x)) \
) \
,IFEXff(COORDONNEES(particule,y) \
,EXTENSION_DE_L_UNIVERS_VERSION_01(ASD2(espace_physique,origine,y)) \
,EXTENSION_DE_L_UNIVERS_VERSION_01(ASD2(espace_physique,extremite,y)) \
) \
,IFEXff(COORDONNEES(particule,z) \
,EXTENSION_DE_L_UNIVERS_VERSION_01(ASD2(espace_physique,origine,z)) \
,EXTENSION_DE_L_UNIVERS_VERSION_01(ASD2(espace_physique,extremite,z)) \
) \
) \
/* Test verifiant si la particule argument est dans l'univers de la simulation (version 01), */ \
/* l'univers etant donc considere comme parallelepipedique. */
#nodefine EXTENSION_DE_L_UNIVERS_VERSION_02(dimension) \
GRO10(FRA8(dimension)) \
/* Afin que l'univers des particules soit superieur a l'univers visible... */
#nodefine EST_HORS_DE_L_UNIVERS_VERSION_02(particule) \
IFGT(RdisF3D(COORDONNEES(particule,x) \
,COORDONNEES(particule,y) \
,COORDONNEES(particule,z) \
,Xcentre_ESPACE \
,Ycentre_ESPACE \
,Zcentre_ESPACE \
) \
,MOIT(MIN3(SOUA(EXTENSION_DE_L_UNIVERS_VERSION_02(ASD2(espace_physique,extremite,x)) \
,EXTENSION_DE_L_UNIVERS_VERSION_02(ASD2(espace_physique,origine,x)) \
) \
,SOUA(EXTENSION_DE_L_UNIVERS_VERSION_02(ASD2(espace_physique,extremite,y)) \
,EXTENSION_DE_L_UNIVERS_VERSION_02(ASD2(espace_physique,origine,y)) \
) \
,SOUA(EXTENSION_DE_L_UNIVERS_VERSION_02(ASD2(espace_physique,extremite,z)) \
,EXTENSION_DE_L_UNIVERS_VERSION_02(ASD2(espace_physique,origine,z)) \
) \
) \
) \
) \
/* Test verifiant si la particule argument est dans l'univers de la simulation (version 02), */ \
/* l'univers etant donc considere comme une sphere inscrite dans le parallelepipede. */
/* Les '..._VERSION_0[12](...)' sont passees de 'define' a 'nodefine' le 20030222110715 */
/* afin de ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#if ( (defined(__VERSION__GENERATION_D_UN_NUCLEON)) \
|| (defined(__VERSION__GENERATION_D_UN_MESON)) \
|| (defined(__VERSION__GENERATION_DU_VIDE)) \
)
# define EXTENSION_DE_L_UNIVERS_VERSION_03(dimension) \
GRO2(FRA2(dimension)) \
/* Afin que l'univers des particules soit superieur a l'univers visible... */
#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)) \
)
#if (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
# define EXTENSION_DE_L_UNIVERS_VERSION_03(dimension) \
GRO2(FRA1(dimension)) \
/* Afin que l'univers des particules soit superieur a l'univers visible... */
#Aif (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
#Eif (defined(__VERSION__GENERATION_D_UN_DI_ELECTRON))
#define EST_HORS_DE_L_UNIVERS_VERSION_03(particule) \
IFGT(RdisF3D(COORDONNEES(particule,x) \
,COORDONNEES(particule,y) \
,COORDONNEES(particule,z) \
,Xcentre_ESPACE \
,Ycentre_ESPACE \
,Zcentre_ESPACE \
) \
,MOIT(RdisF3D(EXTENSION_DE_L_UNIVERS_VERSION_03(ASD2(espace_physique,origine,x)) \
,EXTENSION_DE_L_UNIVERS_VERSION_03(ASD2(espace_physique,origine,y)) \
,EXTENSION_DE_L_UNIVERS_VERSION_03(ASD2(espace_physique,origine,z)) \
,EXTENSION_DE_L_UNIVERS_VERSION_03(ASD2(espace_physique,extremite,x)) \
,EXTENSION_DE_L_UNIVERS_VERSION_03(ASD2(espace_physique,extremite,y)) \
,EXTENSION_DE_L_UNIVERS_VERSION_03(ASD2(espace_physique,extremite,z)) \
) \
) \
) \
/* Test verifiant si la particule argument est dans l'univers de la simulation (version 03), */ \
/* l'univers etant donc considere comme une sphere circonscrite au parallelepipede. */
#define EST_HORS_DE_L_UNIVERS(particule) \
EST_HORS_DE_L_UNIVERS_VERSION_03(particule) \
/* Test courant verifiant si la particule argument est dans l'univers de la simulation... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E C H E R C H E D E L A P R E M I E R E P A R T I C U L E R E P O N D A N T */
/* A C E R T A I N S C R I T E R E S D A N S L ' E N S E M B L E D E S P A R T I C U L E S : */
/* */
/*************************************************************************************************************************************/
#define RECHERCHE_D_UNE_PARTICULE(particuleR,chercher_particuleR,probabilite_chercher_particuleR,particuleA1,particuleA2,conditions) \
Bblock \
DEFV(Float,INIT(probabilite_d_evenement_collisionnel,FLOT__UNDEF)); \
GENERATION_D_UNE_PROBABILITE_01(probabilite_d_evenement_collisionnel); \
/* Probabilite pour que la rechrche de 'particuleR' ait lieu... */ \
\
EGAL(particuleR,PARTICULE_NON_DEFINIE); \
/* A priori, la particule recherchee 'particuleR' n'existe pas... */ \
\
Test(IFET(IL_FAUT(chercher_particuleR) \
,IFLE(probabilite_d_evenement_collisionnel,REGUL9(probabilite_chercher_particuleR)) \
) \
) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(I3ET(IFEQ(particuleR,PARTICULE_NON_DEFINIE) \
,IFET(IFNE(PARTICULE_COURANTE,particuleA1) \
,IFNE(PARTICULE_COURANTE,particuleA2) \
) \
,conditions \
) \
) \
Bblock \
EGAL(particuleR,PARTICULE_COURANTE); \
/* Memorisation de la premiere particule repondant aux <conditions> et etant differente */ \
/* de la particule 'particuleA'. ATTENTION : dans <conditions> on ne peut utiliser le nom */ \
/* de particule 'particuleR' puiqu'elle est encore indefinie, mais bien plutot le nom de la */ \
/* particule courante 'PARTICULE_COURANTE'... */ \
/* */ \
/* Nota important sur l'aleatoire : en general, 'RECHERCHE_D_UNE_PARTICULE(...)' est */ \
/* destinee a trouver une particule 'particuleR' appartenant au voisinage de la particule */ \
/* 'particuleA' ; pour ce faire, on pourrait creer une liste contenant toutes celles du */ \
/* voisinage, puis a l'interieur, en selectionner une aleatoirement. Or la liste generale */ \
/* des particules peut etre consideree comme contenant l'ensemble des particules dans un */ \
/* ordre aleatoire. En consequence de quoi, prendre comme 'particuleR' la premiere particule */ \
/* satisfaisante dans le voisinage est equivalent a faire une selection aleatoire dans le */ \
/* voisinage... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
ATes \
Bblock \
/* Dans le cas ou la recherche de 'particuleR' n'est pas demandee, cette derniere prend */ \
/* l'etat 'PARTICULE_NON_DEFINIE'... */ \
Eblock \
ETes \
Eblock \
/* Recherche de la premiere particule 'particuleR' differente de 'particuleA1' et de */ \
/* 'particuleA2' et repondant a certaines <conditions>. La "subtilite" dans les arguments */ \
/* ('particuleA1'/'particuleA2') est liee au fait que dans les processus evenementiels, */ \
/* lorsqu'ils sont pris en compte, les particules qui les subissent existent pendant un */ \
/* cours instant sous la forme de deux blocs de donnees (l'ancien et le nouveau...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S P A R T I C U L E S R E E L L E S : */
/* */
/*************************************************************************************************************************************/
#define ATTENTION_EST_CE_UN_QUARK_REEL(quarkD) \
Bblock \
Test(IFEQ(NATURE(quarkD),QUARK_REEL)) \
Bblock \
PRINT_ERREUR("le quark 'quarkD' est REEL et va surement etre detruit"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Passage de l'etat REEL d'un quark qui le possedait (et qui va etre detruit) a un qui */ \
/* va l'acquerir (et qui vient d'etre cree). */
#define ATTENTION_EST_CE_UN_ANTI_QUARK_REEL(anti_quarkD) \
Bblock \
Test(IFEQ(NATURE(anti_quarkD),ANTI_QUARK_REEL)) \
Bblock \
PRINT_ERREUR("l'anti-quark 'anti_quarkD' est REEL et va surement etre detruit"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Passage de l'etat REEL d'un anti-quark qui le possedait (et qui va etre detruit) a un qui */ \
/* va l'acquerir (et qui vient d'etre cree). */
#define CHANGEMENT_DE_QUARK_REEL(quark_REEL,quarkA) \
Bblock \
Test(IFEQ(particule_REELLE_dominante,quark_REEL)) \
Bblock \
EGAL(particule_REELLE_dominante,quarkA); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
EGAL(quark_REEL,quarkA); \
Eblock \
/* Changement d'un quark REEL, et mise a jour de la particule REELLE dominante si */ \
/* necessaire... */
#define CHANGEMENT_D_ANTI_QUARK_REEL(anti_quark_REEL,anti_quarkA) \
Bblock \
Test(IFEQ(particule_REELLE_dominante,anti_quark_REEL)) \
Bblock \
EGAL(particule_REELLE_dominante,anti_quarkA); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
EGAL(anti_quark_REEL,anti_quarkA); \
Eblock \
/* Changement d'un anti-quark REEL, et mise a jour de la particule REELLE dominante si */ \
/* necessaire... */
#define ATTENTION_EST_CE_UN_ELECTRON_REEL(electronD) \
Bblock \
Test(IFEQ(NATURE(electronD),ELECTRON_REEL)) \
Bblock \
PRINT_ERREUR("l'electron 'electronD' est REEL et va surement etre detruit"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Passage de l'etat REEL d'un electron qui le possedait (et qui va etre detruit) a un qui */ \
/* va l'acquerir (et qui vient d'etre cree). */
#define ATTENTION_EST_CE_UN_ANTI_ELECTRON_REEL(anti_electronD) \
Bblock \
Test(IFEQ(NATURE(anti_electronD),ANTI_ELECTRON_REEL)) \
Bblock \
PRINT_ERREUR("l'anti-electron 'anti_electronD' est REEL et va surement etre detruit"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Passage de l'etat REEL d'un anti-electron qui le possedait (et qui va etre detruit) a un */ \
/* qui va l'acquerir (et qui vient d'etre cree). */
#define CHANGEMENT_D_ELECTRON_REEL(electron_REEL,electronA) \
Bblock \
Test(IFEQ(particule_REELLE_dominante,electron_REEL)) \
Bblock \
EGAL(particule_REELLE_dominante,electronA); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
EGAL(electron_REEL,electronA); \
Eblock \
/* Changement d'un electron REEL, et mise a jour de la particule REELLE dominante si */ \
/* necessaire... */
#define CHANGEMENT_D_ANTI_ELECTRON_REEL(anti_electron_REEL,anti_electronA) \
Bblock \
Test(IFEQ(particule_REELLE_dominante,anti_electron_REEL)) \
Bblock \
EGAL(particule_REELLE_dominante,anti_electronA); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
EGAL(anti_electron_REEL,anti_electronA); \
Eblock \
/* Changement d'un anti-electron REEL, et mise a jour de la particule REELLE dominante si */ \
/* necessaire... */
#define ATTENTION_EST_CE_UN_NEUTRINO_REEL(neutrinoD) \
Bblock \
Test(IFEQ(NATURE(neutrinoD),NEUTRINO_REEL)) \
Bblock \
PRINT_ERREUR("le neutrino 'neutrinoD' est REEL et va surement etre detruit"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Passage de l'etat REEL d'un neutrino qui le possedait (et qui va etre detruit) a un qui */ \
/* va l'acquerir (et qui vient d'etre cree). */
#define CHANGEMENT_DE_NEUTRINO_REEL(neutrino_REEL,neutrinoA) \
Bblock \
Test(IFEQ(particule_REELLE_dominante,neutrino_REEL)) \
Bblock \
EGAL(particule_REELLE_dominante,neutrinoA); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
EGAL(neutrino_REEL,neutrinoA); \
Eblock \
/* Changement d'un neutrino REEL, et mise a jour de la particule REELLE dominante si */ \
/* necessaire... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S Q U A R K S ( R E E L S O U V I R T U E L S ) : */
/* */
/*************************************************************************************************************************************/
#define ACCES_QUARK(identite_du_quark_courant) \
ACCES_PARTICULE(identite_du_quark_courant) \
/* Acces a un quark de numero donne dans la liste... */
#define identite_du_quark_courant \
particule_courante \
/* Numero du quark courant... */
#define ENSEMBLE_DES_QUARKS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(quarkD1),QUARK_REEL) \
,IFEQ(NATURE(quarkD1),QUARK_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les quarks REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des quarks REELs ou VIRTUELs. */
#define ENSEMBLE_DES_QUARKS_VIRTUELS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFEQ(NATURE(quarkD1),QUARK_VIRTUEL)) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les quarks VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des quarks VIRTUELs. */
#ifdef __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
# define TOTALITE_DES_QUARKS(sequence) \
Bblock \
ENSEMBLE_DES_QUARKS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des quarks. */
#Aifdef __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
# define TOTALITE_DES_QUARKS(sequence) \
Bblock \
ENSEMBLE_DES_QUARKS_VIRTUELS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des quarks. */
#Eifdef __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
#define CREATION_D_UN_QUARK(quark_cree,nature_du_quark_cree) \
/* 'nature_du_quark_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(quark_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(quark_cree); \
Choi(nature_du_quark_cree) \
Bblock \
Ca1e(QUARK_REEL) \
Bblock \
INCR(nombre_instantane_de_quarks_REELs,I); \
INCR(nombre_total_de_quarks_REELs,I); \
/* Comptage des quarks REELs. */ \
Eblock \
ECa1 \
\
Ca1e(QUARK_VIRTUEL) \
Bblock \
INCR(nombre_instantane_de_quarks_VIRTUELs,I); \
INCR(nombre_total_de_quarks_VIRTUELs,I); \
/* Comptage des quarks VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du quark a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un quark (REEL ou VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_QUARK(quark_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(quark_a_detruire),QUARK_REEL) \
,IFEQ(NATURE(quark_a_detruire),QUARK_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(quark_a_detruire)) \
Bblock \
Ca1e(QUARK_REEL) \
Bblock \
DECR(nombre_instantane_de_quarks_REELs,I); \
/* Decomptage des quarks REELs. */ \
Eblock \
ECa1 \
\
Ca1e(QUARK_VIRTUEL) \
Bblock \
DECR(nombre_instantane_de_quarks_VIRTUELs,I); \
/* Decomptage des quarks VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du quark a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(quark_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'quark_a_detruire' n'est ni 'QUARK REEL' ni 'QUARK VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un quark (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_QUARKS \
Bblock \
ENSEMBLE_DES_QUARKS(BLOC(VISUALISATION_D_UN_QUARK(quarkD1););); \
/* Et visualisation du quark... */ \
Eblock \
/* Visualisation de la liste des quarks presents dans le proton (REELs ou VIRTUELs). */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_QUARKS \
Bblock \
TOTALITE_DES_QUARKS(BLOC(DEPLACEMENT_D_UN_QUARK(quarkD1); \
/* Deplacement du quark... */ \
Test(EST_HORS_DE_L_UNIVERS(quarkD1)) \
Bblock \
ATTENTION_EST_CE_UN_QUARK_REEL(quarkD1); \
DESTRUCTION_D_UN_QUARK(quarkD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS Q(%d) --> VIDE" \
,ETIQUETTE(quarkD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des quarks presents dans le proton (REELs ou VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_QUARKS,Q,___DEPLACEMENT_DE_L_ENSEMBLE_DES_QUARKS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S A N T I - Q U A R K S R E E L S O U V I R T U E L S : */
/* */
/*************************************************************************************************************************************/
#define ACCES_ANTI_QUARK(identite_de_l_anti_quark_courant) \
ACCES_PARTICULE(identite_de_l_anti_quark_courant) \
/* Acces a un anti-quark de numero donne dans la liste... */
#define identite_de_l_anti_quark_courant \
particule_courante \
/* Numero de l'anti-quark courant... */
#define ENSEMBLE_DES_ANTI_QUARKS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(anti_quarkD1),ANTI_QUARK_REEL) \
,IFEQ(NATURE(anti_quarkD1),ANTI_QUARK_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les anti-quarks REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des anti-quarks REELs ou VIRTUELs. */
#define ENSEMBLE_DES_ANTI_QUARKS_VIRTUELS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFEQ(NATURE(anti_quarkD1),ANTI_QUARK_VIRTUEL)) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les anti-quarks VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des anti-quarks VIRTUELs. */
#ifdef __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
# define TOTALITE_DES_ANTI_QUARKS(sequence) \
Bblock \
ENSEMBLE_DES_ANTI_QUARKS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des quarks. */
#Aifdef __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
# define TOTALITE_DES_ANTI_QUARKS(sequence) \
Bblock \
ENSEMBLE_DES_ANTI_QUARKS_VIRTUELS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des quarks. */
#Eifdef __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
#define CREATION_D_UN_ANTI_QUARK(anti_quark_cree,nature_de_l_anti_quark_cree) \
/* 'nature_de_l_anti_quark_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(anti_quark_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(anti_quark_cree); \
Choi(nature_de_l_anti_quark_cree) \
Bblock \
Ca1e(ANTI_QUARK_REEL) \
Bblock \
INCR(nombre_instantane_d_anti_quarks_REELs,I); \
INCR(nombre_total_d_anti_quarks_REELs,I); \
/* Comptage des anti-quarks REELs. */ \
Eblock \
ECa1 \
\
Ca1e(ANTI_QUARK_VIRTUEL) \
Bblock \
INCR(nombre_instantane_d_anti_quarks_VIRTUELs,I); \
INCR(nombre_total_d_anti_quarks_VIRTUELs,I); \
/* Comptage des anti-quarks VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature de l'anti-quark a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un anti-quark (REEL ou VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_ANTI_QUARK(anti_quark_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(anti_quark_a_detruire),ANTI_QUARK_REEL) \
,IFEQ(NATURE(anti_quark_a_detruire),ANTI_QUARK_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(anti_quark_a_detruire)) \
Bblock \
Ca1e(ANTI_QUARK_REEL) \
Bblock \
DECR(nombre_instantane_d_anti_quarks_REELs,I); \
/* Decomptage des anti-quarks REELs. */ \
Eblock \
ECa1 \
\
Ca1e(ANTI_QUARK_VIRTUEL) \
Bblock \
DECR(nombre_instantane_d_anti_quarks_VIRTUELs,I); \
/* Decomptage des anti-quarks VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature de l'anti-quark a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(anti_quark_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'anti_quark_a_detruire' n'est ni 'ANTI-QUARK REEL' ni 'ANTI-QUARK VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un anti-quark (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_ANTI_QUARKS \
Bblock \
ENSEMBLE_DES_ANTI_QUARKS(BLOC(VISUALISATION_D_UN_ANTI_QUARK(anti_quarkD1););); \
/* Et visualisation de l'anti-quark... */ \
Eblock \
/* Visualisation de la liste des anti-quarks presents dans le proton (REELs ou VIRTUELs). */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_ANTI_QUARKS \
Bblock \
TOTALITE_DES_ANTI_QUARKS(BLOC(DEPLACEMENT_D_UN_ANTI_QUARK(anti_quarkD1); \
/* Deplacement du anti-quark... */ \
Test(EST_HORS_DE_L_UNIVERS(anti_quarkD1)) \
Bblock \
DESTRUCTION_D_UN_ANTI_QUARK(anti_quarkD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS AQ(%d) --> VIDE" \
,ETIQUETTE(anti_quarkD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des anti-quarks presents dans le proton (REELs ou VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_ANTI_QUARKS,AQ,___DEPLACEMENT_DE_L_ENSEMBLE_DES_ANTI_QUARKS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S G L U O N S ( V I R T U E L S ) : */
/* */
/*************************************************************************************************************************************/
#define ACCES_GLUON(identite_du_gluon_courant) \
ACCES_PARTICULE(identite_du_gluon_courant) \
/* Acces a un gluon de numero donne dans la liste... */
#define identite_du_gluon_courant \
particule_courante \
/* Numero du gluon courant... */
#define ENSEMBLE_DES_GLUONS_EXISTANTS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(gluonD1),GLUON_REEL) \
,IFEQ(NATURE(gluonD1),GLUON_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les etats gluons REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des gluons (REELs ou VIRTUELs). */
#define CREATION_D_UN_GLUON(gluon_cree,nature_du_gluon_cree) \
/* 'nature_du_gluon_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(gluon_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(gluon_cree); \
Choi(nature_du_gluon_cree) \
Bblock \
Ca1e(GLUON_REEL) \
Bblock \
INCR(nombre_instantane_de_gluons_REELs,I); \
INCR(nombre_total_de_gluons_REELs,I); \
/* Comptage des gluons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(GLUON_VIRTUEL) \
Bblock \
INCR(nombre_instantane_de_gluons_VIRTUELs,I); \
INCR(nombre_total_de_gluons_VIRTUELs,I); \
/* Comptage des gluons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du gluon a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un gluon (VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_GLUON(gluon_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(gluon_a_detruire),GLUON_REEL) \
,IFEQ(NATURE(gluon_a_detruire),GLUON_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(gluon_a_detruire)) \
Bblock \
Ca1e(GLUON_REEL) \
Bblock \
DECR(nombre_instantane_de_gluons_REELs,I); \
/* Decomptage des gluons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(GLUON_VIRTUEL) \
Bblock \
DECR(nombre_instantane_de_gluons_VIRTUELs,I); \
/* Decomptage des gluons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du gluon a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(gluon_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'gluon_a_detruire' n'est ni 'GLUON REEL' ni 'GLUON VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un gluon (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_GLUONS \
Bblock \
ENSEMBLE_DES_GLUONS_EXISTANTS(BLOC(VISUALISATION_D_UN_GLUON(gluonD1););); \
/* Et visualisation du gluon... */ \
Eblock \
/* Visualisation de la liste des gluons presents dans le proton. */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_GLUONS \
Bblock \
ENSEMBLE_DES_GLUONS_EXISTANTS(BLOC(DEPLACEMENT_D_UN_GLUON(gluonD1); \
/* Deplacement du gluon... */ \
Test(EST_HORS_DE_L_UNIVERS(gluonD1)) \
Bblock \
DESTRUCTION_D_UN_GLUON(gluonD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS G(%d) --> VIDE" \
,ETIQUETTE(gluonD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des gluons presents dans le proton (VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_GLUONS,G,___DEPLACEMENT_DE_L_ENSEMBLE_DES_GLUONS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S E L E C T R O N S */
/* R E E L S O U V I R T U E L S : */
/* */
/*************************************************************************************************************************************/
#define ACCES_ELECTRON(identite_de_l_electron_courant) \
ACCES_PARTICULE(identite_de_l_electron_courant) \
/* Acces a un electron de numero donne dans la liste... */
#define identite_de_l_electron_courant \
particule_courante \
/* Numero de l'electron courant... */
#define ENSEMBLE_DES_ELECTRONS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(electronD1),ELECTRON_REEL) \
,IFEQ(NATURE(electronD1),ELECTRON_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les electrons REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des electrons REELs ou VIRTUELs. */
#define ENSEMBLE_DES_ELECTRONS_VIRTUELS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFEQ(NATURE(electronD1),ELECTRON_VIRTUEL)) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les electrons VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des electrons VIRTUELs. */
#define TOTALITE_DES_ELECTRONS(sequence) \
Bblock \
ENSEMBLE_DES_ELECTRONS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des */ \
/* electrons. */
#define CREATION_D_UN_ELECTRON(electron_cree,nature_de_l_electron_cree) \
/* 'nature_de_l_electron_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(electron_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(electron_cree); \
Choi(nature_de_l_electron_cree) \
Bblock \
Ca1e(ELECTRON_REEL) \
Bblock \
INCR(nombre_instantane_d_electrons_REELs,I); \
INCR(nombre_total_d_electrons_REELs,I); \
/* Comptage des electrons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(ELECTRON_VIRTUEL) \
Bblock \
INCR(nombre_instantane_d_electrons_VIRTUELs,I); \
INCR(nombre_total_d_electrons_VIRTUELs,I); \
/* Comptage des electrons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature de l'electron a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un electron (REEL ou VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_ELECTRON(electron_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(electron_a_detruire),ELECTRON_REEL) \
,IFEQ(NATURE(electron_a_detruire),ELECTRON_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(electron_a_detruire)) \
Bblock \
Ca1e(ELECTRON_REEL) \
Bblock \
DECR(nombre_instantane_d_electrons_REELs,I); \
/* Decomptage des electrons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(ELECTRON_VIRTUEL) \
Bblock \
DECR(nombre_instantane_d_electrons_VIRTUELs,I); \
/* Decomptage des electrons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature de l'electron a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(electron_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'electron_a_detruire' n'est ni 'ELECTRON REEL' ni 'ELECTRON VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un electron (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_ELECTRONS \
Bblock \
ENSEMBLE_DES_ELECTRONS(BLOC(VISUALISATION_D_UN_ELECTRON(electronD1););); \
/* Et visualisation de l'electron. */ \
Eblock \
/* Visualisation de la liste des electrons presents dans le proton (REELs ou VIRTUELs). */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_ELECTRONS \
Bblock \
TOTALITE_DES_ELECTRONS(BLOC(DEPLACEMENT_D_UN_ELECTRON(electronD1); \
/* Deplacement de l'electron. */ \
Test(EST_HORS_DE_L_UNIVERS(electronD1)) \
Bblock \
ATTENTION_EST_CE_UN_ELECTRON_REEL(electronD1); \
DESTRUCTION_D_UN_ELECTRON(electronD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS E(%d) --> VIDE" \
,ETIQUETTE(electronD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des electrons presents dans le proton (REELs ou VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_ELECTRONS,Q,___DEPLACEMENT_DE_L_ENSEMBLE_DES_ELECTRONS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S A N T I - E L E C T R O N S */
/* R E E L S O U V I R T U E L S : */
/* */
/*************************************************************************************************************************************/
#define ACCES_ANTI_ELECTRON(identite_de_l_anti_electron_courant) \
ACCES_PARTICULE(identite_de_l_anti_electron_courant) \
/* Acces a un anti-electron de numero donne dans la liste... */
#define identite_de_l_anti_electron_courant \
particule_courante \
/* Numero de l'anti-electron courant... */
#define ENSEMBLE_DES_ANTI_ELECTRONS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(anti_electronD1),ANTI_ELECTRON_REEL) \
,IFEQ(NATURE(anti_electronD1),ANTI_ELECTRON_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les anti-electrons REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des anti-electrons REELs ou VIRTUELs. */
#define ENSEMBLE_DES_ANTI_ELECTRONS_VIRTUELS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFEQ(NATURE(anti_electronD1),ANTI_ELECTRON_VIRTUEL)) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les anti-electrons VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des anti-electrons VIRTUELs. */
#define TOTALITE_DES_ANTI_ELECTRONS(sequence) \
Bblock \
ENSEMBLE_DES_ANTI_ELECTRONS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des */
/* electrons. */
#define CREATION_D_UN_ANTI_ELECTRON(anti_electron_cree,nature_de_l_anti_electron_cree) \
/* 'nature_de_l_anti_electron_cree' a ete introduit pour permettre le comptage des */ \
/* particules, mais, ne modifie pas 'NATURE(anti_electron_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(anti_electron_cree); \
Choi(nature_de_l_anti_electron_cree) \
Bblock \
Ca1e(ANTI_ELECTRON_REEL) \
Bblock \
INCR(nombre_instantane_d_anti_electrons_REELs,I); \
INCR(nombre_total_d_anti_electrons_REELs,I); \
/* Comptage des anti-electrons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(ANTI_ELECTRON_VIRTUEL) \
Bblock \
INCR(nombre_instantane_d_anti_electrons_VIRTUELs,I); \
INCR(nombre_total_d_anti_electrons_VIRTUELs,I); \
/* Comptage des anti-electrons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature de l'anti-electron a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un anti-electron (REEL ou VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_ANTI_ELECTRON(anti_electron_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(anti_electron_a_detruire),ANTI_ELECTRON_REEL) \
,IFEQ(NATURE(anti_electron_a_detruire),ANTI_ELECTRON_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(anti_electron_a_detruire)) \
Bblock \
Ca1e(ANTI_ELECTRON_REEL) \
Bblock \
DECR(nombre_instantane_d_anti_electrons_REELs,I); \
/* Decomptage des anti-electrons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(ANTI_ELECTRON_VIRTUEL) \
Bblock \
DECR(nombre_instantane_d_anti_electrons_VIRTUELs,I); \
/* Decomptage des anti-electrons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature de l'anti-electron a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(anti_electron_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'anti_electron_a_detruire' n'est ni 'ANTI-ELECTRON REEL' ni 'ANTI-ELECTRON VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un anti-electron (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_ANTI_ELECTRONS \
Bblock \
ENSEMBLE_DES_ANTI_ELECTRONS(BLOC(VISUALISATION_D_UN_ANTI_ELECTRON(anti_electronD1););); \
/* Et visualisation de l'anti-electron... */ \
Eblock \
/* Visualisation de la liste des anti-electrons presents dans le proton (REELs ou VIRTUELs). */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_ANTI_ELECTRONS \
Bblock \
TOTALITE_DES_ANTI_ELECTRONS(BLOC(DEPLACEMENT_D_UN_ANTI_ELECTRON(anti_electronD1); \
/* Deplacement du anti-electron... */ \
Test(EST_HORS_DE_L_UNIVERS(anti_electronD1)) \
Bblock \
DESTRUCTION_D_UN_ANTI_ELECTRON(anti_electronD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS AE(%d) --> VIDE" \
,ETIQUETTE(anti_electronD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des anti-electrons presents dans le proton (REELs ou VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_ANTI_ELECTRONS,AQ,___DEPLACEMENT_DE_L_ENSEMBLE_DES_ANTI_ELECTRONS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S N E U T R I N O S : */
/* */
/*************************************************************************************************************************************/
#define ACCES_NEUTRINO(identite_du_neutrino_courant) \
ACCES_PARTICULE(identite_du_neutrino_courant) \
/* Acces a un neutrino de numero donne dans la liste... */
#define identite_du_neutrino_courant \
particule_courante \
/* Numero du neutrino courant... */
#define ENSEMBLE_DES_NEUTRINOS_EXISTANTS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(neutrinoD1),NEUTRINO_REEL) \
,IFEQ(NATURE(neutrinoD1),NEUTRINO_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les etats neutrinos REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des neutrinos (REELs ou VIRTUELs). */
#define TOTALITE_DES_NEUTRINOS(sequence) \
Bblock \
ENSEMBLE_DES_NEUTRINOS_EXISTANTS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des */
/* neutrinos. */
#define CREATION_D_UN_NEUTRINO(neutrino_cree,nature_du_neutrino_cree) \
/* 'nature_du_neutrino_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(neutrino_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(neutrino_cree); \
Choi(nature_du_neutrino_cree) \
Bblock \
Ca1e(NEUTRINO_REEL) \
Bblock \
INCR(nombre_instantane_de_neutrinos_REELs,I); \
INCR(nombre_total_de_neutrinos_REELs,I); \
/* Comptage des neutrinos REELs. */ \
Eblock \
ECa1 \
\
Ca1e(NEUTRINO_VIRTUEL) \
Bblock \
INCR(nombre_instantane_de_neutrinos_VIRTUELs,I); \
INCR(nombre_total_de_neutrinos_VIRTUELs,I); \
/* Comptage des neutrinos VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du neutrino a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un neutrino (VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_NEUTRINO(neutrino_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(neutrino_a_detruire),NEUTRINO_REEL) \
,IFEQ(NATURE(neutrino_a_detruire),NEUTRINO_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(neutrino_a_detruire)) \
Bblock \
Ca1e(NEUTRINO_REEL) \
Bblock \
DECR(nombre_instantane_de_neutrinos_REELs,I); \
/* Decomptage des neutrinos REELs. */ \
Eblock \
ECa1 \
\
Ca1e(NEUTRINO_VIRTUEL) \
Bblock \
DECR(nombre_instantane_de_neutrinos_VIRTUELs,I); \
/* Decomptage des neutrinos VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du neutrino a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(neutrino_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'neutrino_a_detruire' n'est ni 'NEUTRINO REEL' ni 'NEUTRINO VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un neutrino (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_NEUTRINOS \
Bblock \
ENSEMBLE_DES_NEUTRINOS_EXISTANTS(BLOC(VISUALISATION_D_UN_NEUTRINO(neutrinoD1););); \
/* Et visualisation du neutrino... */ \
Eblock \
/* Visualisation de la liste des neutrinos presents dans le proton. */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_NEUTRINOS \
Bblock \
ENSEMBLE_DES_NEUTRINOS_EXISTANTS(BLOC(DEPLACEMENT_D_UN_NEUTRINO(neutrinoD1); \
/* Deplacement du neutrino... */ \
Test(EST_HORS_DE_L_UNIVERS(neutrinoD1)) \
Bblock \
DESTRUCTION_D_UN_NEUTRINO(neutrinoD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS N(%d) --> VIDE" \
,ETIQUETTE(neutrinoD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des neutrinos presents dans le proton (VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_NEUTRINOS,G,___DEPLACEMENT_DE_L_ENSEMBLE_DES_NEUTRINOS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S P H O T O N S ( V I R T U E L S ) : */
/* */
/*************************************************************************************************************************************/
#define ACCES_PHOTON(identite_du_photon_courant) \
ACCES_PARTICULE(identite_du_photon_courant) \
/* Acces a un photon de numero donne dans la liste... */
#define identite_du_photon_courant \
particule_courante \
/* Numero du photon courant... */
#define ENSEMBLE_DES_PHOTONS_EXISTANTS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(photonD1),PHOTON_REEL) \
,IFEQ(NATURE(photonD1),PHOTON_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les etats photons REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des photons (REELs ou VIRTUELs). */
#define TOTALITE_DES_PHOTONS(sequence) \
Bblock \
ENSEMBLE_DES_PHOTONS_EXISTANTS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des */
/* photons. */
#define CREATION_D_UN_PHOTON(photon_cree,nature_du_photon_cree) \
/* 'nature_du_photon_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(photon_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(photon_cree); \
Choi(nature_du_photon_cree) \
Bblock \
Ca1e(PHOTON_REEL) \
Bblock \
INCR(nombre_instantane_de_photons_REELs,I); \
INCR(nombre_total_de_photons_REELs,I); \
/* Comptage des photons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(PHOTON_VIRTUEL) \
Bblock \
INCR(nombre_instantane_de_photons_VIRTUELs,I); \
INCR(nombre_total_de_photons_VIRTUELs,I); \
/* Comptage des photons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du photon a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un photon (VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_PHOTON(photon_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(photon_a_detruire),PHOTON_REEL) \
,IFEQ(NATURE(photon_a_detruire),PHOTON_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(photon_a_detruire)) \
Bblock \
Ca1e(PHOTON_REEL) \
Bblock \
DECR(nombre_instantane_de_photons_REELs,I); \
/* Decomptage des photons REELs. */ \
Eblock \
ECa1 \
\
Ca1e(PHOTON_VIRTUEL) \
Bblock \
DECR(nombre_instantane_de_photons_VIRTUELs,I); \
/* Decomptage des photons VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du photon a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(photon_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'photon_a_detruire' n'est ni 'PHOTON REEL' ni 'PHOTON VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un photon (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_PHOTONS \
Bblock \
ENSEMBLE_DES_PHOTONS_EXISTANTS(BLOC(VISUALISATION_D_UN_PHOTON(photonD1););); \
/* Et visualisation du photon... */ \
Eblock \
/* Visualisation de la liste des photons presents dans le proton. */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_PHOTONS \
Bblock \
ENSEMBLE_DES_PHOTONS_EXISTANTS(BLOC(DEPLACEMENT_D_UN_PHOTON(photonD1); \
/* Deplacement du photon... */ \
Test(EST_HORS_DE_L_UNIVERS(photonD1)) \
Bblock \
DESTRUCTION_D_UN_PHOTON(photonD1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS P(%d) --> VIDE" \
,ETIQUETTE(photonD1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des photons presents dans le proton (VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_PHOTONS,G,___DEPLACEMENT_DE_L_ENSEMBLE_DES_PHOTONS))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E N S E M B L E D E S Z 0 : */
/* */
/*************************************************************************************************************************************/
#define ACCES_Z0(identite_du_z0_courant) \
ACCES_PARTICULE(identite_du_z0_courant) \
/* Acces a un z0 de numero donne dans la liste... */
#define identite_du_z0_courant \
particule_courante \
/* Numero du z0 courant... */
#define ENSEMBLE_DES_Z0S_EXISTANTS(sequence) \
Bblock \
ENSEMBLE_DES_PARTICULES(BLOC(Test(IFOU(IFEQ(NATURE(z0D1),Z0_REEL) \
,IFEQ(NATURE(z0D1),Z0_VIRTUEL) \
) \
) \
Bblock \
BLOC(sequence); \
/* Execution de la sequence argument uniquement sur les etats z0s REELs ou VIRTUELs. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Repetition d'une certaine sequence sur l'ensemble des z0s (REELs ou VIRTUELs). */
#define TOTALITE_DES_Z0S(sequence) \
Bblock \
ENSEMBLE_DES_Z0S_EXISTANTS(sequence); \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble (eventuellement partiel) des */
/* z0s. */
#define CREATION_D_UN_Z0(z0_cree,nature_du_z0_cree) \
/* 'nature_du_z0_cree' a ete introduit pour permettre le comptage des particules, */ \
/* mais, ne modifie pas 'NATURE(z0_cree)'... */ \
Bblock \
CREATION_D_UNE_PARTICULE(z0_cree); \
Choi(nature_du_z0_cree) \
Bblock \
Ca1e(Z0_REEL) \
Bblock \
INCR(nombre_instantane_de_z0s_REELs,I); \
INCR(nombre_total_de_z0s_REELs,I); \
/* Comptage des z0s REELs. */ \
Eblock \
ECa1 \
\
Ca1e(Z0_VIRTUEL) \
Bblock \
INCR(nombre_instantane_de_z0s_VIRTUELs,I); \
INCR(nombre_total_de_z0s_VIRTUELs,I); \
/* Comptage des z0s VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du z0 a creer n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
/* Creation d'un z0 (VIRTUEL) a partir d'une particule INEXISTANTe. */
#define DESTRUCTION_D_UN_Z0(z0_a_detruire) \
Bblock \
Test(IFOU(IFEQ(NATURE(z0_a_detruire),Z0_REEL) \
,IFEQ(NATURE(z0_a_detruire),Z0_VIRTUEL) \
) \
) \
Bblock \
Choi(NATURE(z0_a_detruire)) \
Bblock \
Ca1e(Z0_REEL) \
Bblock \
DECR(nombre_instantane_de_z0s_REELs,I); \
/* Decomptage des z0s REELs. */ \
Eblock \
ECa1 \
\
Ca1e(Z0_VIRTUEL) \
Bblock \
DECR(nombre_instantane_de_z0s_VIRTUELs,I); \
/* Decomptage des z0s VIRTUELs. */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la nature du z0 a detruire n'est pas reconnue"); \
Eblock \
EDef \
Eblock \
ECho \
DESTRUCTION_D_UNE_PARTICULE(z0_a_detruire); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'z0_a_detruire' n'est ni 'Z0 REEL' ni 'Z0 VIRTUEL'"); \
Eblock \
ETes \
Eblock \
/* Destruction d'un z0 (REEL ou VIRTUEL). */
#define VISUALISATION_DE_L_ENSEMBLE_DES_Z0S \
Bblock \
ENSEMBLE_DES_Z0S_EXISTANTS(BLOC(VISUALISATION_D_UN_Z0(z0D1););); \
/* Et visualisation du z0... */ \
Eblock \
/* Visualisation de la liste des z0s presents dans le proton. */
#define ___DEPLACEMENT_DE_L_ENSEMBLE_DES_Z0S \
Bblock \
ENSEMBLE_DES_Z0S_EXISTANTS(BLOC(DEPLACEMENT_D_UN_Z0(z0D1); \
/* Deplacement du z0... */ \
Test(EST_HORS_DE_L_UNIVERS(z0D1)) \
Bblock \
DESTRUCTION_D_UN_Z0(z0D1); \
/* Et sa destruction s'il sort de l'univers de la simulation... */ \
TRACE_D_UN_EVENEMENT(Prin1("SORTIE DE L'UNIVERS Z(%d) --> VIDE" \
,ETIQUETTE(z0D1) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
/* Deplacement de la liste des z0s presents dans le proton (VIRTUELs). */
BFonctionI
DEFV(LoF,GENERE__Fonction__OPT(DEPLACEMENT_DE_L_ENSEMBLE_DES_Z0S,G,___DEPLACEMENT_DE_L_ENSEMBLE_DES_Z0S))
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S D I F F E R E N T S E V E N E M E N T S */
/* D A N S L A V I E D E S P A R T I C U L E S : */
/* */
/* */
/* Notations : */
/* */
/* V Vide, */
/* */
/* Q Quark, */
/* */
/* AQ Anti-Quark, */
/* */
/* G Gluon, */
/* */
/* ___ -->, */
/* */
/* x "union" ou ".". */
/* */
/*************************************************************************************************************************************/
#define EDITER_LES_MESSAGES_DES_PROCESSUS_INCOMPLETS \
VRAI
DEFV(Local,DEFV(Logical,INIT(editer_les_messages_des_processus_incomplets,EDITER_LES_MESSAGES_DES_PROCESSUS_INCOMPLETS)));
/* Indique s'il faut ('VRAI') ou pas ('FAUX') editer les messages relatifs aux processus */
/* encore incomplets dans 'PROCESSUS_INCOMPLET(...)'. */
#define PROCESSUS_INCOMPLET(message) \
Bblock \
Test(IL_FAUT(editer_les_messages_des_processus_incomplets)) \
Bblock \
SEQUENCE_INCOMPLETE(message); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Sequence destinee a montrer quels sont les processus encore incomplets, et permettant */ \
/* donc de faciliter le "prototypage"... */
#define CREATION_D_UN_QUARK_VIRTUEL(quark,qs,position_initiale,vitesse_initiale,qr,qv,qb) \
Bblock \
DEFINITION_D_UN_QUARK_VIRTUEL(quark,qs,position_initiale,vitesse_initiale,qr,qv,qb); \
/* Initialisation a priori du quark courant... */ \
Eblock \
/* Creation et initialisation d'un quark VIRTUEL. */
#define DESTRUCTION_D_UN_QUARK_VIRTUEL(quark) \
Bblock \
Test(IFEQ(NATURE(quark),QUARK_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_QUARK(quark); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'quark' a detruire n'est pas 'QUARK VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un quark VIRTUEL... */ \
Eblock \
/* Destruction d'un quark VIRTUEL... */
#define CREATION_D_UN_ANTI_QUARK_VIRTUEL(anti_quark,qs,position_initiale,vitesse_initiale,qr,qv,qb) \
Bblock \
DEFINITION_D_UN_ANTI_QUARK_VIRTUEL(anti_quark,qs,position_initiale,vitesse_initiale,qr,qv,qb); \
/* Initialisation a priori de l'anti-quark courant... */ \
Eblock \
/* Creation et initialisation d'un anti-quark VIRTUEL. */
#define DESTRUCTION_D_UN_ANTI_QUARK_VIRTUEL(anti_quark) \
Bblock \
Test(IFEQ(NATURE(anti_quark),ANTI_QUARK_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_ANTI_QUARK(anti_quark); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'anti_quark' a detruire n'est pas 'ANTI-QUARK VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un anti-quark VIRTUEL... */ \
Eblock \
/* Destruction d'un anti-quark VIRTUEL... */
#define CREATION_D_UN_GLUON_VIRTUEL(gluon,position_initiale,vitesse_initiale,gr,gv,gb) \
Bblock \
DEFINITION_D_UN_GLUON_VIRTUEL(gluon,position_initiale,vitesse_initiale,gr,gv,gb); \
/* Initialisation a priori du gluon courant... */ \
Eblock \
/* Creation et initialisation d'un gluon VIRTUEL. */
#define DESTRUCTION_D_UN_GLUON_VIRTUEL(gluon) \
Bblock \
Test(IFEQ(NATURE(gluon),GLUON_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_GLUON(gluon); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'gluon' a detruire n'est pas 'GLUON VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un gluon VIRTUEL... */ \
Eblock \
/* Destruction d'un gluon VIRTUEL... */
#define CREATION_D_UN_ELECTRON_VIRTUEL(electron,es,position_initiale,vitesse_initiale) \
Bblock \
DEFINITION_D_UN_ELECTRON_VIRTUEL(electron,es,position_initiale,vitesse_initiale); \
/* Initialisation a priori de l'electron courant... */ \
Eblock \
/* Creation et initialisation d'un electron VIRTUEL. */
#define DESTRUCTION_D_UN_ELECTRON_VIRTUEL(electron) \
Bblock \
Test(IFEQ(NATURE(electron),ELECTRON_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_ELECTRON(electron); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'electron' a detruire n'est pas 'ELECTRON VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un electron VIRTUEL... */ \
Eblock \
/* Destruction d'un electron VIRTUEL... */
#define CREATION_D_UN_ANTI_ELECTRON_VIRTUEL(anti_electron,es,position_initiale,vitesse_initiale) \
Bblock \
DEFINITION_D_UN_ANTI_ELECTRON_VIRTUEL(anti_electron,es,position_initiale,vitesse_initiale); \
/* Initialisation a priori de l'anti-electron courant... */ \
Eblock \
/* Creation et initialisation d'un anti-electron VIRTUEL. */
#define DESTRUCTION_D_UN_ANTI_ELECTRON_VIRTUEL(anti_electron) \
Bblock \
Test(IFEQ(NATURE(anti_electron),ANTI_ELECTRON_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_ANTI_ELECTRON(anti_electron); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'anti_electron' a detruire n'est pas 'ANTI-ELECTRON VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un anti-electron VIRTUEL... */ \
Eblock \
/* Destruction d'un anti-electron VIRTUEL... */
#define CREATION_D_UN_NEUTRINO_VIRTUEL(neutrino,ns,position_initiale,vitesse_initiale) \
Bblock \
DEFINITION_D_UN_NEUTRINO_VIRTUEL(neutrino,ns,position_initiale,vitesse_initiale); \
/* Initialisation a priori du neutrino courant... */ \
Eblock \
/* Creation et initialisation d'un neutrino VIRTUEL. */
#define DESTRUCTION_D_UN_NEUTRINO_VIRTUEL(neutrino) \
Bblock \
Test(IFEQ(NATURE(neutrino),NEUTRINO_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_NEUTRINO(neutrino); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'neutrino' a detruire n'est pas 'NEUTRINO VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un neutrino VIRTUEL... */ \
Eblock \
/* Destruction d'un neutrino VIRTUEL... */
#define CREATION_D_UN_PHOTON_VIRTUEL(photon,position_initiale,vitesse_initiale) \
Bblock \
DEFINITION_D_UN_PHOTON_VIRTUEL(photon,position_initiale,vitesse_initiale); \
/* Initialisation a priori du photon courant... */ \
Eblock \
/* Creation et initialisation d'un photon VIRTUEL. */
#define DESTRUCTION_D_UN_PHOTON_VIRTUEL(photon) \
Bblock \
Test(IFEQ(NATURE(photon),PHOTON_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_PHOTON(photon); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'photon' a detruire n'est pas 'PHOTON VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un photon VIRTUEL... */ \
Eblock \
/* Destruction d'un photon VIRTUEL... */
#define CREATION_D_UN_Z0_VIRTUEL(z0,position_initiale,vitesse_initiale) \
Bblock \
DEFINITION_D_UN_Z0_VIRTUEL(z0,position_initiale,vitesse_initiale); \
/* Initialisation a priori du z0 courant... */ \
Eblock \
/* Creation et initialisation d'un z0 VIRTUEL. */
#define DESTRUCTION_D_UN_Z0_VIRTUEL(z0) \
Bblock \
Test(IFEQ(NATURE(z0),Z0_VIRTUEL)) \
Bblock \
DESTRUCTION_D_UN_Z0(z0); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("'z0' a detruire n'est pas 'Z0 VIRTUEL'"); \
Eblock \
ETes \
/* Destruction d'un z0 VIRTUEL... */ \
Eblock \
/* Destruction d'un z0 VIRTUEL... */