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

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P O U R   A S S U R E R   L A   C O M P A T I B I L I T E  :                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/champs_5.27.I"
                                        /* ATTENTION : cet include est destine uniquement a definir les deux indicateurs relatifs    */
                                        /* a la projection du rayon ; ils sont en fait inutilises dans les programmes de '$xrq'      */
                                        /* mais references par le fichier 'v $xrv/champs_5.1A$I projeter_correctement_le_rayon_'.    */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        R E N O R M A L I S A T I O N   D E S   D I F F E R E N T I E L L E S  :                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrk/attractor.1D.I"

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E S T I O N   D E S   C O U L E U R S   ( A U   S E N S   " S U B J E C T I F " )  :                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/champs_5.15.I"

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E S T I O N   D E   L A   B R U M E   E V E N T U E L L E  :                                                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/champs_5.16.I"
                                        /* ATTENTION : cette reference n'est faite que pour 'valeur_d_initialisation_du_Z_Buffer'... */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   Q U A R K S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_QUARKS                                                                                     \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_quarks,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_QUARKS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_quarks' doit absolument etre du meme      */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_QUARKS                                                                                     \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_quarks,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_QUARKS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_quarks' doit absolument etre du meme      */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_QUARKS                                                                                        \
                    FRA1(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_quarks,FRACTION_DE_LA_VITESSE_POUR_LES_QUARKS)));

#define   RAPPORT_DES_AXES_POUR_LES_QUARKS                                                                                              \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_quarks,RAPPORT_DES_AXES_POUR_LES_QUARKS)));

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   A N T I - Q U A R K S  :                                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_ANTI_QUARKS                                                                                \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_anti_quarks,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_ANTI_QUARKS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_anti_quarks' doit absolument etre du meme */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_ANTI_QUARKS                                                                                \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_anti_quarks,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_ANTI_QUARKS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_anti_quarks' doit absolument etre du meme */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_ANTI_QUARKS                                                                                   \
                    FRA1(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_anti_quarks,FRACTION_DE_LA_VITESSE_POUR_LES_ANTI_QUARKS)));

#define   RAPPORT_DES_AXES_POUR_LES_ANTI_QUARKS                                                                                         \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_anti_quarks,RAPPORT_DES_AXES_POUR_LES_ANTI_QUARKS)));

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   G L U O N S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_GLUONS                                                                                     \
                    TRENTE_DEUX
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_gluons,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_GLUONS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_gluons' doit absolument etre du meme      */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_GLUONS                                                                                     \
                    TRENTE_DEUX
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_gluons,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_GLUONS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_gluons' doit absolument etre du meme      */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_GLUONS                                                                                        \
                    FRA2(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_gluons,FRACTION_DE_LA_VITESSE_POUR_LES_GLUONS)));

#define   RAPPORT_DES_AXES_POUR_LES_GLUONS                                                                                              \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_gluons,RAPPORT_DES_AXES_POUR_LES_GLUONS)));
                                        /* Rapport du grand axe au petit axe pour un gluon. On notera qu'autrefois, on utilisait     */
                                        /* 'GRO4(FRA1(FU))' ; en fait, il est impossible de visualiser proprement les gluons en      */
                                        /* tant qu'ellipsoide projette sous forme d'une ellipse : en effet, la coordonnee 'Z' qui    */
                                        /* est essentielle pour les intersections, les eliminations de lignes cachees, mais aussi    */
                                        /* pour la coherence des paires stereoscopiques est inconnue, et de plus, elle n'est pas     */
                                        /* approximable. Dorenavant, les gluons seront donc materialises par de petites chaines      */
                                        /* de particules...                                                                          */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   E L E C T R O N S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_ELECTRONS                                                                                  \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_electrons,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_ELECTRONS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_electrons' doit absolument etre du meme   */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_ELECTRONS                                                                                  \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_electrons,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_ELECTRONS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_electrons' doit absolument etre du meme   */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_ELECTRONS                                                                                     \
                    FRA1(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_electrons,FRACTION_DE_LA_VITESSE_POUR_LES_ELECTRONS)));

#define   RAPPORT_DES_AXES_POUR_LES_ELECTRONS                                                                                           \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_electrons,RAPPORT_DES_AXES_POUR_LES_ELECTRONS)));

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   A N T I - E L E C T R O N S  :                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_ANTI_ELECTRONS                                                                             \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_anti_electrons,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_ANTI_ELECTRONS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_anti_electrons' doit absolument etre      */
                                        /* du meme type que 'nombre_negatif_de_spheres_de_materialisation'...                        */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_ANTI_ELECTRONS                                                                             \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_anti_electrons,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_ANTI_ELECTRONS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_anti_electrons' doit absolument etre      */
                                        /* du meme type que 'nombre_positif_de_spheres_de_materialisation'...                        */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_ANTI_ELECTRONS                                                                                \
                    FRA1(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_anti_electrons,FRACTION_DE_LA_VITESSE_POUR_LES_ANTI_ELECTRONS)));

#define   RAPPORT_DES_AXES_POUR_LES_ANTI_ELECTRONS                                                                                      \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_anti_electrons,RAPPORT_DES_AXES_POUR_LES_ANTI_ELECTRONS)));

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   N E U T R I N O S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_NEUTRINOS                                                                                  \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_neutrinos,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_NEUTRINOS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_neutrinos' doit absolument etre du meme   */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_NEUTRINOS                                                                                  \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_neutrinos,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_NEUTRINOS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_neutrinos' doit absolument etre du meme   */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_NEUTRINOS                                                                                     \
                    FRA2(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_neutrinos,FRACTION_DE_LA_VITESSE_POUR_LES_NEUTRINOS)));

#define   RAPPORT_DES_AXES_POUR_LES_NEUTRINOS                                                                                           \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_neutrinos,RAPPORT_DES_AXES_POUR_LES_NEUTRINOS)));
                                        /* Rapport du grand axe au petit axe pour un neutrino.                                       */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   P H O T O N S  :                                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_PHOTONS                                                                                    \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_photons,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_PHOTONS)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_photons' doit absolument etre du meme     */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
                                        /*                                                                                           */
                                        /* ATTENTION, afin d'eliminer le probleme de l'apparence visuelle d'une chaine de spheres    */
                                        /* qui s'agglutinent (la derniere tracee l'emporte visuellement sur les autres, la surface   */
                                        /* cylindique obtenue n'est donc pas uniforme...) on ramene les photons a une seule sphere.  */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_PHOTONS                                                                                    \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_photons,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_PHOTONS)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_photons' doit absolument etre du meme     */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */
                                        /*                                                                                           */
                                        /* ATTENTION, afin d'eliminer le probleme de l'apparence visuelle d'une chaine de spheres    */
                                        /* qui s'agglutinent (la derniere tracee l'emporte visuellement sur les autres, la surface   */
                                        /* cylindique obtenue n'est donc pas uniforme...) on ramene les photons a une seule sphere.  */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_PHOTONS                                                                                       \
                    FRA2(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_photons,FRACTION_DE_LA_VITESSE_POUR_LES_PHOTONS)));

#define   RAPPORT_DES_AXES_POUR_LES_PHOTONS                                                                                             \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_photons,RAPPORT_DES_AXES_POUR_LES_PHOTONS)));
                                        /* Rapport du grand axe au petit axe pour un photon. On notera qu'autrefois, on utilisait    */
                                        /* 'GRO4(FRA1(FU))' ; en fait, il est impossible de visualiser proprement les photons en     */
                                        /* tant qu'ellipsoide projette sous forme d'une ellipse : en effet, la coordonnee 'Z' qui    */
                                        /* est essentielle pour les intersections, les eliminations de lignes cachees, mais aussi    */
                                        /* pour la coherence des paires stereoscopiques est inconnue, et de plus, elle n'est pas     */
                                        /* approximable. Dorenavant, les photons seront donc materialises par de petites chaines     */
                                        /* de particules...                                                                          */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N                                              */
/*        D E S   Z 0 S  :                                                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_Z0S                                                                                        \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_negatif_de_spheres_pour_les_z0s,NOMBRE_NEGATIF_DE_SPHERES_POUR_LES_Z0S)));
                                        /* ATTENTION : 'nombre_negatif_de_spheres_pour_les_z0s' doit absolument etre du meme         */
                                        /* type que 'nombre_negatif_de_spheres_de_materialisation'...                                */
#define   NOMBRE_POSITIF_DE_SPHERES_POUR_LES_Z0S                                                                                        \
                    ZERO
