/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N S   D U   " D I - E L E C T R O N "  :                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrq/di_elec.L6$I' :                                                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 1994??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   " D I - E L E C T R O N "   A   P A R T I R                                                    */
/*        D ' U N E   P A I R E   D ' E L E C T R O N S   E T   D ' U N   N E U T R I N O  :                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   INITIALISER_AVEC_L_ELECTRON_1_REEL                                                                                            \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(initialiser_avec_l_electron_1_REEL,INITIALISER_AVEC_L_ELECTRON_1_REEL)));
                                        /* Faut-il initialiser avec l'electron 1 REEL ('VRAI') ou un pas ('FAUX').                   */
#define   INITIALISER_AVEC_L_ELECTRON_2_REEL                                                                                            \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(initialiser_avec_l_electron_2_REEL,INITIALISER_AVEC_L_ELECTRON_2_REEL)));
                                        /* Faut-il initialiser avec l'electron 2 REEL ('VRAI') ou un pas ('FAUX').                   */

#define   INITIALISER_AVEC_L_ANTI_ELECTRON_REEL                                                                                         \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(initialiser_avec_l_anti_electron_REEL,INITIALISER_AVEC_L_ANTI_ELECTRON_REEL)));
                                        /* Faut-il initialiser avec l'anti-electron REEL ('VRAI') ou un pas ('FAUX').                */

#define   INITIALISER_AVEC_LE_NEUTRINO_REEL                                                                                             \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(initialiser_avec_le_neutrino_REEL,INITIALISER_AVEC_LE_NEUTRINO_REEL)));
                                        /* Faut-il initialiser avec le neutrino REEL ('VRAI') ou un pas ('FAUX').                    */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   P A I R E   D ' E L E C T R O N S  :                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_D_ELECTRONS_DANS_LE_DI_ELECTRON                                                                                        \
                    DEUX                                                                                                                \
                                        /* Nombre d'electrons contenus dans le "di-electron"...                                      */

#define   _VX_electron_1_REEL                                                                                                           \
                    GRO1(FRA1(FRA6(VITESSE_DE_LA_LUMIERE)))
#define   _VY_electron_1_REEL                                                                                                           \
                    GRO1(FRA2(FRA16(VITESSE_DE_LA_LUMIERE)))
#define   _VZ_electron_1_REEL                                                                                                           \
                    FZERO
                                        /* Definition de la vitesse des deux electrons. ATTENTION, on notera que cette valeur        */
                                        /* initiale est choisie de facon que l'electron 2 REEL et l'anti-electron REEL n'aient       */
                                        /* pas leurs vecteurs vitesse opposes. En effet, sinon, dans la mesure ou leur collision     */
                                        /* nous interesse, 'DEFINITION_DE_LA_RESULTANTE_DE_2_POSITIONS(...)' donnerait dans ce cas   */
                                        /* resultante nulle...                                                                       */
#define   _MX_electron_1_REEL                                                                                                           \
                    FZERO
#define   _MY_electron_1_REEL                                                                                                           \
                    FZERO
#define   _MZ_electron_1_REEL                                                                                                           \
                    FU
                                        /* Definition du moment angulaire des deux electrons.                                        */

#define   DEMI_CERCLE                                                                                                                   \
                    DIVI(CERCLE_TRIGONOMETRIQUE,FLOT(NOMBRE_D_ELECTRONS_DANS_LE_DI_ELECTRON))                                           \
                                        /* Une moitie du cercle trigonometrique puisqu'il y a deux electrons.                        */
#define   phase_de_l_electron_1_REEL                                                                                                    \
                    GRO1(FRA2(DEMI_CERCLE))                                                                                             \
                                        /* On fixe de facon absolue la position angulaire dans 'PLAN_DE_LA_PARTICULE' du premier     */ \
                                        /* electron, le second etant positionne par rapport a lui...                                 */ \
                                        /*                                                                                           */ \
                                        /*                  e 1                                                                      */ \
                                        /*                                                                                           */ \
                                        /*                   *                                                                       */ \
                                        /*                                                                                           */ \
                                        /*                  e 2                                                                      */ \
                                        /*                                                                                           */

