/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N S   D U   D E P L A C E M E N T   D E S   P A R T I C U L E S  :                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrq/nucleon.L9$I' :                                                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 1991??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   G E N E R A L E   D E S   C A R A C T E R I S T I Q U E S                                            */
/*        G E O M E T R I Q U E S   D U   D E P L A C E M E N T   D E S   P A R T I C U L E S   ( D E B U T )  :                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   DEFINITION_DE_LA_MATRICE_DE_ROTATION                                                                                          \
                    DEFV(matrixF_3D,matrice_de_rotation);                                                                               \
                                        /* Definition de la matrice de rotation de l'espace physique.                                */
#define   DEFINITION_DE_LA_VITESSE_ALEATOIRE                                                                                            \
                    DEFINITION_DE_LA_MATRICE_DE_ROTATION;                                                                               \
                                        /* Definition de la matrice de rotation de l'espace physique. Cette definition est faite     */ \
                                        /* ici afin que l'on puisse imbriquer 'DEBUT_DE_ROTATION_ALEATOIRE_DE_L_ESPACE_PHYSIQUE'     */ \
                                        /* dans 'DEBUT_DE_ROTATION_D_ALIGNEMENT_DE_L_ESPACE_PHYSIQUE_SUR_UNE_PARTICULE' au cas ou    */ \
                                        /* l'on rencontre une particule immobile...                                                  */ \
                    DEFINITION_D_UNE_DIRECTION_EN_COORDONNEES_SPHERIQUES(rho_de_la_vitesse,theta_spherique,phi_spherique);              \
                                        /* Definition d'une direction en coordonnees spheriques. Mais on notera avec attention que   */ \
                                        /* 'rho_de_la_vitesse' est utilise aussi bien en coordonnees spheriques (3D) qu'en           */ \
                                        /* coordonnees polaires (2D)...                                                              */ \
                    DEFV(deltaF_3D,vitesse_courante);                                                                                   \
                                        /* Pour memoriser la vitesse (aleatoire) du quark virtuel courant, sous la forme d'un        */ \
                                        /* vecteur (vx,vy,vz) en coordonnees cartesiennes, mais aussi en coordonnees                 */ \
                                        /* spheriques {rho,theta,phi}.                                                               */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D U   D E P L A C E M E N T   D E S   P A R T I C U L E S  :                                         */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_QUARK_OU_D_UN_ANTI_QUARK                                                \
                    Bblock                                                                                                              \
                    GENERATION_D_UNE_VALEUR(rho_de_la_vitesse                                                                           \
                                           ,COMPOSITION_RELATIVISTE_DES_VITESSES(VITESSE_MOYENNE_DES_QUARKS_ET_DES_ANTI_QUARKS          \
                                                                                ,NEGA(DISPERSION_VITESSE_DES_QUARKS_ET_DES_ANTI_QUARKS) \
                                                                                 )                                                      \
                                           ,COMPOSITION_RELATIVISTE_DES_VITESSES(VITESSE_MOYENNE_DES_QUARKS_ET_DES_ANTI_QUARKS          \
                                                                                ,NEUT(DISPERSION_VITESSE_DES_QUARKS_ET_DES_ANTI_QUARKS) \
                                                                                 )                                                      \
                                            );                                                                                          \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire du module de la vitesse d'un quark.                              */
#define   CONSERVATION_DU_MODULE_DE_LA_VITESSE_D_UN_QUARK_OU_D_UN_ANTI_QUARK(quark)                                                     \
                    Bblock                                                                                                              \
                    EGAL(rho_de_la_vitesse,longF3D(ASI2(quark,espace_temps,vitesse)));                                                  \
                    Eblock                                                                                                              \
                                        /* Conservation du module de la vitesse d'un quark.                                          */
#define   INITIALISATION_DE_LA_VITESSE_ALEATOIRE_D_UN_QUARK_OU_D_UN_ANTI_QUARK                                                          \
                    Bblock                                                                                                              \
                    INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_QUARK_OU_D_UN_ANTI_QUARK;                                     \
                                        /* Initialisation aleatoire du module de la vitesse d'un quark.                              */ \
                    GENERATION_D_UNE_DIRECTION_3D(theta_spherique,phi_spherique);                                                       \
                                        /* La vitesse est choisie aleatoirement (en coordonnees spheriques),                         */ \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire de la vitesse d'un quark.                                        */