DEFV(Local,DEFV(Int,INIT(nombre_positif_de_spheres_pour_les_z0s,NOMBRE_POSITIF_DE_SPHERES_POUR_LES_Z0S)));
                                        /* ATTENTION : 'nombre_positif_de_spheres_pour_les_z0s' doit absolument etre du meme         */
                                        /* type que 'nombre_positif_de_spheres_de_materialisation'...                                */

#define   FRACTION_DE_LA_VITESSE_POUR_LES_Z0S                                                                                           \
                    FRA2(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(fraction_de_la_vitesse_pour_les_z0s,FRACTION_DE_LA_VITESSE_POUR_LES_Z0S)));

#define   RAPPORT_DES_AXES_POUR_LES_Z0S                                                                                                 \
                    FZERO
DEFV(Local,DEFV(Float,INIT(rapport_des_axes_pour_les_z0s,RAPPORT_DES_AXES_POUR_LES_Z0S)));
                                        /* Rapport du grand axe au petit axe pour un z0.                                             */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   S P H E R E S   R E P R E S E N T A T I V E S  :                                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   RAYON_DE_VISUALISATION_D_UN_QUARK_REEL                                                                                        \
                    FRA2(FRA10(RAYON_D_UN_HADRON))                                                                                      \
                                        /* Rayon du disque materialisant un quark ou un anti-quark REEL,                             */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_quark_REEL,RAYON_DE_VISUALISATION_D_UN_QUARK_REEL)));
                                        /* Rayon du disque materialisant un quark ou un anti-quark REEL,                             */
#define   RAYON_DE_VISUALISATION_D_UN_QUARK_VIRTUEL                                                                                     \
                    RAYON_DE_VISUALISATION_D_UN_QUARK_REEL                                                                              \
                                        /* Rayon du disque materialisant un quark ou un anti-quark VIRTUEL.                          */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_quark_VIRTUEL,RAYON_DE_VISUALISATION_D_UN_QUARK_VIRTUEL)));
                                        /* Rayon du disque materialisant un quark ou un anti-quark VIRTUEL.                          */

#define   RAYON_DE_VISUALISATION_D_UN_GLUON                                                                                             \
                    GRO1(FRA4(RAYON_DE_VISUALISATION_D_UN_QUARK_VIRTUEL))                                                               \
                                        /* Rayon du disque materialisant un gluon ; en fait, et plus recemment, il s'agit du petit   */ \
                                        /* axe de l'ellipse le materialisant...                                                      */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_gluon,RAYON_DE_VISUALISATION_D_UN_GLUON)));
                                        /* Rayon du disque materialisant un gluon.                                                   */

#define   RAYON_DE_VISUALISATION_D_UN_ELECTRON_REEL                                                                                     \
                    GRO4(FRA3(FRA10(RAYON_D_UN_HADRON)))                                                                                \
                                        /* Rayon du disque materialisant un electron ou un anti-electron REEL,                       */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_electron_REEL,RAYON_DE_VISUALISATION_D_UN_ELECTRON_REEL)));
                                        /* Rayon du disque materialisant un electron ou un anti-electron REEL,                       */
#define   RAYON_DE_VISUALISATION_D_UN_ELECTRON_VIRTUEL                                                                                  \
                    RAYON_DE_VISUALISATION_D_UN_ELECTRON_REEL                                                                           \
                                        /* Rayon du disque materialisant un electron ou un anti-electron VIRTUEL.                    */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_electron_VIRTUEL,RAYON_DE_VISUALISATION_D_UN_ELECTRON_VIRTUEL)));
                                        /* Rayon du disque materialisant un electron ou un anti-electron VIRTUEL.                    */

#define   RAYON_DE_VISUALISATION_D_UN_NEUTRINO                                                                                          \
                    GRO9(FRA16(RAYON_DE_VISUALISATION_D_UN_ELECTRON_VIRTUEL))                                                           \
                                        /* Rayon du disque materialisant un neutrino ; en fait, et plus recemment, il s'agit         */ \
                                        /* du petit axe de l'ellipse le materialisant...                                             */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_neutrino,RAYON_DE_VISUALISATION_D_UN_NEUTRINO)));
                                        /* Rayon du disque materialisant un neutrino.                                                */

#define   RAYON_DE_VISUALISATION_D_UN_PHOTON                                                                                            \
                    GRO9(FRA16(RAYON_DE_VISUALISATION_D_UN_ELECTRON_VIRTUEL))                                                           \
                                        /* Rayon du disque materialisant un photon ; en fait, et plus recemment, il s'agit du petit  */ \
                                        /* axe de l'ellipse le materialisant...                                                      */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_photon,RAYON_DE_VISUALISATION_D_UN_PHOTON)));
                                        /* Rayon du disque materialisant un photon.                                                  */

#define   AMPLITUDE_DE_PULSATION_D_UN_PHOTON                                                                                            \
                    FDU
DEFV(Local,DEFV(Float,INIT(amplitude_de_pulsation_d_un_photon,AMPLITUDE_DE_PULSATION_D_UN_PHOTON)));
                                        /* Facteur dans [0,1] permettant de faire pulser periodiquement un photon...                 */
#define   PERIODE_DE_PULSATION_D_UN_PHOTON                                                                                              \
                    GRO2(GRO10(PERIODE_INITIALE_DE_L_HORLOGE))
DEFV(Local,DEFV(Float,INIT(periode_de_pulsation_d_un_photon,PERIODE_DE_PULSATION_D_UN_PHOTON)));
                                        /* Periode permettant de faire pulser periodiquement un photon...                            */
#define   PHASE_DE_PULSATION_D_UN_PHOTON                                                                                                \
                    FZERO
DEFV(Local,DEFV(Float,INIT(phase_de_pulsation_d_un_photon,PHASE_DE_PULSATION_D_UN_PHOTON)));
                                        /* Phase permettant de faire pulser periodiquement un photon...                              */

#define   PULSATION_D_UN_PHOTON(photon,composante)                                                                                      \
                    MUL2(AXPB(NEGA(amplitude_de_pulsation_d_un_photon)                                                                  \
                             ,MOIT(ADD2(FU                                                                                              \
                                       ,COSX(AXPB(DIVI(CERCLE_TRIGONOMETRIQUE,periode_de_pulsation_d_un_photon)                         \
                                                 ,AGE(photon)                                                                           \
                                                 ,phase_de_pulsation_d_un_photon                                                        \
                                                  )                                                                                     \
                                             )                                                                                          \
                                        )                                                                                               \
                                   )                                                                                                    \
                             ,FU                                                                                                        \
                              )                                                                                                         \
                        ,composante                                                                                                     \
                         )                                                                                                              \
                                        /* Fonction de pulsation des composantes chromatiques d'un photon ; la loi utilisee est du   */ \
                                        /* type :                                                                                    */ \
                                        /*                                                                                           */ \
                                        /*                                      1 + cos(OMEGA.t+PHASE)                               */ \
                                        /*                  composante.[1 - A.(------------------------)                             */ \
                                        /*                                                 2                                         */ \
                                        /*                                                                                           */ \
                                        /* ou 'OMEGA' vaut deux pi sur la periode, et 't' represente l'age du photon...              */

#define   RAYON_DE_VISUALISATION_D_UN_Z0                                                                                                \
                    GRO9(FRA16(RAYON_DE_VISUALISATION_D_UN_ELECTRON_VIRTUEL))                                                           \
                                        /* Rayon du disque materialisant un z0 ; en fait, et plus recemment, il s'agit               */ \
                                        /* du petit axe de l'ellipse le materialisant...                                             */
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation_d_un_z0,RAYON_DE_VISUALISATION_D_UN_Z0)));
                                        /* Rayon du disque materialisant un z0.                                                      */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N D I C A T E U R   D E   C O N T R O L E   D E   V I S U A L I S A T I O N   S E L E C T I V E  :                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
#    define    VISUALISER_LES_QUARKS_REELS                                                                                              \
                         VRAI
#Aifdef   __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
#    define    VISUALISER_LES_QUARKS_REELS                                                                                              \
                         FAUX
#Eifdef   __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE

DEFV(Local,DEFV(Logical,INIT(visualiser_les_quarks_REELs,VISUALISER_LES_QUARKS_REELS)));
#define   VISUALISER_LES_QUARKS_VIRTUELS                                                                                                \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_quarks_VIRTUELs,VISUALISER_LES_QUARKS_VIRTUELS)));

#ifdef    __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
#    define    VISUALISER_LES_ANTI_QUARKS_REELS                                                                                         \
                         VRAI
#Aifdef   __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE
#    define    VISUALISER_LES_ANTI_QUARKS_REELS                                                                                         \
                         FAUX
#Eifdef   __VERSION__LES_PARTICULES_REELLES_SONT_SOUMISES_A_L_INTERACTION_FORTE