=define   X_electron_1_REEL_INITIAL                                                                                                     \
                    ADD2(X_DU_CENTRE_DE_LA_PARTICULE                                                                                    \
                        ,MUL2(RAYON_D_UN_HADRON                                                                                         \
                             ,COSX(ADD2(phase_de_l_electron_1_REEL                                                                      \
                                       ,GRO0(DEMI_CERCLE)                                                                               \
                                        )                                                                                               \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )
=define   Y_electron_1_REEL_INITIAL                                                                                                     \
                    ADD2(Y_DU_CENTRE_DE_LA_PARTICULE                                                                                    \
                        ,MUL2(RAYON_D_UN_HADRON                                                                                         \
                             ,SINX(ADD2(phase_de_l_electron_1_REEL                                                                      \
                                       ,GRO0(DEMI_CERCLE)                                                                               \
                                        )                                                                                               \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )
=define   Z_electron_1_REEL_INITIAL                                                                                                     \
                    PLAN_DE_LA_PARTICULE
                                        /* Definition de la position de l'electron 1.                                                */
#define   VX_electron_1_REEL_INITIALE                                                                                                   \
                    _VX_electron_1_REEL
#define   VY_electron_1_REEL_INITIALE                                                                                                   \
                    _VY_electron_1_REEL
#define   VZ_electron_1_REEL_INITIALE                                                                                                   \
                    _VZ_electron_1_REEL
                                        /* Definition de la vitesse de l'electron 1.                                                 */
#define   MX_electron_1_REEL_INITIAL                                                                                                    \
                    NEUT(_MX_electron_1_REEL)
#define   MY_electron_1_REEL_INITIAL                                                                                                    \
                    NEUT(_MY_electron_1_REEL)
#define   MZ_electron_1_REEL_INITIAL                                                                                                    \
                    NEUT(_MZ_electron_1_REEL)
                                        /* Definition du moment angulaire de l'electron 1.                                           */
DEFV(Local,DEFV(Float,INIT(X_electron_1_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Y_electron_1_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Z_electron_1_REEL,FLOT__UNDEF)));
DEFINITION_D_UNE_POSITION_INDEFINIE(position_initiale_de_l_electron_1_REEL);
DEFV(Local,DEFV(Float,INIT(VX_electron_1_REEL,VX_electron_1_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VY_electron_1_REEL,VY_electron_1_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VZ_electron_1_REEL,VZ_electron_1_REEL_INITIALE)));
DEFINITION_D_UNE_VITESSE_INDEFINIE(vitesse_initiale_de_l_electron_1_REEL);
DEFV(Local,DEFV(Float,INIT(MX_electron_1_REEL,MX_electron_1_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MY_electron_1_REEL,MY_electron_1_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MZ_electron_1_REEL,MZ_electron_1_REEL_INITIAL)));
DEFINITION_D_UN_MOMENT_ANGULAIRE_INDEFINI(moment_angulaire_initial_de_l_electron_1_REEL);
DEFV(Local,DEFV(electron,INIT(POINTERs(electron_1_REEL),PARTICULE_NON_DEFINIE)));
#define   DEFINITION_DE_L_ELECTRON_1_REEL                                                                                               \
                    Bblock                                                                                                              \
                    INITIALISATION_D_UNE_POSITION_QUELCONQUE(position_initiale_de_l_electron_1_REEL                                     \
                                                            ,X_electron_1_REEL                                                          \
                                                            ,Y_electron_1_REEL                                                          \
                                                            ,Z_electron_1_REEL                                                          \
                                                             );                                                                         \
                    INITIALISATION_D_UNE_VITESSE_QUELCONQUE(vitesse_initiale_de_l_electron_1_REEL                                       \
                                                           ,VX_electron_1_REEL                                                          \
                                                           ,VY_electron_1_REEL                                                          \
                                                           ,VZ_electron_1_REEL                                                          \
                                                            );                                                                          \
                    INITIALISATION_D_UN_MOMENT_ANGULAIRE_QUELCONQUE(moment_angulaire_initial_de_l_electron_1_REEL                       \
                                                                   ,MX_electron_1_REEL                                                  \
                                                                   ,MY_electron_1_REEL                                                  \
                                                                   ,MZ_electron_1_REEL                                                  \
                                                                    );                                                                  \
                    DEFINITION_D_UN_ELECTRON_REEL(electron_1_REEL                                                                       \
                                                 ,LEPTON_PAS_DE_SAVEUR                                                                  \
                                                 ,position_initiale_de_l_electron_1_REEL                                                \
                                                 ,vitesse_initiale_de_l_electron_1_REEL                                                 \
                                                 ,moment_angulaire_initial_de_l_electron_1_REEL                                         \
                                                  );                                                                                    \
                    Eblock
#define   COULEUR_DE_L_ELECTRON_1_REEL                                                                                                  \
                    Bblock                                                                                                              \
                    COULEUR_D_UNE_PARTICULE(electron_1_REEL                                                                             \
                                           ,COMPOSANTE_ROUGE_D_UN_ELECTRON_REEL_OU_VIRTUEL                                              \
                                           ,COMPOSANTE_VERTE_D_UN_ELECTRON_REEL_OU_VIRTUEL                                              \
                                           ,COMPOSANTE_BLEUE_D_UN_ELECTRON_REEL_OU_VIRTUEL                                              \
                                            );                                                                                          \
                    TRACE_D_UN_EVENEMENT(Prin1("ELECTROWEAK_CREATION_DE_L_ELECTRON_1_REEL    VIDE --> E(%d)"                            \
                                              ,ETIQUETTE(electron_1_REEL)                                                               \
                                               )                                                                                        \
                                         );                                                                                             \
                    Eblock

=define   X_electron_2_REEL_INITIAL                                                                                                     \
                    ADD2(X_DU_CENTRE_DE_LA_PARTICULE                                                                                    \
                        ,MUL2(RAYON_D_UN_HADRON                                                                                         \
                             ,COSX(ADD2(phase_de_l_electron_1_REEL                                                                      \
                                       ,GRO1(DEMI_CERCLE)                                                                               \
                                        )                                                                                               \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )
=define   Y_electron_2_REEL_INITIAL                                                                                                     \
                    ADD2(Y_DU_CENTRE_DE_LA_PARTICULE                                                                                    \
                        ,MUL2(RAYON_D_UN_HADRON                                                                                         \
                             ,SINX(ADD2(phase_de_l_electron_1_REEL                                                                      \
                                       ,GRO1(DEMI_CERCLE)                                                                               \
                                        )                                                                                               \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )
=define   Z_electron_2_REEL_INITIAL                                                                                                     \
                    PLAN_DE_LA_PARTICULE
                                        /* Definition de la position de l'electron 2.                                                */
#define   VX_electron_2_REEL_INITIALE                                                                                                   \
                    _VX_electron_1_REEL
#define   VY_electron_2_REEL_INITIALE                                                                                                   \
                    _VY_electron_1_REEL
#define   VZ_electron_2_REEL_INITIALE                                                                                                   \
                    _VZ_electron_1_REEL
                                        /* Definition de la vitesse de l'electron 2.                                                 */
#define   MX_electron_2_REEL_INITIAL                                                                                                    \
                    NEUT(_MX_electron_1_REEL)
#define   MY_electron_2_REEL_INITIAL                                                                                                    \
                    NEUT(_MY_electron_1_REEL)
#define   MZ_electron_2_REEL_INITIAL                                                                                                    \
                    NEUT(_MZ_electron_1_REEL)
                                        /* Definition du moment angulaire de l'electron 2.                                           */
DEFV(Local,DEFV(Float,INIT(X_electron_2_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Y_electron_2_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Z_electron_2_REEL,FLOT__UNDEF)));
DEFINITION_D_UNE_POSITION_INDEFINIE(position_initiale_de_l_electron_2_REEL);
DEFV(Local,DEFV(Float,INIT(VX_electron_2_REEL,VX_electron_2_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VY_electron_2_REEL,VY_electron_2_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VZ_electron_2_REEL,VZ_electron_2_REEL_INITIALE)));
DEFINITION_D_UNE_VITESSE_INDEFINIE(vitesse_initiale_de_l_electron_2_REEL);
DEFV(Local,DEFV(Float,INIT(MX_electron_2_REEL,MX_electron_2_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MY_electron_2_REEL,MY_electron_2_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MZ_electron_2_REEL,MZ_electron_2_REEL_INITIAL)));
DEFINITION_D_UN_MOMENT_ANGULAIRE_INDEFINI(moment_angulaire_initial_de_l_electron_2_REEL);
DEFV(Local,DEFV(electron,INIT(POINTERs(electron_2_REEL),PARTICULE_NON_DEFINIE)));
#define   DEFINITION_DE_L_ELECTRON_2_REEL                                                                                               \
                    Bblock                                                                                                              \
                    INITIALISATION_D_UNE_POSITION_QUELCONQUE(position_initiale_de_l_electron_2_REEL                                     \
                                                            ,X_electron_2_REEL                                                          \
                                                            ,Y_electron_2_REEL                                                          \
                                                            ,Z_electron_2_REEL                                                          \
                                                             );                                                                         \
                    INITIALISATION_D_UNE_VITESSE_QUELCONQUE(vitesse_initiale_de_l_electron_2_REEL                                       \
                                                           ,VX_electron_2_REEL                                                          \
                                                           ,VY_electron_2_REEL                                                          \
                                                           ,VZ_electron_2_REEL                                                          \
                                                            );                                                                          \
                    INITIALISATION_D_UN_MOMENT_ANGULAIRE_QUELCONQUE(moment_angulaire_initial_de_l_electron_2_REEL                       \
                                                                   ,MX_electron_2_REEL                                                  \
                                                                   ,MY_electron_2_REEL                                                  \
                                                                   ,MZ_electron_2_REEL                                                  \
                                                                    );                                                                  \
                    DEFINITION_D_UN_ELECTRON_REEL(electron_2_REEL                                                                       \
                                                 ,LEPTON_PAS_DE_SAVEUR                                                                  \
                                                 ,position_initiale_de_l_electron_2_REEL                                                \
                                                 ,vitesse_initiale_de_l_electron_2_REEL                                                 \
                                                 ,moment_angulaire_initial_de_l_electron_2_REEL                                         \
                                                  );                                                                                    \
                    Eblock
#define   COULEUR_DE_L_ELECTRON_2_REEL                                                                                                  \
                    Bblock                                                                                                              \
                    COULEUR_D_UNE_PARTICULE(electron_2_REEL                                                                             \
                                           ,COMPOSANTE_ROUGE_D_UN_ELECTRON_REEL_OU_VIRTUEL                                              \
                                           ,COMPOSANTE_VERTE_D_UN_ELECTRON_REEL_OU_VIRTUEL                                              \
                                           ,COMPOSANTE_BLEUE_D_UN_ELECTRON_REEL_OU_VIRTUEL                                              \
                                            );                                                                                          \
                    TRACE_D_UN_EVENEMENT(Prin1("ELECTROWEAK_CREATION_DE_L_ELECTRON_2_REEL    VIDE --> E(%d)"                            \
                                              ,ETIQUETTE(electron_2_REEL)                                                               \
                                               )                                                                                        \
                                         );                                                                                             \
                    Eblock

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L ' A N T I - E L E C T R O N  :                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
=define   X_anti_electron_REEL_INITIAL                                                                                                  \
                    ADD2(X_electron_2_REEL_INITIAL                                                                                      \
                        ,GRO2(RAYON_D_UN_HADRON)                                                                                        \
                         )
=define   Y_anti_electron_REEL_INITIAL                                                                                                  \
                    Y_electron_2_REEL_INITIAL                                                                                           \
=define   Z_anti_electron_REEL_INITIAL                                                                                                  \
                    PLAN_DE_LA_PARTICULE
                                        /* Definition de la position de l'anti-electron.                                             */
#define   VX_anti_electron_REEL_INITIALE                                                                                                \
                    NEGA(VX_electron_2_REEL_INITIALE)
#define   VY_anti_electron_REEL_INITIALE                                                                                                \
                    NEUT(VY_electron_2_REEL_INITIALE)
#define   VZ_anti_electron_REEL_INITIALE                                                                                                \
                    NEUT(VZ_electron_2_REEL_INITIALE)
                                        /* Definition de la vitesse de l'anti-electron. ATTENTION, on notera que cette valeur        */
                                        /* initiale est choisie de facon a ce que l'electron 2 REEL et l'anti-electron REEL aillent  */
                                        /* a la rencontre l'un de l'autre...                                                         */
#define   MX_anti_electron_REEL_INITIAL                                                                                                 \
                    NEGA(_MX_electron_1_REEL)
#define   MY_anti_electron_REEL_INITIAL                                                                                                 \
                    NEGA(_MY_electron_1_REEL)
#define   MZ_anti_electron_REEL_INITIAL                                                                                                 \
                    NEGA(_MZ_electron_1_REEL)
                                        /* Definition du moment angulaire de l'anti-electron.                                        */
DEFV(Local,DEFV(Float,INIT(X_anti_electron_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Y_anti_electron_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Z_anti_electron_REEL,FLOT__UNDEF)));
DEFINITION_D_UNE_POSITION_INDEFINIE(position_initiale_de_l_anti_electron_REEL);
DEFV(Local,DEFV(Float,INIT(VX_anti_electron_REEL,VX_anti_electron_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VY_anti_electron_REEL,VY_anti_electron_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VZ_anti_electron_REEL,VZ_anti_electron_REEL_INITIALE)));
DEFINITION_D_UNE_VITESSE_INDEFINIE(vitesse_initiale_de_l_anti_electron_REEL);
DEFV(Local,DEFV(Float,INIT(MX_anti_electron_REEL,MX_anti_electron_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MY_anti_electron_REEL,MY_anti_electron_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MZ_anti_electron_REEL,MZ_anti_electron_REEL_INITIAL)));
DEFINITION_D_UN_MOMENT_ANGULAIRE_INDEFINI(moment_angulaire_initial_de_l_anti_electron_REEL);
DEFV(Local,DEFV(electron,INIT(POINTERs(anti_electron_REEL),PARTICULE_NON_DEFINIE)));
#define   DEFINITION_DE_L_ANTI_ELECTRON_REEL                                                                                            \
                    Bblock                                                                                                              \
                    INITIALISATION_D_UNE_POSITION_QUELCONQUE(position_initiale_de_l_anti_electron_REEL                                  \
                                                            ,X_anti_electron_REEL                                                       \
                                                            ,Y_anti_electron_REEL                                                       \
                                                            ,Z_anti_electron_REEL                                                       \
                                                             );                                                                         \
                    INITIALISATION_D_UNE_VITESSE_QUELCONQUE(vitesse_initiale_de_l_anti_electron_REEL                                    \
                                                           ,VX_anti_electron_REEL                                                       \
                                                           ,VY_anti_electron_REEL                                                       \
                                                           ,VZ_anti_electron_REEL                                                       \
                                                            );                                                                          \
                    INITIALISATION_D_UN_MOMENT_ANGULAIRE_QUELCONQUE(moment_angulaire_initial_de_l_anti_electron_REEL                    \
                                                                   ,MX_anti_electron_REEL                                               \
                                                                   ,MY_anti_electron_REEL                                               \
                                                                   ,MZ_anti_electron_REEL                                               \
                                                                    );                                                                  \
                    DEFINITION_D_UN_ANTI_ELECTRON_REEL(anti_electron_REEL                                                               \
                                                      ,LEPTON_PAS_DE_SAVEUR                                                             \
                                                      ,position_initiale_de_l_anti_electron_REEL                                        \
                                                      ,vitesse_initiale_de_l_anti_electron_REEL                                         \
                                                      ,moment_angulaire_initial_de_l_anti_electron_REEL                                 \
                                                       );                                                                               \
                    Eblock
#define   COULEUR_DE_L_ANTI_ELECTRON_REEL                                                                                               \
                    Bblock                                                                                                              \
                    COULEUR_D_UNE_PARTICULE(anti_electron_REEL                                                                          \
                                           ,COMPOSANTE_ROUGE_D_UN_ANTI_ELECTRON_REEL_OU_VIRTUEL                                         \
                                           ,COMPOSANTE_VERTE_D_UN_ANTI_ELECTRON_REEL_OU_VIRTUEL                                         \
                                           ,COMPOSANTE_BLEUE_D_UN_ANTI_ELECTRON_REEL_OU_VIRTUEL                                         \
                                            );                                                                                          \
                    TRACE_D_UN_EVENEMENT(Prin1("ELECTROWEAK_CREATION_DE_L_ANTI_ELECTRON_REEL VIDE --> AE(%d)"                           \
                                              ,ETIQUETTE(anti_electron_REEL)                                                            \
                                               )                                                                                        \
                                         );                                                                                             \
                    Eblock

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   N E U T R I N O  :                                                                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   _VX_neutrino_REEL                                                                                                             \
                    GRO1(FRA3(VITESSE_DE_LA_LUMIERE))
#define   _VY_neutrino_REEL                                                                                                             \
                    FZERO
#define   _VZ_neutrino_REEL                                                                                                             \
                    FZERO
                                        /* Definition de la vitesse des deux neutrinos.                                              */
#define   _MX_neutrino_REEL                                                                                                             \
                    FZERO
#define   _MY_neutrino_REEL                                                                                                             \
                    FZERO
#define   _MZ_neutrino_REEL                                                                                                             \
                    FU
                                        /* Definition du moment angulaire des deux neutrinos.                                        */

#define   phase_du_neutrino_REEL                                                                                                        \
                    GRO1(FRA2(DEMI_CERCLE))                                                                                             \
                                        /* On fixe de facon absolue la position angulaire dans 'PLAN_DE_LA_PARTICULE' du neutrino.   */

=define   X_neutrino_REEL_INITIAL                                                                                                       \
                    ADD2(X_DU_CENTRE_DE_LA_PARTICULE                                                                                    \
                        ,MUL2(RAYON_D_UN_HADRON                                                                                         \
                             ,COSX(ADD2(phase_du_neutrino_REEL                                                                          \
                                       ,GRO1(FRA2(DEMI_CERCLE))                                                                         \
                                        )                                                                                               \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )
=define   Y_neutrino_REEL_INITIAL                                                                                                       \
                    ADD2(Y_DU_CENTRE_DE_LA_PARTICULE                                                                                    \
                        ,MUL2(RAYON_D_UN_HADRON                                                                                         \
                             ,SINX(ADD2(phase_du_neutrino_REEL                                                                          \
                                       ,GRO0(DEMI_CERCLE)                                                                               \
                                        )                                                                                               \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )
=define   Z_neutrino_REEL_INITIAL                                                                                                       \
                    PLAN_DE_LA_PARTICULE
                                        /* Definition de la position de l'neutrino 1.                                                */
#define   VX_neutrino_REEL_INITIALE                                                                                                     \
                    _VX_neutrino_REEL
#define   VY_neutrino_REEL_INITIALE                                                                                                     \
                    _VY_neutrino_REEL
#define   VZ_neutrino_REEL_INITIALE                                                                                                     \
                    _VZ_neutrino_REEL
                                        /* Definition de la vitesse de l'neutrino 1.                                                 */
#define   MX_neutrino_REEL_INITIAL                                                                                                      \
                    NEUT(_MX_neutrino_REEL)
#define   MY_neutrino_REEL_INITIAL                                                                                                      \
                    NEUT(_MY_neutrino_REEL)
#define   MZ_neutrino_REEL_INITIAL                                                                                                      \
                    NEUT(_MZ_neutrino_REEL)
                                        /* Definition du moment angulaire de l'neutrino 1.                                           */
DEFV(Local,DEFV(Float,INIT(X_neutrino_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Y_neutrino_REEL,FLOT__UNDEF)));
DEFV(Local,DEFV(Float,INIT(Z_neutrino_REEL,FLOT__UNDEF)));
DEFINITION_D_UNE_POSITION_INDEFINIE(position_initiale_du_neutrino_REEL);
DEFV(Local,DEFV(Float,INIT(VX_neutrino_REEL,VX_neutrino_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VY_neutrino_REEL,VY_neutrino_REEL_INITIALE)));
DEFV(Local,DEFV(Float,INIT(VZ_neutrino_REEL,VZ_neutrino_REEL_INITIALE)));
DEFINITION_D_UNE_VITESSE_INDEFINIE(vitesse_initiale_du_neutrino_REEL);
DEFV(Local,DEFV(Float,INIT(MX_neutrino_REEL,MX_neutrino_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MY_neutrino_REEL,MY_neutrino_REEL_INITIAL)));
DEFV(Local,DEFV(Float,INIT(MZ_neutrino_REEL,MZ_neutrino_REEL_INITIAL)));
DEFINITION_D_UN_MOMENT_ANGULAIRE_INDEFINI(moment_angulaire_initial_du_neutrino_REEL);
DEFV(Local,DEFV(neutrino,INIT(POINTERs(neutrino_REEL),PARTICULE_NON_DEFINIE)));
#define   DEFINITION_DU_NEUTRINO_REEL                                                                                                   \
                    Bblock                                                                                                              \
                    INITIALISATION_D_UNE_POSITION_QUELCONQUE(position_initiale_du_neutrino_REEL                                         \
                                                            ,X_neutrino_REEL                                                            \
                                                            ,Y_neutrino_REEL                                                            \
                                                            ,Z_neutrino_REEL                                                            \
                                                             );                                                                         \
                    INITIALISATION_D_UNE_VITESSE_QUELCONQUE(vitesse_initiale_du_neutrino_REEL                                           \
                                                           ,VX_neutrino_REEL                                                            \
                                                           ,VY_neutrino_REEL                                                            \
                                                           ,VZ_neutrino_REEL                                                            \
                                                            );                                                                          \
                    INITIALISATION_D_UN_MOMENT_ANGULAIRE_QUELCONQUE(moment_angulaire_initial_du_neutrino_REEL                           \
                                                                   ,MX_neutrino_REEL                                                    \
                                                                   ,MY_neutrino_REEL                                                    \
                                                                   ,MZ_neutrino_REEL                                                    \
                                                                    );                                                                  \
                    DEFINITION_D_UN_NEUTRINO_REEL(neutrino_REEL                                                                         \
                                                 ,LEPTON_PAS_DE_SAVEUR                                                                  \
                                                 ,position_initiale_du_neutrino_REEL                                                    \
                                                 ,vitesse_initiale_du_neutrino_REEL                                                     \
                                                  );                                                                                    \
                    Eblock
#define   COULEUR_DU_NEUTRINO_REEL                                                                                                      \
                    Bblock                                                                                                              \
                    COULEUR_D_UNE_PARTICULE(neutrino_REEL                                                                               \
                                           ,COMPOSANTE_ROUGE_D_UN_NEUTRINO_REEL_OU_VIRTUEL                                              \
                                           ,COMPOSANTE_VERTE_D_UN_NEUTRINO_REEL_OU_VIRTUEL                                              \
                                           ,COMPOSANTE_BLEUE_D_UN_NEUTRINO_REEL_OU_VIRTUEL                                              \
                                            );                                                                                          \
                    TRACE_D_UN_EVENEMENT(Prin1("ELECTROWEAK_CREATION_DU_NEUTRINO_REEL        VIDE --> N(%d)"                            \
                                              ,ETIQUETTE(neutrino_REEL)                                                                 \
                                               )                                                                                        \
                                         );                                                                                             \
                    Eblock

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   V I D E   P A R   U N   C H A M P   U N I F O R M E  :                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   PONDERATION_g0                                                                                                                \
                    FRA10(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(ponderation_g0,PONDERATION_g0)));
                                        /* Definition l'amplitude du champ du vide.                                                  */

#define   MAXIMUM_DU_CHAMP_GLOBAL                                                                                                       \
                    FU                                                                                                                  \
                                        /* Valeur maximale du champ global qui sera atteinte partout. ATTENTION : cette definition   */ \
                                        /* doit preceder cellede 'CHAMP_DU_VIDE(...)', car en effet, elles n'appartiennent pas a la  */ \
                                        /* meme passe...                                                                             */

=define   CHAMP_DU_VIDE(cX,cY,cZ)                                                                                                       \
                    MUL2(ponderation_g0,MAXIMUM_DU_CHAMP_GLOBAL)
                                        /* Definition du champ du vide.                                                              */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   V A L E U R S   D E   L A   C H A R G E   D E   C O U L E U R  :                             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        ATTENTION :                                                                                                                */
/*                                                                                                                                   */
/*                    Pour des raisons liees au pre-processing                                                                       */
/*                  les definitions qui suivent doivent se trouver                                                                   */
/*                  apres les definitions de 'CHAMP_DE_VALENCE_DE_L_ELECTRON_1_REEL(...)',                                           */
/*                  et 'CHAMP_DE_VALENCE_DE_L_ELECTRON_2_REEL(...)'...                                                               */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
%define   ROUGE_max                                                                                                                     \
                    COULEUR_max
                                        /* Definition du maximum de la composante ROUGE de la charge de couleur.                     */
%define   VERTE_max                                                                                                                     \
                    COULEUR_max
                                        /* Definition du maximum de la composante VERTE de la charge de couleur.                     */
%define   BLEUE_max                                                                                                                     \
                    COULEUR_max
                                        /* Definition du maximum de la composante BLEUE de la charge de couleur.                     */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   G E O M E T R I E   D U   C H A M P   " D E   F L U X "  :                               */
/*        L ' I N T E R A C T I O N   F O R T E   D A N S   L E   " D I - E L E C T R O N "  :                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition du champ de flux :                                                                                              */
/*                                                                                                                                   */
/*        FLUX(x,y,z) = 0                                                                                                            */
/*                                                                                                                                   */
/*        il est donc inutile...                                                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   CALCULER_LE_CHAMP_DE_FLUX                                                                                                     \
                    LUNDEF
                                        /* Par compatibilte avec '$xrq/nucleon.LI$I' et '$xrq/nucleon.LV$I'...                       */
#define   DISTANCE_CARACTERISTIQUE_g1                                                                                                   \
                    FLOT__UNDEF
DEFV(Local,DEFV(Float,INIT(distance_caracteristique_g1,FLOT__UNDEF)));
                                        /* Nota : cette definition est uniquement destinee a la compatibilite avec les deux fichiers */
                                        /* '$xrq/nucleon.LW.1$I' et '$xrq/nucleon.LW.2$I'...                                         */
DEFV(Local,DEFV(Float,INIT(cutoff_du_champ_global,FLOT__UNDEF)));
                                        /* Nota : cette definition est uniquement destinee a la compatibilite avec les deux fichiers */
                                        /* '$xrq/nucleon.LI$I' et '$xrq/nucleon.LV$I'...                                             */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E   L A   G E O M E T R I E   D U   C H A M P   " D E   C O N F I N E M E N T "                    */
/*        D U   " D I - E L E C T R O N "  :                                                                                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Definition du champ de confinement :                                                                                       */
/*                                                                                                                                   */
/*        CONFINEMENT(x,y,z) = 0                                                                                                     */
/*                                                                                                                                   */
/*        il est donc inutile...                                                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NE_PAS_CALCULER_LE_CHAMP_DE_CONFINEMENT                                                                                       \
                    LUNDEF
                                        /* Par compatibilte avec '$xrq/nucleon.LI$I' et '$xrq/nucleon.LV$I'...                       */
#define   DISTANCE_CARACTERISTIQUE_g2                                                                                                   \
                    FLOT__UNDEF
DEFV(Local,DEFV(Float,INIT(distance_caracteristique_g2,FLOT__UNDEF)));
                                        /* Nota : cette definition est uniquement destinee a la compatibilite avec les deux fichiers */
                                        /* '$xrq/nucleon.LW.1$I' et '$xrq/nucleon.LW.2$I'...                                         */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   C H A M P   G L O B A L   D ' I N T E R A C T I O N  :                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   MINIMUM_DU_CHAMP_GLOBAL                                                                                                       \
                    FZERO                                                                                                               \
                                        /* Valeur minimale (relativement arbitraire) du champ global...                              */
DEFV(Local,DEFV(Float,INIT(champ_global,FLOT__UNDEF)));
                                        /* Intensite du champ resultant (valence + flux + confinement).                              */
#define   CALCUL_DU_CHAMP_GLOBAL(cX,cY,cZ,calculer_le_champ_de_flux,calculer_le_champ_de_confinement,cutoff)                            \
                    Bblock                                                                                                              \
                    EGAL(champ_global                                                                                                   \
                        ,CHAMP_DU_VIDE(cX,cY,cZ)                                                                                        \
                         );                                                                                                             \
                                        /* Generation du champ du vide...                                                            */ \
                    Eblock                                                                                                              \
                                        /* Intensite du champ resultant...                                                           */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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   CHANGEMENT_EVENTUEL_D_ELECTRON_REEL(electronD,electronA)                                                                      \
                    Bblock                                                                                                              \
                    Test(IFEQ(NATURE(electronD),ELECTRON_REEL))                                                                         \
                         Bblock                                                                                                         \
                         Choi(NATURE(electronA))                                                                                        \
                              Bblock                                                                                                    \
                              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 changer n'est pas reconnue");                                \
                                   Eblock                                                                                               \
                              EDef                                                                                                      \
                              Eblock                                                                                                    \
                         ECho                                                                                                           \
                                                                                                                                        \
                         NATURE_D_UNE_PARTICULE(electronA,ELECTRON_REEL);                                                               \
                                        /* L'electron 'electronA' devient reel, puisque 'electronD' l'etait et qu'il va mourir...    */ \
                         CHARGE_D_UNE_PARTICULE(electronA,CHARGE_DE_L_ELECTRON_REEL);                                                   \
                                        /* L'electron 'electronA' recupere la charge d'un electron REEL (voir en effet ce qui est    */ \
                                        /* fait par 'exageration_de_la_charge_des_electrons_et_des_anti_electrons_virtuels' dans     */ \
                                        /* '$xrq/nucleon.L5$I' afin d'accentuer l'effet de la force de Lorentz...).                  */ \
                                                                                                                                        \
                         INCR(nombre_instantane_d_electrons_REELs,I);                                                                   \
                         INCR(nombre_total_d_electrons_REELs,I);                                                                        \
                                        /* Comptage des electrons REELs.                                                             */ \
                                                                                                                                        \
                         INITIALISATION_DE_LA_POSITION_INITIALE_D_UNE_PARTICULE(electronA                                               \
                                                                               ,ASI2(electronD,espace_temps,position_courante)          \
                                                                                );                                                      \
                         INITIALISATION_DE_LA_POSITION_COURANTE_D_UNE_PARTICULE(electronA);                                             \
                                        /* Et le 'electronA' se place la ou etait 'electronD'...                                     */ \
                                                                                                                                        \
                         Test(IFEQ(electronD,electron_1_REEL))                                                                          \
                              Bblock                                                                                                    \
                              CHANGEMENT_D_ELECTRON_REEL(electron_1_REEL,electronA);                                                    \
                                        /* Si 'electronD' etait l'electron 1 REEL, 'electronD' le devient...                         */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Test(IFEQ(electronD,electron_2_REEL))                                                                     \
                                   Bblock                                                                                               \
                                   CHANGEMENT_D_ELECTRON_REEL(electron_2_REEL,electronA);                                               \
                                        /* Si 'electronD' etait l'electron 2 REEL, 'electronD' le devient...                         */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   PRINT_ERREUR("un electron a le type REEL, mais n'est pas l'electron REEL courant");                  \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         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   CHANGEMENT_EVENTUEL_D_ANTI_ELECTRON_REEL(anti_electronD,anti_electronA)                                                       \
                    Bblock                                                                                                              \
                    Test(IFEQ(NATURE(anti_electronD),ANTI_ELECTRON_REEL))                                                               \
                         Bblock                                                                                                         \
                         Choi(NATURE(anti_electronA))                                                                                   \
                              Bblock                                                                                                    \
                              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 changer n'est pas reconnue");                           \
                                   Eblock                                                                                               \
                              EDef                                                                                                      \
                              Eblock                                                                                                    \
                         ECho                                                                                                           \
                                                                                                                                        \
                         NATURE_D_UNE_PARTICULE(anti_electronA,ANTI_ELECTRON_REEL);                                                     \
                                        /* L'anti-electron 'anti_electronA' devient reel, puisque 'anti_electronD' l'etait et        */ \
                                        /* qu'il va mourir...                                                                        */ \
                         CHARGE_D_UNE_PARTICULE(anti_electronA,CHARGE_DE_L_ANTI_ELECTRON_REEL);                                         \
                                        /* L'anti-electron 'anti_electronA' recupere la charge d'un anti-electron REEL (voir en      */ \
                                        /* effet 'exageration_de_la_charge_des_electrons_et_des_anti_electrons_virtuels' dans        */ \
                                        /* '$xrq/nucleon.L5$I' afin d'accentuer l'effet de la force de Lorentz...).                  */ \
                                                                                                                                        \
                         INCR(nombre_instantane_d_anti_electrons_REELs,I);                                                              \
                         INCR(nombre_total_d_anti_electrons_REELs,I);                                                                   \
                                        /* Comptage des anti-electrons REELs.                                                        */ \
                                                                                                                                        \
                         INITIALISATION_DE_LA_POSITION_INITIALE_D_UNE_PARTICULE(anti_electronA                                          \
                                                                               ,ASI2(anti_electronD,espace_temps,position_courante)     \
                                                                                );                                                      \
                         INITIALISATION_DE_LA_POSITION_COURANTE_D_UNE_PARTICULE(anti_electronA);                                        \
                                        /* Et le 'anti_electronA' se place la ou etait 'anti_electronD'...                           */ \
                                                                                                                                        \
                         Test(IFEQ(anti_electronD,anti_electron_REEL))                                                                  \
                              Bblock                                                                                                    \
                              CHANGEMENT_D_ANTI_ELECTRON_REEL(anti_electron_REEL,anti_electronA);                                       \
                                        /* Si 'anti_electronD' etait l'anti-electron REEL, 'anti_electronD' le devient...            */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              PRINT_ERREUR("un anti_electron a le type REEL, mais n'est pas l'anti_electron REEL courant");             \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         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_EVENTUEL_DE_NEUTRINO_REEL(neutrinoD,neutrinoA)                                                                     \
                    Bblock                                                                                                              \
                    Test(IFEQ(NATURE(neutrinoD),NEUTRINO_REEL))                                                                         \
                         Bblock                                                                                                         \
                         Choi(NATURE(neutrinoA))                                                                                        \
                              Bblock                                                                                                    \
                              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 changer n'est pas reconnue");                                  \
                                   Eblock                                                                                               \
                              EDef                                                                                                      \
                              Eblock                                                                                                    \
                         ECho                                                                                                           \
                         NATURE_D_UNE_PARTICULE(neutrinoA,NEUTRINO_REEL);                                                               \
                                        /* Le neutrino 'neutrinoA' devient reel, puisque 'neutrinoD' l'etait et qu'il va mourir...   */ \
                         INCR(nombre_instantane_de_neutrinos_REELs,I);                                                                  \
                         INCR(nombre_total_de_neutrinos_REELs,I);                                                                       \
                                        /* Comptage des neutrinos REELs.                                                             */ \
                         INITIALISATION_DE_LA_POSITION_INITIALE_D_UNE_PARTICULE(neutrinoA                                               \
                                                                               ,ASI2(neutrinoD,espace_temps,position_courante)          \
                                                                                );                                                      \
                         INITIALISATION_DE_LA_POSITION_COURANTE_D_UNE_PARTICULE(neutrinoA);                                             \
                                        /* Et le 'neutrinoA' se place la ou etait 'neutrinoD'...                                     */ \
                         Test(IFEQ(neutrinoD,neutrino_REEL))                                                                            \
                              Bblock                                                                                                    \
                              CHANGEMENT_DE_NEUTRINO_REEL(neutrino_REEL,neutrinoA);                                                     \
                                        /* Si 'neutrinoD' etait le neutrino REEL, 'neutrinoD' le devient...                          */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              PRINT_ERREUR("un neutrino a le type REEL, mais n'est pas le neutrino REEL courant");                      \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         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).                                                 */



Copyright © Jean-François Colonna, 2019-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2019-2021.