#define   INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_GLUON                                                                   \
                    Bblock                                                                                                              \
                    EGAL(rho_de_la_vitesse,VITESSE_DES_GLUONS);                                                                         \
                                        /* Le module de la vitesse des gluons est figees, puisque ces particules se deplacent a la   */ \
                                        /* vitesse de la lumiere...                                                                  */ \
                    Eblock                                                                                                              \
                                        /* Initialisation du module de la vitesse d'un gluon, mais en respectant le fait qu'ils      */ \
                                        /* se deplacent tous a la vitesse de la lumiere...                                           */
#define   INITIALISATION_DE_LA_VITESSE_ALEATOIRE_D_UN_GLUON                                                                             \
                    Bblock                                                                                                              \
                    INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_GLUON;                                                        \
                                        /* Le module de la vitesse des gluons est figees, puisque ces particules se deplacent a la   */ \
                                        /* vitesse de la lumiere...                                                                  */ \
                    GENERATION_D_UNE_DIRECTION_3D(theta_spherique,phi_spherique);                                                       \
                                        /* La vitesse est choisie aleatoirement (en coordonnees spheriques),                         */ \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire de la vitesse d'un gluon, mais en respectant le fait qu'ils      */ \
                                        /* se deplacent tous a la vitesse de la lumiere...                                           */

#define   INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_ELECTRON_OU_D_UN_ANTI_ELECTRON                                          \
                    Bblock                                                                                                              \
                    GENERATION_D_UNE_VALEUR(rho_de_la_vitesse                                                                           \
                                           ,COMPOSITION_RELATIVISTE_DES_VITESSES                                                        \
                                                (vitesse_moyenne_des_electrons_et_des_anti_electrons                                    \
                                                ,NEGA(DISPERSION_VITESSE_DES_ELECTRONS_ET_DES_ANTI_ELECTRONS)                           \
                                                 )                                                                                      \
                                           ,COMPOSITION_RELATIVISTE_DES_VITESSES                                                        \
                                                (vitesse_moyenne_des_electrons_et_des_anti_electrons                                    \
                                                ,NEUT(DISPERSION_VITESSE_DES_ELECTRONS_ET_DES_ANTI_ELECTRONS)                           \
                                                 )                                                                                      \
                                            );                                                                                          \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire du module de la vitesse d'un electron.                           */
#define   CONSERVATION_DU_MODULE_DE_LA_VITESSE_D_UN_ELECTRON_OU_D_UN_ANTI_ELECTRON(electron)                                            \
                    Bblock                                                                                                              \
                    EGAL(rho_de_la_vitesse,longF3D(ASI2(electron,espace_temps,vitesse)));                                               \
                    Eblock                                                                                                              \
                                        /* Conservation du module de la vitesse d'un electron.                                       */
#define   INITIALISATION_DE_LA_VITESSE_ALEATOIRE_D_UN_ELECTRON_OU_D_UN_ANTI_ELECTRON                                                    \
                    Bblock                                                                                                              \
                    INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_ELECTRON_OU_D_UN_ANTI_ELECTRON;                               \
                                        /* Initialisation aleatoire du module de la vitesse d'un electron.                           */ \
                    GENERATION_D_UNE_DIRECTION_3D(theta_spherique,phi_spherique);                                                       \
                                        /* La vitesse est choisie aleatoirement (en coordonnees spheriques),                         */ \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire de la vitesse d'un electron.                                     */

#define   INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_NEUTRINO                                                                \
                    Bblock                                                                                                              \
                    GENERATION_D_UNE_VALEUR(rho_de_la_vitesse                                                                           \
                                           ,COMPOSITION_RELATIVISTE_DES_VITESSES                                                        \
                                                (VITESSE_MOYENNE_DES_NEUTRINOS                                                          \
                                                ,NEGA(DISPERSION_VITESSE_DES_NEUTRINOS)                                                 \
                                                 )                                                                                      \
                                           ,COMPOSITION_RELATIVISTE_DES_VITESSES                                                        \
                                                (VITESSE_MOYENNE_DES_NEUTRINOS                                                          \
                                                ,NEUT(DISPERSION_VITESSE_DES_NEUTRINOS)                                                 \
                                                 )                                                                                      \
                                            );                                                                                          \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire du module de la vitesse d'un neutrino.                           */