DEFV(Local,DEFV(Logical,INIT(visualiser_les_anti_quarks_REELs,VISUALISER_LES_ANTI_QUARKS_REELS)));
#define   VISUALISER_LES_ANTI_QUARKS_VIRTUELS                                                                                           \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_anti_quarks_VIRTUELs,VISUALISER_LES_ANTI_QUARKS_VIRTUELS)));

#define   VISUALISER_LES_GLUONS_REELS                                                                                                   \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_gluons_REELs,VISUALISER_LES_GLUONS_REELS)));
#define   VISUALISER_LES_GLUONS_VIRTUELS                                                                                                \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_gluons_VIRTUELs,VISUALISER_LES_GLUONS_VIRTUELS)));

#define   VISUALISER_LES_ELECTRONS_REELS                                                                                                \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_electrons_REELs,VISUALISER_LES_ELECTRONS_REELS)));
#define   VISUALISER_LES_ELECTRONS_VIRTUELS                                                                                             \
                    VRAI

DEFV(Local,DEFV(Logical,INIT(visualiser_les_electrons_VIRTUELs,VISUALISER_LES_ELECTRONS_VIRTUELS)));
#define   VISUALISER_LES_ANTI_ELECTRONS_REELS                                                                                           \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_anti_electrons_REELs,VISUALISER_LES_ANTI_ELECTRONS_REELS)));
#define   VISUALISER_LES_ANTI_ELECTRONS_VIRTUELS                                                                                        \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_anti_electrons_VIRTUELs,VISUALISER_LES_ANTI_ELECTRONS_VIRTUELS)));

#define   VISUALISER_LES_NEUTRINOS_REELS                                                                                                \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_neutrinos_REELs,VISUALISER_LES_NEUTRINOS_REELS)));
#define   VISUALISER_LES_NEUTRINOS_VIRTUELS                                                                                             \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_neutrinos_VIRTUELs,VISUALISER_LES_NEUTRINOS_VIRTUELS)));

#define   VISUALISER_LES_PHOTONS_REELS                                                                                                  \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_photons_REELs,VISUALISER_LES_PHOTONS_REELS)));
#define   VISUALISER_LES_PHOTONS_VIRTUELS                                                                                               \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_photons_VIRTUELs,VISUALISER_LES_PHOTONS_VIRTUELS)));

#define   VISUALISER_LES_Z0S_REELS                                                                                                      \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_z0s_REELs,VISUALISER_LES_Z0S_REELS)));
#define   VISUALISER_LES_Z0S_VIRTUELS                                                                                                   \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(visualiser_les_z0s_VIRTUELs,VISUALISER_LES_Z0S_VIRTUELS)));

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P R O C E D U R E S   S P E C I F I Q U E S   D E   V I S U A L I S A T I O N  :                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   VISUALISATION_D_UN_QUARK(quark)                                                                                               \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(quark),QUARK_REEL)                                                                       \
                                  ,IL_FAUT(visualiser_les_quarks_REELs)                                                                 \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(quark),QUARK_VIRTUEL)                                                                    \
                                  ,IL_FAUT(visualiser_les_quarks_VIRTUELs)                                                              \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(quark                                                                       \
                                                           ,rapport_des_axes_pour_les_quarks                                            \
                                                           ,nombre_negatif_de_spheres_pour_les_quarks                                   \
                                                           ,nombre_positif_de_spheres_pour_les_quarks                                   \
                                                           ,fraction_de_la_vitesse_pour_les_quarks                                      \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un quark...                                                               */
#define   VISUALISATION_D_UN_ANTI_QUARK(anti_quark)                                                                                     \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(anti_quark),ANTI_QUARK_REEL)                                                             \
                                  ,IL_FAUT(visualiser_les_anti_quarks_REELs)                                                            \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(anti_quark),ANTI_QUARK_VIRTUEL)                                                          \
                                  ,IL_FAUT(visualiser_les_anti_quarks_VIRTUELs)                                                         \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(anti_quark                                                                  \
                                                           ,rapport_des_axes_pour_les_anti_quarks                                       \
                                                           ,nombre_negatif_de_spheres_pour_les_anti_quarks                              \
                                                           ,nombre_positif_de_spheres_pour_les_anti_quarks                              \
                                                           ,fraction_de_la_vitesse_pour_les_anti_quarks                                 \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un anti-quark...                                                          */

#define   VISUALISATION_D_UN_GLUON(gluon)                                                                                               \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(gluon),GLUON_REEL)                                                                       \
                                  ,IL_FAUT(visualiser_les_gluons_REELs)                                                                 \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(gluon),GLUON_VIRTUEL)                                                                    \
                                  ,IL_FAUT(visualiser_les_gluons_VIRTUELs)                                                              \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(gluon                                                                       \
                                                           ,rapport_des_axes_pour_les_gluons                                            \
                                                           ,nombre_negatif_de_spheres_pour_les_gluons                                   \
                                                           ,nombre_positif_de_spheres_pour_les_gluons                                   \
                                                           ,fraction_de_la_vitesse_pour_les_gluons                                      \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un gluon...                                                               */

#define   VISUALISATION_D_UN_ELECTRON(electron)                                                                                         \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(electron),ELECTRON_REEL)                                                                 \
                                  ,IL_FAUT(visualiser_les_electrons_REELs)                                                              \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(electron),ELECTRON_VIRTUEL)                                                              \
                                  ,IL_FAUT(visualiser_les_electrons_VIRTUELs)                                                           \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(electron                                                                    \
                                                           ,rapport_des_axes_pour_les_electrons                                         \
                                                           ,nombre_negatif_de_spheres_pour_les_electrons                                \
                                                           ,nombre_positif_de_spheres_pour_les_electrons                                \
                                                           ,fraction_de_la_vitesse_pour_les_electrons                                   \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un electron...                                                            */
#define   VISUALISATION_D_UN_ANTI_ELECTRON(anti_electron)                                                                               \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(anti_electron),ANTI_ELECTRON_REEL)                                                       \
                                  ,IL_FAUT(visualiser_les_anti_electrons_REELs)                                                         \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(anti_electron),ANTI_ELECTRON_VIRTUEL)                                                    \
                                  ,IL_FAUT(visualiser_les_anti_electrons_VIRTUELs)                                                      \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(anti_electron                                                               \
                                                           ,rapport_des_axes_pour_les_anti_electrons                                    \
                                                           ,nombre_negatif_de_spheres_pour_les_anti_electrons                           \
                                                           ,nombre_positif_de_spheres_pour_les_anti_electrons                           \
                                                           ,fraction_de_la_vitesse_pour_les_anti_electrons                              \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un anti-electron...                                                       */

#define   VISUALISATION_D_UN_NEUTRINO(neutrino)                                                                                         \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(neutrino),NEUTRINO_REEL)                                                                 \
                                  ,IL_FAUT(visualiser_les_neutrinos_REELs)                                                              \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(neutrino),NEUTRINO_VIRTUEL)                                                              \
                                  ,IL_FAUT(visualiser_les_neutrinos_VIRTUELs)                                                           \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(neutrino                                                                    \
                                                           ,rapport_des_axes_pour_les_neutrinos                                         \
                                                           ,nombre_negatif_de_spheres_pour_les_neutrinos                                \
                                                           ,nombre_positif_de_spheres_pour_les_neutrinos                                \
                                                           ,fraction_de_la_vitesse_pour_les_neutrinos                                   \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un neutrino...                                                            */

#define   VISUALISATION_D_UN_PHOTON(photon)                                                                                             \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(photon),PHOTON_REEL)                                                                     \
                                  ,IL_FAUT(visualiser_les_photons_REELs)                                                                \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(photon),PHOTON_VIRTUEL)                                                                  \
                                  ,IL_FAUT(visualiser_les_photons_VIRTUELs)                                                             \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         DEFV(charge_de_couleur,couleur_du_photon);                                                                     \
                         EGAL(ASD1(couleur_du_photon,ROUGE),cCOULEUR(photon,ROUGE));                                                    \
                         EGAL(ASD1(couleur_du_photon,VERTE),cCOULEUR(photon,VERTE));                                                    \
                         EGAL(ASD1(couleur_du_photon,BLEUE),cCOULEUR(photon,BLEUE));                                                    \
                                        /* Sauvegarde de la couleur "originale" du photon...                                         */ \
                         COULEUR_D_UNE_PARTICULE(photon                                                                                 \
                                                ,PULSATION_D_UN_PHOTON(photon,cCOULEUR(photon,ROUGE))                                   \
                                                ,PULSATION_D_UN_PHOTON(photon,cCOULEUR(photon,VERTE))                                   \
                                                ,PULSATION_D_UN_PHOTON(photon,cCOULEUR(photon,BLEUE))                                   \
                                                 );                                                                                     \
                                        /* Pulsation eventuelle de la couleur du photon...                                           */ \
                         CALS(visualisation_d_une_particule(photon                                                                      \
                                                           ,rapport_des_axes_pour_les_photons                                           \
                                                           ,nombre_negatif_de_spheres_pour_les_photons                                  \
                                                           ,nombre_positif_de_spheres_pour_les_photons                                  \
                                                           ,fraction_de_la_vitesse_pour_les_photons                                     \
                                                            )                                                                           \
                              );                                                                                                        \
                         COULEUR_D_UNE_PARTICULE(photon                                                                                 \
                                                ,ASD1(couleur_du_photon,ROUGE)                                                          \
                                                ,ASD1(couleur_du_photon,VERTE)                                                          \
                                                ,ASD1(couleur_du_photon,BLEUE)                                                          \
                                                 );                                                                                     \
                                        /* Restauration de la couleur "originale" du photon...                                       */ \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un photon...                                                              */