#define   CONSERVATION_DU_MODULE_DE_LA_VITESSE_D_UN_NEUTRINO(neutrino)                                                                  \
                    Bblock                                                                                                              \
                    EGAL(rho_de_la_vitesse,longF3D(ASI2(neutrino,espace_temps,vitesse)));                                               \
                    Eblock                                                                                                              \
                                        /* Conservation du module de la vitesse d'un neutrino.                                       */
#define   INITIALISATION_DE_LA_VITESSE_ALEATOIRE_D_UN_NEUTRINO                                                                          \
                    Bblock                                                                                                              \
                    INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_NEUTRINO;                                                     \
                                        /* Initialisation aleatoire du module de la vitesse d'un neutrino.                           */ \
                    GENERATION_D_UNE_DIRECTION_3D(theta_spherique,phi_spherique);                                                       \
                                        /* La vitesse est choisie aleatoirement (en coordonnees spheriques),                         */ \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire de la vitesse d'un neutrino.                                     */

#define   INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_PHOTON                                                                  \
                    Bblock                                                                                                              \
                    EGAL(rho_de_la_vitesse,VITESSE_DES_PHOTONS);                                                                        \
                                        /* Le module de la vitesse des photons est figees, puisque ces particules se deplacent a la  */ \
                                        /* vitesse de la lumiere...                                                                  */ \
                    Eblock                                                                                                              \
                                        /* Initialisation du module de la vitesse d'un photon, mais en respectant le fait qu'ils     */ \
                                        /* se deplacent tous a la vitesse de la lumiere...                                           */
#define   INITIALISATION_DE_LA_VITESSE_ALEATOIRE_D_UN_PHOTON                                                                            \
                    Bblock                                                                                                              \
                    INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_PHOTON;                                                       \
                                        /* Le module de la vitesse des photons est figees, puisque ces particules se deplacent a la  */ \
                                        /* vitesse de la lumiere...                                                                  */ \
                    GENERATION_D_UNE_DIRECTION_3D(theta_spherique,phi_spherique);                                                       \
                                        /* La vitesse est choisie aleatoirement (en coordonnees spheriques),                         */ \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire de la vitesse d'un photon, mais en respectant le fait qu'ils     */ \
                                        /* se deplacent tous a la vitesse de la lumiere...                                           */

#define   INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_Z0                                                                      \
                    Bblock                                                                                                              \
                    EGAL(rho_de_la_vitesse,VITESSE_DES_Z0S);                                                                            \
                                        /* Le module de la vitesse des z0s est figees, puisque ces particules se deplacent a la      */ \
                                        /* vitesse de la lumiere...                                                                  */ \
                    Eblock                                                                                                              \
                                        /* Initialisation du module de la vitesse d'un z0, mais en respectant le fait qu'ils         */ \
                                        /* se deplacent tous a la vitesse de la lumiere...                                           */
#define   INITIALISATION_DE_LA_VITESSE_ALEATOIRE_D_UN_Z0                                                                                \
                    Bblock                                                                                                              \
                    INITIALISATION_DU_MODULE_DE_LA_VITESSE_ALEATOIRE_D_UN_Z0;                                                           \
                                        /* Le module de la vitesse des z0s est figees, puisque ces particules se deplacent a la      */ \
                                        /* vitesse de la lumiere...                                                                  */ \
                    GENERATION_D_UNE_DIRECTION_3D(theta_spherique,phi_spherique);                                                       \
                                        /* La vitesse est choisie aleatoirement (en coordonnees spheriques),                         */ \
                    Eblock                                                                                                              \
                                        /* Initialisation aleatoire de la vitesse d'un z0, mais en respectant le fait qu'ils         */ \
                                        /* se deplacent tous a la vitesse de la lumiere...                                           */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   G E N E R A L E   D E S   C A R A C T E R I S T I Q U E S                                            */
/*        G E O M E T R I Q U E S   D U   D E P L A C E M E N T   D E S   P A R T I C U L E S   ( S U I T E )  :                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   COMBINAISON_DE_TYPE_RESULTANTE                                                                                                \
                    FU                                                                                                                  \
                                        /* Ponderation destinee a calculer la resultante de deux vitesses...                         */

#define   DEFINITION_DE_LA_COMBINAISON_DE_2_POSITIONS(resultante_des_2_positions,resultante_des_2_vitesses,k1,part1,k2,part2)           \
                                        /* ATTENTION : il n'y a pas de (Bblock,Eblock) afin que 'resultante_des_2_vitesses' et       */ \
                                        /* 'resultante_des_2_positions' soient connus a l'exterieur...                               */ \
                    DEFV(pointF_3D,resultante_des_2_positions);                                                                         \
                                        /* Definition d'une position moyenne entre les 2 particules...                               */ \
                    DEFV(deltaF_3D,resultante_des_2_vitesses);                                                                          \
                                        /* Definition d'un vecteur resultante des deux vecteurs vitesse des particules incidentes ;  */ \
                                        /* il est dit "virtuel" parce que son module peut tres bien etre superieur a la vitesse de   */ \
                                        /* la lumiere, ce qui n'a aucune importance, puisque seule sa direction importe...           */ \
                    INITIALISATION_POINT_3D(resultante_des_2_positions                                                                  \
                                           ,LRZ2(k1,COORDONNEES(part1,x)                                                                \
                                                ,k2,COORDONNEES(part2,x)                                                                \
                                                 )                                                                                      \
                                           ,LRZ2(k1,COORDONNEES(part1,y)                                                                \
                                                ,k2,COORDONNEES(part2,y)                                                                \
                                                 )                                                                                      \
                                           ,LRZ2(k1,COORDONNEES(part1,z)                                                                \
                                                ,k2,COORDONNEES(part2,z)                                                                \
                                                 )                                                                                      \
                                            );                                                                                          \
                                        /* La position resultante est choisie a mi-chemin de 'part1' et 'part2'.                     */ \
                    INITIALISATION_ACCROISSEMENT_3D(resultante_des_2_vitesses                                                           \
                                                   ,LIZ2(k1,ASI3(part1,espace_temps,vitesse,dx)                                         \
                                                        ,k2,ASI3(part2,espace_temps,vitesse,dx)                                         \
                                                         )                                                                              \
                                                   ,LIZ2(k1,ASI3(part1,espace_temps,vitesse,dy)                                         \
                                                        ,k2,ASI3(part2,espace_temps,vitesse,dy)                                         \
                                                         )                                                                              \
                                                   ,LIZ2(k1,ASI3(part1,espace_temps,vitesse,dz)                                         \
                                                        ,k2,ASI3(part2,espace_temps,vitesse,dz)                                         \
                                                         )                                                                              \
                                                    );                                                                                  \
                                        /* La vitesse resultante est choisie comme la somme arithmetique des 2 vitesses, mais        */ \
                                        /* ceci est tout a fait arbitraire, puisqu'en fait seule nous interesse une direction.       */ \
                                        /* On notera de plus que l'on utilise 'ADD2(v1,v2)' et non pas la fonction relativiste       */ \
                                        /* 'COMPOSITION_RELATIVISTE_DES_VITESSES(v1,v2)' car d'une part cette operation est          */ \
                                        /* arbitraire, et que d'autre part, dans le cas v2=-v1, on arriverait au rapport 0/0...      */ \
                                        /*                                                                                           */ \
                                        /* calcul de la resultante de 2 positions (scalaire et vectorielle) avec ponderation.        */
#define   DEFINITION_DE_LA_RESULTANTE_DE_2_POSITIONS(resultante_des_2_positions,resultante_des_2_vitesses,part1,part2)                  \
                                        /* ATTENTION : il n'y a pas de (Bblock,Eblock) afin que 'resultante_des_2_vitesses' et       */ \
                                        /* 'resultante_des_2_positions' soient connus a l'exterieur...                               */ \
                    DEFINITION_DE_LA_COMBINAISON_DE_2_POSITIONS(resultante_des_2_positions                                              \
                                                               ,resultante_des_2_vitesses                                               \
                                                               ,COMBINAISON_DE_TYPE_RESULTANTE,part1                                    \
                                                               ,COMBINAISON_DE_TYPE_RESULTANTE,part2                                    \
                                                                );                                                                      \
                                        /* Calcul de la resultante de 2 positions (scalaire et vectorielle) sans ponderation.        */