#define   VISUALISATION_D_UN_Z0(z0)                                                                                                     \
                    Bblock                                                                                                              \
                    Test(IFOU(IFET(IFEQ(NATURE(z0),Z0_REEL)                                                                             \
                                  ,IL_FAUT(visualiser_les_z0s_REELs)                                                                    \
                                   )                                                                                                    \
                             ,IFET(IFEQ(NATURE(z0),Z0_VIRTUEL)                                                                          \
                                  ,IL_FAUT(visualiser_les_z0s_VIRTUELs)                                                                 \
                                   )                                                                                                    \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         CALS(visualisation_d_une_particule(z0                                                                          \
                                                           ,rapport_des_axes_pour_les_z0s                                               \
                                                           ,nombre_negatif_de_spheres_pour_les_z0s                                      \
                                                           ,nombre_positif_de_spheres_pour_les_z0s                                      \
                                                           ,fraction_de_la_vitesse_pour_les_z0s                                         \
                                                            )                                                                           \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Visualisation d'un z0...                                                                  */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E S T I O N   D E   L A   L I S T E   D E S   P O I N T S   D E S T I N E E   A   F A I R E   U N   T R I                */
/*        S U R   L A   C O O R D O N N E E   ' Z '   D ' A R R I E R E   E N   A V A N T   P O U R   L U T T E R                    */
/*        E F F I C A C E M E N T   C O N T R E   L ' A L I A S I N G  :                                                             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/champs_5.11.I"

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N   D E   V I S U A L I S A T I O N   D U   P O I N T   C O U R A N T  :                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/champs_5.1C.I"
                                        /* Cette appel rend donc dorenavant l'appel a '$xrq/nucleon.LS$I' inutile, puisque la        */
                                        /* definition de 'store_ellipsoide(...)' est remplacee par 'store_sphere(...)'.              */

#include  xrv/champs_5.12.I"

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F O N C T I O N   C E N T R A L E   D E   V I S U A L I S A T I O N   Q U I   E N   F A I T                                */
/*        M E M O R I S E   L ' E N S E M B L E   D E S   S P H E R E S   C O N S T I T U T I V E S  :                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrk/attractor.24.I"
                                        /* Par compatibilite avec 'MEMORISATION_D_UN_POINT(...)'...                                  */

#define   COORDONNEES_DE_MATERIALISATION(particule,Ccomposante,Vcomposante)                                                             \
                    ADD2(COORDONNEES(particule,Ccomposante)                                                                             \
                        ,MUL2(tiSCALE(MUL2(MUL2(ASI3(particule,espace_temps,vitesse,Vcomposante)                                        \
                                               ,fraction_de_la_vitesse                                                                  \
                                                )                                                                                       \
                                          ,PERIODE_COURANTE_DE_L_HORLOGE                                                                \
                                           )                                                                                            \
                                      )                                                                                                 \
                             ,FLOT(numero_de_la_sphere_de_materialisation)                                                              \
                              )                                                                                                         \
                         )                                                                                                              \
                                        /* Passage d'une sphere de materialisation a la suivante le long du vecteur vitesse de la    */ \
                                        /* particule lorsqu'une chaine de sphere materialise une particule. Le pas spatial est egal  */ \
                                        /* a la distance parcourue pendant 'PERIODE_COURANTE_DE_L_HORLOGE' par la particule courante */ \
                                        /* en supposant qu'elle se deplace a une vitesse egale a 'fraction_de_la_vitesse' de sa      */ \
                                        /* vitesse courante. On notera que la formule ci-dessus suppose que la sphere qui occupe     */ \
                                        /* la meme position que la particule (toutes deux ont le meme centre) a le numero 0...       */

#define   NATU(particule_courante,nature_courante,nom_de_la_nature_courante)                                                            \
                    Bblock                                                                                                              \
                    Test(IFEQ(NATURE(particule_courante),nature_courante))                                                              \
                         Bblock                                                                                                         \
                         BASE_DE_DONNEES(Prin1("%s",nom_de_la_nature_courante));                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Procedure introduite uniquement pour reduire la longueur des lignes de generation de la   */ \
                                        /* base de donnees...                                                                        */
#define   SAVE(particule_courante,saveur_courante,nom_de_la_saveur_courante)                                                            \
                    Bblock                                                                                                              \
                    Test(IFEQ(SAVEUR(particule_courante),saveur_courante))                                                              \
                         Bblock                                                                                                         \
                         BASE_DE_DONNEES(Prin1("%s",nom_de_la_saveur_courante));                                                        \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Procedure introduite uniquement pour reduire la longueur des lignes de generation de la   */ \
                                        /* base de donnees...                                                                        */

BFonctionI

DEFV(Local,DEFV(FonctionI,visualisation_d_une_particule(ARGUMENT_POINTERs(particule_courante)
                                                       ,rapport_des_axes_de_la_particule
                                                       ,nombre_negatif_de_spheres_de_materialisation
                                                       ,nombre_positif_de_spheres_de_materialisation
                                                       ,fraction_de_la_vitesse
                                                        )
                )
     )
DEFV(Argument,DEFV(particule,POINTERs(particule_courante)));
                                        /* Definition de la particule a visualiser.                                                  */
DEFV(Argument,DEFV(Float,rapport_des_axes_de_la_particule));
                                        /* Definition du rapport entre le grand axe et le petit axe de l'ellipsoide representatif,   */
                                        /* et ce a une unite pres (voir le calcul de 'grand_axe_de_la_particule_visualisee').        */
DEFV(Argument,DEFV(Int,nombre_negatif_de_spheres_de_materialisation));
DEFV(Argument,DEFV(Int,nombre_positif_de_spheres_de_materialisation));
                                        /* Si 'Sn' et 'Sp' designent respectivement 'nombre_negatif_de_spheres_de_materialisation',  */
                                        /* 'nombre_positif_de_spheres_de_materialisation', le nombre de spheres qui seront utilisees */
                                        /* pour visualiser la particule courante sera alors 'Sn+Sp+1'.                               */
                                        /*                                                                                           */
                                        /* ATTENTION : il serait logique que 'nombre_positif_de_spheres_de_materialisation' et       */
                                        /* 'nombre_negatif_de_spheres_de_materialisation' soient du type 'Positive', mais ce dernier */
                                        /* etant utilise dans un 'DoIn(...)' avec la fonction 'NEGA(...)', il est imperatif qu'ils   */
                                        /* soient signes et donc du type 'Int' (ce que l'on fait pour l'un, on le fait aussi pour    */
                                        /* l'autre par symetrie...).                                                                 */
DEFV(Argument,DEFV(Float,fraction_de_la_vitesse));
                                        /* Le passage d'une sphere de materialisation a la suivante se fera a l'aide d'une fraction  */
                                        /* du vecteur vitesse qui est donnee par ce parametre. Voir pour plus de precisions le       */
                                        /* commentaire qui suit le 'DoIn(...)' correspondant...                                      */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(Int,INIT(numero_de_la_sphere_de_materialisation,UNDEF));
                                        /* Numero de la sphere courante de materialisation dans [-Sn,+Sp] (voir la definition de     */
                                        /* de 'Sn' et 'Sp' avec les arguments 'nombre_negatif_de_spheres_de_materialisation' et      */
                                        /* 'nombre_positif_de_spheres_de_materialisation'). Le numero '0' correspond a la position   */
                                        /* "reelle" de la particule.                                                                 */
     DEFV(Float,INIT(Xf,FLOT__UNDEF));
     DEFV(Float,INIT(Yf,FLOT__UNDEF));
     DEFV(Float,INIT(Zf,FLOT__UNDEF));
                                        /* Pour definir les coordonnees {x,y,z} de la particule dans [0,1] ; cette facon de          */
                                        /* proceder est liee au fait que d'introduire directement les expressions du type :          */
                                        /* 'X_PHYSIQUE_DANS_01(...)' dans 'store_point_3D(...)' conduit a generer des expressions    */
                                        /* trop longues a compiler...                                                                */
     DEFV(Float,INIT(module_de_la_vitesse_de_la_particule,FLOT__UNDEF));
                                        /* Module de la vitesse de la particule.                                                     */
     DEFV(deltaF_3D,vitesse_normalisee_de_la_particule);
                                        /* Definition de la vitesse normalisee de la particule.                                      */
     DEFV(Float,INIT(Xf_de_la_vitesse,FLOT__UNDEF));
     DEFV(Float,INIT(Yf_de_la_vitesse,FLOT__UNDEF));
     DEFV(Float,INIT(Zf_de_la_vitesse,FLOT__UNDEF));
                                        /* Definition de l'extremite du vecteur vitesse de la particule dans [0.1].                  */
     DEFV(deltaF_2D,vitesse_projetee_de_la_particule);
                                        /* Definition des composantes dans [0,1] de la vitesse projetee de la particule.             */
     DEFV(Float,INIT(module_de_la_vitesse_projetee_de_la_particule,FLOT__UNDEF));
                                        /* Module normalise de la vitesse projetee de la particule.                                  */
     DEFV(Float,INIT(Yf_au_pole_nord_de_la_sphere,FLOT__UNDEF));
                                        /* Definition de la coordonnee 'y' au pole de la particule dans [0,1].                       */
     DEFV(Float,INIT(rayon_de_la_particule
                    ,fCOND(IFOU(IFEQ(NATURE(particule_courante),QUARK_REEL)
                               ,IFEQ(NATURE(particule_courante),ANTI_QUARK_REEL)
                                )
                          ,rayon_de_visualisation_d_un_quark_REEL
                          ,fCOND(IFOU(IFEQ(NATURE(particule_courante),QUARK_VIRTUEL)
                                     ,IFEQ(NATURE(particule_courante),ANTI_QUARK_VIRTUEL)
                                      )
                                ,rayon_de_visualisation_d_un_quark_VIRTUEL
                                ,fCOND(IFOU(IFEQ(NATURE(particule_courante),GLUON_REEL)
                                           ,IFEQ(NATURE(particule_courante),GLUON_VIRTUEL)
                                            )
                                      ,rayon_de_visualisation_d_un_gluon
                                      ,fCOND(IFOU(IFEQ(NATURE(particule_courante),ELECTRON_REEL)
                                                 ,IFEQ(NATURE(particule_courante),ANTI_ELECTRON_REEL)
                                                  )
                                            ,rayon_de_visualisation_d_un_electron_REEL
                                            ,fCOND(IFOU(IFEQ(NATURE(particule_courante),ELECTRON_VIRTUEL)
                                                       ,IFEQ(NATURE(particule_courante),ANTI_ELECTRON_VIRTUEL)
                                                        )
                                                  ,rayon_de_visualisation_d_un_electron_VIRTUEL
                                                  ,fCOND(IFOU(IFEQ(NATURE(particule_courante),NEUTRINO_REEL)
                                                             ,IFEQ(NATURE(particule_courante),NEUTRINO_VIRTUEL)
                                                              )
                                                        ,rayon_de_visualisation_d_un_neutrino
                                                        ,fCOND(IFOU(IFEQ(NATURE(particule_courante),PHOTON_REEL)
                                                                   ,IFEQ(NATURE(particule_courante),PHOTON_VIRTUEL)
                                                                    )
                                                              ,rayon_de_visualisation_d_un_photon
                                                              ,fCOND(IFOU(IFEQ(NATURE(particule_courante),Z0_REEL)
                                                                         ,IFEQ(NATURE(particule_courante),Z0_VIRTUEL)
                                                                          )
                                                                    ,rayon_de_visualisation_d_un_z0
                                                                    ,FLOT__UNDEF
                                                                     )
                                                               )
                                                         )
                                                   )
                                             )
                                       )
                                 )
                           )
                     )
          );
                                        /* Rayon de la particule dans l'espace physique (introduit pour simplifier le travail du     */
                                        /* compilateur...).                                                                          */
     DEFV(Float,INIT(petit_axe_de_la_particule_visualisee,FLOT__UNDEF));
     DEFV(Float,INIT(grand_axe_de_la_particule_visualisee,FLOT__UNDEF));
                                        /* Petit axe et grand axe de l'ellipsoide visualisant une particule. ATTENTION : ils ne sont */
                                        /* conserves que pour des raisons historiques, puisqu'aujourd'hui on ne trace plus que des   */
                                        /* spheres...                                                                                */
     DEFV(Float,INIT(rayon_de_visualisation_projete,FLOT__UNDEF));
                                        /* Rayon de la particule dans [0,1] apres projection.                                        */
     DEFV(Float,INIT(charge_ROUGE,cCOULEUR(particule_courante,ROUGE)));
     DEFV(Float,INIT(charge_VERTE,cCOULEUR(particule_courante,VERTE)));
     DEFV(Float,INIT(charge_BLEUE,cCOULEUR(particule_courante,BLEUE)));
                                        /* Charge de couleur de la particule courante.                                               */

                                        /* ATTENTION, il y avait autrefois (avant l'introduction de '$xrv/champs_5.11$I' et de       */
                                        /* '$xrv/champs_5.12$I') :                                                                   */
                                        /*                                                                                           */
                                        /*                  DEFV(Float,INIT(charge_ROUGE_attenuee,COULEUR_indefinie));               */
                                        /*                  DEFV(Float,INIT(charge_VERTE_attenuee,COULEUR_indefinie));               */
                                        /*                  DEFV(Float,INIT(charge_BLEUE_attenuee,COULEUR_indefinie));               */
                                        /*                                      /* charge de couleur de la particule courante apres  */
                                        /*                                      /* attenuation par la fonction de "depth-cueing".    */
                                        /*                  DEFV(Float,INIT(charge_ROUGE_normalisee,COULEUR_indefinie));             */
                                        /*                  DEFV(Float,INIT(charge_VERTE_normalisee,COULEUR_indefinie));             */
                                        /*                  DEFV(Float,INIT(charge_BLEUE_normalisee,COULEUR_indefinie));             */
                                        /*                                      /* charge de couleur de la particule courante : elle */
                                        /*                                      /* est dupliquee afin d'accelerer la compilation.    */
                                        /*                                                                                           */

     INIT_ERROR;
     /*..............................................................................................................................*/
     Test(I3ET(IFEQ(COORDONNEES(particule_courante,x),ASD1(position_indefinie,x))
              ,IFEQ(COORDONNEES(particule_courante,y),ASD1(position_indefinie,y))
              ,IFEQ(COORDONNEES(particule_courante,z),ASD1(position_indefinie,z))
               )
          )
          Bblock
          PROCESSUS_INCOMPLET("nous sommes en presence d'une particule non definie");
          Eblock
     ATes
          Bblock
          DoIn(numero_de_la_sphere_de_materialisation
              ,NEGA(nombre_negatif_de_spheres_de_materialisation)
              ,NEUT(nombre_positif_de_spheres_de_materialisation)
              ,I
               )
                                        /* L'unite de base de la visualisation des particules est la sphere ; on offre ici la        */
                                        /* possibilite d'enrichir cette representation, en les materialisant (en fait cela n'est     */
                                        /* utilise que pour les gluons) par une chaine de 'Sn+Sp+1' spheres centree sur la position  */
                                        /* courante de la particule (donnee par 'COORDONNEES(...)') et disposees sur la direction    */
                                        /* du vecteur vitesse. Le nombre de spheres a utiliser est donne par les arguments           */
                                        /* 'Sn' et 'Sp' definis ci-dessus, alors que l'espacement des spheres le long du vecteur     */
                                        /* vitesse est exprime en une fraction 'fraction_de_la_vitesse' de ce meme vecteur vitesse   */
                                        /* convertit en une distance parcourue pendant la duree 'PERIODE_COURANTE_DE_L_HORLOGE'.     */
                                        /*                                                                                           */
                                        /*                  Position courante de la particule ___                                    */
                                        /*                                                       |                      -->          */
                                        /*                                                      \|/             vitesse  V           */
                                        /*                                                       .                                   */
                                        /*                                                       *===================>               */
                                        /*                                                       :                                   */
                                        /*                  Visualisation de la particule :      :                                   */
                                        /*                                                       :                                   */
                                        /*                                                 *  *  *  *  *  *  *                       */
                                        /*                                                 2  1  0 /1  2\ 3  4                       */
                                        /*                                                (-)     /      \  (+)                      */
                                        /*                                                       /        \                          */
                                        /*                                                      /          \                         */
                                        /*                                                      <---------->                         */
                                        /*                                                fraction.vitesse.periode                   */
                                        /*                                                                                           */
                                        /* (l'exemple ci-dessus suppose Sn=2 et Sp=4, et chaque '*' represente une sphere).          */
                                        /*                                                                                           */
                                        /* On notera que cette methode, par rapport a celle des ellipsoides projetes, a de nombreux  */
                                        /* avantages ; en particulier, elle permettra, si cela s'avere utile (voir par exemple le    */
                                        /* probleme de la visualisation de la charge d'anti-couleur que les gluons portent en plus   */
                                        /* de leur charge de couleur) de faire varier au long de cette chaine de spheres la couleur  */
                                        /* de visualisation des particules (par exemple par une interpolation de la couleur a        */
                                        /* l'anti-couleur).                                                                          */
               Bblock

                                        /* ATTENTION, la sequence de code qui suit se retrouve, a quelque chose pres, dans les       */
                                        /* deux fichiers suivants :                                                                  */
                                        /*                                                                                           */
                                        /*                  $xrq/nucleon.LU$I                                                        */
                                        /*                  $xrv/champs_5.26$I                                                       */
                                        /*                                                                                           */
                                        /* Donc, toute modification faite dans l'un, peut avoir a etre reportee dans l'autre...      */

               EGAL(Xf
                   ,TRANSFORMATION_GEOMETRIQUE_3D_Fx(COORDONNEES_DE_MATERIALISATION(particule_courante,x,dx)
                                                    ,COORDONNEES_DE_MATERIALISATION(particule_courante,y,dy)
                                                    ,COORDONNEES_DE_MATERIALISATION(particule_courante,z,dz)
                                                    ,ASD1(translation_de_l_origine,dx)
                                                     )
                    );
               EGAL(Yf
                   ,TRANSFORMATION_GEOMETRIQUE_3D_Fy(COORDONNEES_DE_MATERIALISATION(particule_courante,x,dx)
                                                    ,COORDONNEES_DE_MATERIALISATION(particule_courante,y,dy)
                                                    ,COORDONNEES_DE_MATERIALISATION(particule_courante,z,dz)
                                                    ,ASD1(translation_de_l_origine,dy)
                                                     )
                    );
               EGAL(Zf
                   ,TRANSFORMATION_GEOMETRIQUE_3D_Fz(COORDONNEES_DE_MATERIALISATION(particule_courante,x,dx)
                                                    ,COORDONNEES_DE_MATERIALISATION(particule_courante,y,dy)
                                                    ,COORDONNEES_DE_MATERIALISATION(particule_courante,z,dz)
                                                    ,ASD1(translation_de_l_origine,dz)
                                                     )
                    );
                                        /* Coordonnees {x,y,z} de la particule dans l'espace physique eventuellement translatee      */
                                        /* le long de la direction de la vitesse afin de visualiser des chaines de sphere lorsque    */
                                        /* cela est demande...                                                                       */

               EGAL(Yf_au_pole_nord_de_la_sphere
                   ,Y_PHYSIQUE_DANS_01(ADD2(Yf
                                           ,MUL2(rapport_courant_du_zoom,rayon_de_la_particule)
                                            )
                                       )
                    );
                                        /* Calcul de la coordonnee 'y' de l'un des "poles" de la particule dans [0,1], afin de       */
                                        /* calculer son rayon apparent...                                                            */

               EGAL(Xf,X_PHYSIQUE_DANS_01(Xf));
               EGAL(Yf,Y_PHYSIQUE_DANS_01(Yf));
               EGAL(Zf,lZ_PHYSIQUE_DANS_01(Zf));
                                        /* Coordonnees {x,y,z} de la particule dans [0,1]...                                         */

               Test(EST_FAUX(LE_POINT_EST_INVISIBLE_OU_INDETERMINE(Xf,Yf,Zf)))
                    Bblock
                                        /* Cas ou le point {Xf,Yf,Zf} est visible apres projection...                                */
                    EGAL(petit_axe_de_la_particule_visualisee
                        ,SOUA(F__cDENORMALISE_OY(Projection_OY(Xf,Yf_au_pole_nord_de_la_sphere,Zf))
                             ,F__cDENORMALISE_OY(Projection_OY(Xf,Yf,Zf))
                              )
                         );
                                        /* Calcul du petit axe de l'ellipsoide representatif d'une particule ; toute cette           */
                                        /* manipulation etant destinee a projeter le rayon de la particule afin d'avoir un           */
                                        /* effet de perspective...                                                                   */

                    EGAL(module_de_la_vitesse_de_la_particule
                        ,longF3D(ASI2(particule_courante,espace_temps,vitesse))
                         );
                                        /* Calcul du module de la vitesse de la particule...                                         */
                    Test(IZGT(module_de_la_vitesse_de_la_particule))
                         Bblock
                         INITIALISATION_ACCROISSEMENT_3D(vitesse_normalisee_de_la_particule
                                                        ,DIVI(ASI3(particule_courante,espace_temps,vitesse,dx)
                                                             ,longF3D(ASI2(particule_courante,espace_temps,vitesse))
                                                              )
                                                        ,DIVI(ASI3(particule_courante,espace_temps,vitesse,dy)
                                                             ,longF3D(ASI2(particule_courante,espace_temps,vitesse))
                                                              )
                                                        ,DIVI(ASI3(particule_courante,espace_temps,vitesse,dz)
                                                             ,longF3D(ASI2(particule_courante,espace_temps,vitesse))
                                                              )
                                                         );
                                        /* Normalisation de la vitesse de la particule (en mouvement...).                            */
                         Eblock
                    ATes
                         Bblock
                         Test(IZEQ(module_de_la_vitesse_de_la_particule))
                              Bblock
                              INITIALISATION_ACCROISSEMENT_3D(vitesse_normalisee_de_la_particule
                                                             ,FZERO
                                                             ,FZERO
                                                             ,FZERO
                                                              );
                                        /* Normalisation de la vitesse de la particule (immobile, cas par exemple des quarks REELs). */
                              Eblock
                         ATes
                              Bblock
                              PRINT_ERREUR("un module de vitesse est negatif");
                              Eblock
                         ETes
                         Eblock
                    ETes
                    EGAL(Xf_de_la_vitesse
                        ,ADD2(Xf
                             ,TRANSFORMATION_GEOMETRIQUE_3D_Fx(ASD1(vitesse_normalisee_de_la_particule,dx)
                                                              ,ASD1(vitesse_normalisee_de_la_particule,dy)
                                                              ,ASD1(vitesse_normalisee_de_la_particule,dz)
                                                              ,ASD1(translation_de_l_origine,dx)
                                                               )
                              )
                         );
                    EGAL(Yf_de_la_vitesse
                        ,ADD2(Yf
                             ,TRANSFORMATION_GEOMETRIQUE_3D_Fy(ASD1(vitesse_normalisee_de_la_particule,dx)
                                                              ,ASD1(vitesse_normalisee_de_la_particule,dy)
                                                              ,ASD1(vitesse_normalisee_de_la_particule,dz)
                                                              ,ASD1(translation_de_l_origine,dy)
                                                               )
                              )
                         );
                    EGAL(Zf_de_la_vitesse
                        ,ADD2(Zf
                             ,TRANSFORMATION_GEOMETRIQUE_3D_Fz(ASD1(vitesse_normalisee_de_la_particule,dx)
                                                              ,ASD1(vitesse_normalisee_de_la_particule,dy)
                                                              ,ASD1(vitesse_normalisee_de_la_particule,dz)
                                                              ,ASD1(translation_de_l_origine,dz)
                                                               )
                              )
                         );
                                        /* Extremite dans [0,1] du vecteur vitesse de la particule courante, son origine etant bien  */
                                        /* entendu, dans [0,1], le point {Xf,Yf,Zf}.                                                 */
                    Test(EST_FAUX(LE_POINT_EST_INVISIBLE_OU_INDETERMINE(Xf_de_la_vitesse,Yf_de_la_vitesse,Zf_de_la_vitesse)))
                         Bblock
                                        /* Cas ou le point situe a l'extremite du vecteur vitesse du point {Xf,Yf,Zf} est visible    */
                                        /* apres projection...                                                                       */
                         INITIALISATION_ACCROISSEMENT_2D(vitesse_projetee_de_la_particule
                                                        ,SOUS(Projection_OX(Xf_de_la_vitesse,Yf_de_la_vitesse,Zf_de_la_vitesse)
                                                             ,Projection_OX(Xf,Yf,Zf)
                                                              )
                                                        ,SOUS(Projection_OY(Xf_de_la_vitesse,Yf_de_la_vitesse,Zf_de_la_vitesse)
                                                             ,Projection_OY(Xf,Yf,Zf)
                                                              )
                                                         );
                                        /* Composantes du vecteur vitesse projetee de la particule dans [0,1].                       */
                         EGAL(module_de_la_vitesse_projetee_de_la_particule
                             ,longF2D(vitesse_projetee_de_la_particule)
                              );
                                        /* Module de la vitesse projetee de la particule.                                            */
                         Test(IZGT(module_de_la_vitesse_projetee_de_la_particule))
                              Bblock
                              INITIALISATION_ACCROISSEMENT_2D(vitesse_projetee_de_la_particule
                                                             ,DIVI(ASD1(vitesse_projetee_de_la_particule,dx)
                                                                  ,module_de_la_vitesse_projetee_de_la_particule
                                                                   )
                                                             ,DIVI(ASD1(vitesse_projetee_de_la_particule,dy)
                                                                  ,module_de_la_vitesse_projetee_de_la_particule
                                                                   )
                                                              );
                                        /* Calcul des cosinus et sinus de la vitesse projetee de la particule :                      */
                                        /*                                                                                           */
                                        /* --->                                    -->                                               */
                                        /*  V   designant la projection du vecteur  V , on a :                                       */
                                        /*   p                                                                                       */
                                        /*                                                                                           */
                                        /*                              V                                                            */
                                        /*                               p                                                           */
                                        /*                                x                                                          */
                                        /*                  cos(t) = --------                                                        */
                                        /*                            |--->|                                                         */
                                        /*                            | V  |                                                         */
                                        /*                            |  p |                                                         */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                              V                                                            */
                                        /*                               p                                                           */
                                        /*                                y                                                          */
                                        /*                  sin(t) = --------                                                        */
                                        /*                            |--->|                                                         */
                                        /*                            | V  |                                                         */
                                        /*                            |  p |                                                         */
                                        /*                                                                                           */
                                        /*                              --->                                                         */
                                        /* 't' etant l'angle du vecteur  V   avec l'axe des abscisses.                               */
                                        /*                                p                                                          */
                              Eblock
                         ATes
                              Bblock
                              Test(IZEQ(module_de_la_vitesse_projetee_de_la_particule))
                                   Bblock
                                   INITIALISATION_ACCROISSEMENT_2D(vitesse_projetee_de_la_particule
                                                                  ,COSX(FZERO)
                                                                  ,SINX(FZERO)
                                                                   );
                                        /* Lorsque le vecteur vitesse de la particule est orthogonal au plan de projection, on       */
                                        /* choisit arbitrairement un angle nul pour sa projection. En effet, cet angle est           */
                                        /* arbitraire, car ainsi qu'on peut le voir facilement, dans ces conditions, le grand axe    */
                                        /* et le petit axe sont egaux : nous sommes donc ramenes a un disque, et alors la rotation   */
                                        /* du grand axe est "neutre"...                                                              */
                                   Eblock
                              ATes
                                   Bblock
                                   PRINT_ERREUR("un module de vitesse projetee est negatif");
                                   Eblock
                              ETes
                              Eblock
                         ETes

                         EGAL(grand_axe_de_la_particule_visualisee
                             ,MUL2(AXPB(rapport_des_axes_de_la_particule
                                       ,module_de_la_vitesse_projetee_de_la_particule
                                       ,FU
                                        )
                                  ,petit_axe_de_la_particule_visualisee
                                   )
                              );
                                        /* Calcul du petit axe de l'ellipsoide representatif d'une particule. On notera que le       */
                                        /* grand axe est d'une part proportionnel au petit axe, et d'autre part lie a la projection  */
                                        /* de la vitesse de la particule. Ainsi pour une particule se dirigeant dans la direction    */
                                        /* de l'observateur  (ou a l'oppose), le petit axe et le grand axe seront egaux, et la       */
                                        /* particule apparaitra telle une sphere...                                                  */

                                        /* ATTENTION, il y avait autrefois (avant l'introduction de '$xrv/champs_5.11$I' et de       */
                                        /* '$xrv/champs_5.12$I') :                                                                   */
                                        /*                                                                                           */
                                        /*                  EGAL(charge_ROUGE_attenuee                                               */
                                        /*                      ,ATTENUATION_DE_DEPTH_CUEING(charge_ROUGE,Zf)                        */
                                        /*                       );                                                                  */
                                        /*                  EGAL(charge_VERTE_attenuee                                               */
                                        /*                      ,ATTENUATION_DE_DEPTH_CUEING(charge_VERTE,Zf)                        */
                                        /*                       );                                                                  */
                                        /*                  EGAL(charge_BLEUE_attenuee                                               */
                                        /*                      ,ATTENUATION_DE_DEPTH_CUEING(charge_BLEUE,Zf)                        */
                                        /*                       );                                                                  */
                                        /*                                      /* charge de couleur de la particule courante apres  */
                                        /*                                      /* attenuation par la fonction de "depth-cueing".    */
                                        /*                  EGAL(charge_ROUGE_normalisee                                             */
                                        /*                      ,TRON(NORMALISATION_DU_ROUGE(charge_ROUGE_attenuee)                  */
                                        /*                           ,seuil_inferieur_du_ROUGE                                       */
                                        /*                           ,seuil_superieur_du_ROUGE                                       */
                                        /*                            )                                                              */
                                        /*                       );                                                                  */
                                        /*                  EGAL(charge_VERTE_normalisee                                             */
                                        /*                      ,TRON(NORMALISATION_DU_VERTE(charge_VERTE_attenuee)                  */
                                        /*                           ,seuil_inferieur_du_VERTE                                       */
                                        /*                           ,seuil_superieur_du_VERTE                                       */
                                        /*                            )                                                              */
                                        /*                       );                                                                  */
                                        /*                  EGAL(charge_BLEUE_normalisee                                             */
                                        /*                      ,TRON(NORMALISATION_DU_BLEUE(charge_BLEUE_attenuee)                  */
                                        /*                           ,seuil_inferieur_du_BLEUE                                       */
                                        /*                           ,seuil_superieur_du_BLEUE                                       */
                                        /*                            )                                                              */
                                        /*                       );                                                                  */
                                        /*                                      /* charge de couleur de la particule courante : elle */
                                        /*                                      /* est dupliquee afin d'accelerer la compilation.    */
                                        /*                                      /* De plus, l'operation 'TRON(...,inf,sup)' est      */
                                        /*                                      /* destinee a compenser sur le plan visuel les       */
                                        /*                                      /* charges de couleur qui sont trop faibles (par     */
                                        /*                                      /* exemple un bleu tout seul est tres sombre...).    */
                                        /*                                                                                           */

#ifdef    store_ellipsoide
                         EGAL(rayon_de_visualisation_projete
                             ,CHOI(petit_axe_de_la_particule_visualisee,grand_axe_de_la_particule_visualisee)
                              );
                                        /* Calcul du rayon de la sphere de visualisation (version '$xrq/nucleon.LS$I')...            */
#Aifdef   store_ellipsoide
#Eifdef   store_ellipsoide

#ifdef    store_sphere
                         EGAL(rayon_de_visualisation_projete
                             ,CHOI(_____lNORMALISE_OY(petit_axe_de_la_particule_visualisee)
                                  ,_____lNORMALISE_OX(grand_axe_de_la_particule_visualisee)
                                   )
                              );
                                        /* Calcul du rayon de la sphere de visualisation (version '$xrv/champs_5.1C$I')...           */
#Aifdef   store_sphere
#Eifdef   store_sphere

                         MEMORISATION_D_UN_POINT(Xf,Yf,Zf
                                                ,Z_PHYSIQUE_DANS_01(rayon_de_la_particule)
                                                ,rayon_de_visualisation_projete
                                                ,charge_ROUGE,charge_VERTE,charge_BLEUE
                                                 );
                                        /* Memorisation du point courant dans l'espace de visualisation. ATTENTION, il y avait       */
                                        /* autrefois :                                                                               */
                                        /*                                                                                           */
                                        /*        #define   VISUALISATION_D_UN_ELLIPSOIDE(image                                      */
                                        /*                                               ,niveau_au_centre,niveau_au_bord            */
                                        /*                                               ,mise_a_jour_du_Z_Buffer                    */
                                        /*                                                )                                       \  */
                                        /*                            Bblock                                                      \  */
                                        /*                            store_ellipsoide(niveau_au_bord                             \  */
                                        /*                                            ,niveau_au_centre                           \  */
                                        /*                                            ,image                                      \  */
                                        /*                                            ,X_DE_VISUALISATION(Xf)                     \  */
                                        /*                                            ,Y_DE_VISUALISATION(Yf)                     \  */
                                        /*                                            ,Z_DE_VISUALISATION(Zf)                     \  */
                                        /*                                            ,petit_axe_de_la_particule_visualisee       \  */
                                        /*                                            ,grand_axe_de_la_particule_visualisee       \  */
                                        /*                                            ,vitesse_projetee_de_la_particule           \  */
                                        /*                                             );                                         \  */
                                        /*                            Eblock                                                         */
                                        /*                                                                                           */
                                        /* et :                                                                                      */
                                        /*                                                                                           */
                                        /*        VISUALISATION_D_UN_ELLIPSOIDE(Image_ROUGE                                          */
                                        /*                                     ,charge_ROUGE_normalisee                              */
                                        /*                                     ,NIVEAU_AU_BORD_D_UN_DISQUE(charge_ROUGE_normalisee)  */
                                        /*                                     ,BLOC(NE_PAS_METTRE_A_JOUR_LE_Z_Buffer;);             */
                                        /*                                      );                                                   */
                                        /*        VISUALISATION_D_UN_ELLIPSOIDE(Image_VERTE                                          */
                                        /*                                     ,charge_VERTE_normalisee                              */
                                        /*                                     ,NIVEAU_AU_BORD_D_UN_DISQUE(charge_VERTE_normalisee)  */
                                        /*                                     ,BLOC(NE_PAS_METTRE_A_JOUR_LE_Z_Buffer;);             */
                                        /*                                      );                                                   */
                                        /*        VISUALISATION_D_UN_ELLIPSOIDE(Image_BLEUE                                          */
                                        /*                                     ,charge_BLEUE_normalisee                              */
                                        /*                                     ,NIVEAU_AU_BORD_D_UN_DISQUE(charge_BLEUE_normalisee)  */
                                        /*                                     ,BLOC(METTRE_A_JOUR_LE_Z_Buffer;);                    */
                                        /*                                      );                                                   */
                                        /*                                                                                           */
                                        /* Mais cela n'est plus necessaire depuis que les spheres a tracer sont triees par 'Z'       */
                                        /* croissant afin de bien corriger l'aliasing...                                             */

                         Test(IFEQ(numero_de_la_sphere_de_materialisation,ZERO))
                              Bblock
                              BASE_DE_DONNEES
                                  (Prin1("\n Geometrie : etiquette={%d};"
                                        ,ETIQUETTE(particule_courante)
                                         )
                                   );

                              BASE_DE_DONNEES(Prin0(" particule={"));
                              NATU(particule_courante,QUARK_REEL,"QUARK_REEL");
                              NATU(particule_courante,ANTI_QUARK_REEL,"ANTI_QUARK_REEL");
                              NATU(particule_courante,QUARK_VIRTUEL,"QUARK_VIRTUEL");
                              NATU(particule_courante,ANTI_QUARK_VIRTUEL,"ANTI_QUARK_VIRTUEL");
                              NATU(particule_courante,GLUON_REEL,"GLUON_REEL");
                              NATU(particule_courante,GLUON_VIRTUEL,"GLUON_VIRTUEL");
                              NATU(particule_courante,ELECTRON_REEL,"ELECTRON_REEL");
                              NATU(particule_courante,ANTI_ELECTRON_REEL,"ANTI_ELECTRON_REEL");
                              NATU(particule_courante,ELECTRON_VIRTUEL,"ELECTRON_VIRTUEL");
                              NATU(particule_courante,ANTI_ELECTRON_VIRTUEL,"ANTI_ELECTRON_VIRTUEL");
                              NATU(particule_courante,NEUTRINO_REEL,"NEUTRINO_REEL");
                              NATU(particule_courante,NEUTRINO_VIRTUEL,"NEUTRINO_VIRTUEL");
                              NATU(particule_courante,PHOTON_REEL,"PHOTON_REEL");
                              NATU(particule_courante,PHOTON_VIRTUEL,"PHOTON_VIRTUEL");
                              NATU(particule_courante,Z0_REEL,"Z0_REEL");
                              NATU(particule_courante,Z0_VIRTUEL,"Z0_VIRTUEL");
                              BASE_DE_DONNEES(Prin0("};"));

                              BASE_DE_DONNEES(Prin0(" saveur={"));
                              SAVE(particule_courante,QUARK_d,"d");
                              SAVE(particule_courante,QUARK_u,"u");
                              SAVE(particule_courante,QUARK_s,"s");
                              SAVE(particule_courante,QUARK_c,"c");
                              SAVE(particule_courante,QUARK_b,"b");
                              SAVE(particule_courante,QUARK_t,"t");
                              SAVE(particule_courante,QUARK_SAVEUR_INDEFINIE,"QUARK_SAVEUR_INDEFINIE");
                              SAVE(particule_courante,QUARK_PAS_DE_SAVEUR,"QUARK_PAS_DE_SAVEUR");
                              SAVE(particule_courante,LEPTON_e,"e");
                              SAVE(particule_courante,LEPTON_m,"m");
                              SAVE(particule_courante,LEPTON_t,"t");
                              SAVE(particule_courante,LEPTON_SAVEUR_INDEFINIE,"LEPTON_SAVEUR_INDEFINIE");
                              SAVE(particule_courante,LEPTON_PAS_DE_SAVEUR,"LEPTON_PAS_DE_SAVEUR");
                              BASE_DE_DONNEES(Prin0("};"));

                              BASE_DE_DONNEES
                                  (Prin1(" date={%g};"
                                        ,temps_courant
                                         )
                                   );
                              BASE_DE_DONNEES
                                  (Prin3(" position={%g,%g,%g};"
                                        ,COORDONNEES(particule_courante,x)
                                        ,COORDONNEES(particule_courante,y)
                                        ,COORDONNEES(particule_courante,z)
                                         )
                                   );
                              BASE_DE_DONNEES
                                  (Prin3(" vitesse={%g,%g,%g};"
                                        ,ASI3(particule_courante,espace_temps,vitesse,dx)
                                        ,ASI3(particule_courante,espace_temps,vitesse,dy)
                                        ,ASI3(particule_courante,espace_temps,vitesse,dz)
                                         )
                                   );
                              BASE_DE_DONNEES
                                  (Prin3(" moment_angulaire={%g,%g,%g};"
                                        ,ASI3(particule_courante,espace_temps,moment_angulaire,dx)
                                        ,ASI3(particule_courante,espace_temps,moment_angulaire,dy)
                                        ,ASI3(particule_courante,espace_temps,moment_angulaire,dz)
                                         )
                                   );
                              Test(IL_FAUT(editer_la_couleur_en_flottant))
                                   Bblock
                                   BASE_DE_DONNEES
                                       (Prin3(" couleur={%g,%g,%g};"
                                             ,charge_ROUGE
                                             ,charge_VERTE
                                             ,charge_BLEUE
                                              )
                                        );
                                   Eblock
                              ATes
                                   Bblock
                                   BASE_DE_DONNEES
                                       (Prin3(" couleur={%d,%d,%d};"
                                             ,NORMALISATION_DU_ROUGE(charge_ROUGE)
                                             ,NORMALISATION_DU_VERTE(charge_VERTE)
                                             ,NORMALISATION_DU_BLEUE(charge_BLEUE)
                                              )
                                        );
                                   Eblock
                              ETes
                              Eblock
                         ATes
                              Bblock
                              Eblock
                         ETes
                         Eblock
                    ATes
                         Bblock
                                        /* Cas ou le point situe a l'extremite du vecteur vitesse du point {Xf,Yf,Zf} n'est pas      */
                                        /* visible apres projection...                                                               */
                         Eblock
                    ETes
                    Eblock
               ATes
                    Bblock
                                        /* Cas ou le point {Xf,Yf,Zf} n'est pas visible apres projection...                          */
                    Eblock
               ETes

                                        /* ATTENTION, la sequence de code qui precede se retrouve, a quelque chose pres, dans les    */
                                        /* deux fichiers suivants :                                                                  */
                                        /*                                                                                           */
                                        /*                  $xrq/nucleon.LU$I                                                        */
                                        /*                  $xrv/champs_5.26$I                                                       */
                                        /*                                                                                           */
                                        /* Donc, toute modification faite dans l'un, peut avoir a etre reportee dans l'autre...      */

               Eblock
          EDoI
          Eblock
     ETes
     RETU_ERROR;
     Eblock

EFonctionI

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E S T I O N   D E   L A   V I S U A L I S A T I O N   S T E R E O S C O P I Q U E  :                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/champs_5.13.I"



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.