#define   DEFINITION_DE_LA_COMBINAISON_DE_3_POSITIONS(resultante_des_3_positions,resultante_des_3_vitesses,k1,part1,k2,part2,k3,part3)  \
                                        /* ATTENTION : il n'y a pas de (Bblock,Eblock) afin que 'resultante_des_3_vitesses' et       */ \
                                        /* 'resultante_des_3_positions' soient connus a l'exterieur...                               */ \
                    DEFV(pointF_3D,resultante_des_3_positions);                                                                         \
                                        /* Definition d'une position moyenne entre les 3 particules...                               */ \
                    DEFV(deltaF_3D,resultante_des_3_vitesses);                                                                          \
                                        /* Definition d'un vecteur resultante des deux vecteurs vitesse des particules incidentes ;  */ \
                                        /* il est dit "virtuel" parce que son module peut tres bien etre superieur a la vitesse de   */ \
                                        /* la lumiere, ce qui n'a aucune importance, puisque seule sa direction importe...           */ \
                    INITIALISATION_POINT_3D(resultante_des_3_positions                                                                  \
                                           ,LRZ3(k1,COORDONNEES(part1,x)                                                                \
                                                ,k2,COORDONNEES(part2,x)                                                                \
                                                ,k3,COORDONNEES(part3,x)                                                                \
                                                 )                                                                                      \
                                           ,LRZ3(k1,COORDONNEES(part1,y)                                                                \
                                                ,k2,COORDONNEES(part2,y)                                                                \
                                                ,k3,COORDONNEES(part3,y)                                                                \
                                                 )                                                                                      \
                                           ,LRZ3(k1,COORDONNEES(part1,z)                                                                \
                                                ,k2,COORDONNEES(part2,z)                                                                \
                                                ,k3,COORDONNEES(part3,z)                                                                \
                                                 )                                                                                      \
                                            );                                                                                          \
                                        /* La position resultante est choisie a mi-chemin de 'part1', 'part2' et 'part3'.            */ \
                    INITIALISATION_ACCROISSEMENT_3D(resultante_des_3_vitesses                                                           \
                                                   ,LIZ3(k1,ASI3(part1,espace_temps,vitesse,dx)                                         \
                                                        ,k2,ASI3(part2,espace_temps,vitesse,dx)                                         \
                                                        ,k3,ASI3(part3,espace_temps,vitesse,dx)                                         \
                                                         )                                                                              \
                                                   ,LIZ3(k1,ASI3(part1,espace_temps,vitesse,dy)                                         \
                                                        ,k2,ASI3(part2,espace_temps,vitesse,dy)                                         \
                                                        ,k3,ASI3(part3,espace_temps,vitesse,dy)                                         \
                                                         )                                                                              \
                                                   ,LIZ3(k1,ASI3(part1,espace_temps,vitesse,dz)                                         \
                                                        ,k2,ASI3(part2,espace_temps,vitesse,dz)                                         \
                                                        ,k3,ASI3(part3,espace_temps,vitesse,dz)                                         \
                                                         )                                                                              \
                                                    );                                                                                  \
                                        /* La vitesse resultante est choisie comme la somme arithmetique des 3 vitesses, mais        */ \
                                        /* ceci est tout a fait arbitraire, puisqu'en fait seule nous interesse une direction.       */ \
                                        /* On notera de plus que l'on utilise 'ADD3(v1,v2,v3)' et non pas la fonction relativiste    */ \
                                        /* qui n'existe pas pour 3 vitesses...                                                       */ \
                                        /*                                                                                           */ \
                                        /* calcul de la resultante de 3 positions (scalaire et vectorielle) avec ponderation.        */
#define   DEFINITION_DE_LA_RESULTANTE_DE_3_POSITIONS(resultante_des_3_positions,resultante_des_3_vitesses,part1,part2,part3)            \
                                        /* ATTENTION : il n'y a pas de (Bblock,Eblock) afin que 'resultante_des_2_vitesses' et       */ \
                                        /* 'resultante_des_2_positions' soient connus a l'exterieur...                               */ \
                    DEFINITION_DE_LA_COMBINAISON_DE_3_POSITIONS(resultante_des_3_positions                                              \
                                                               ,resultante_des_3_vitesses                                               \
                                                               ,COMBINAISON_DE_TYPE_RESULTANTE,part1                                    \
                                                               ,COMBINAISON_DE_TYPE_RESULTANTE,part2                                    \
                                                               ,COMBINAISON_DE_TYPE_RESULTANTE,part3                                    \
                                                                );                                                                      \
                                        /* Calcul de la resultante de 3 positions (scalaire et vectorielle) sans ponderation.        */



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