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

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P R O C E D U R E S   D ' A U T O - R E G U L A T I O N  :                                                                 */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   REGUL1(x)                                                                                                                     \
                    NEUT(x)
#define   REGUL0(x)                                                                                                                     \
                    NEUT(x)
#define   REGUL9(x)                                                                                                                     \
                    NEUT(x)
                                        /* Ces trois procedures correspondent aux trois cas de figure possibles, a savoir :          */
                                        /*                                                                                           */
                                        /*                  REGUL1 : diminuer  / augmenter                                           */
                                        /*                  REGUL0 : rien      / rien                                                */
                                        /*                  REGUL9 : augmenter / diminuer                                            */
                                        /*                                                                                           */
                                        /* suivant qu'il a trop ou pas assez de particules...                                        */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E N T A T I V E   D ' A U T O - R E G U L A T I O N   D E   L A   D E N S I T E   D E   P A R T I C U L E S  :           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   AUTO_REGULER_LE_MODELE                                                                                                        \
                    VRAI
DEFV(Local,DEFV(Logical,INIT(auto_reguler_le_modele,AUTO_REGULER_LE_MODELE)));
                                        /* Indicateur precisant si l'auto-regulation est activable ('VRAI') ou pas ('FAUX').         */

DEFV(Local,DEFV(Logical,INIT(auto_regulation_en_cours,FAUX)));
                                        /* Indicateur precisant si l'auto-regulation est active ('VRAI') ou pas encore ('FAUX') ;    */
                                        /* notons d'ailleurs qu'une fois que ce processus est declenche, il ne s'arrete plus...      */

DEFV(Local,DEFV(Float,INIT(coefficient_d_auto_regulation,FLOT__UNDEF)));
DEFV(Local,DEFV(Positive,INIT(demi_exposant_d_auto_regulation,UNDEF)));
                                        /* Ces deux variables sont la uniquement pour simplifier les choses...                       */

#define   TAUX_D_AUTO_REGULATION                                                                                                        \
                    FRA1(FRA10(FRA10(FU)))
DEFV(Local,DEFV(Float,INIT(taux_d_auto_regulation,TAUX_D_AUTO_REGULATION)));
                                        /* Taux de variation des differents nombres d'evenements et probabilites affectes par        */
                                        /* la procedure 'AUTO_REGULATION'.                                                           */
#define   REGULATION_DOWN(variable)                                                                                                     \
                    Bblock                                                                                                              \
                    DECR(variable,MUL2(taux_d_auto_regulation,variable));                                                               \
                    Eblock
#define   REGULATION_ZERO(variable)                                                                                                     \
                    Bblock                                                                                                              \
                    Eblock
#define   REGULATION_HAUT(variable)                                                                                                     \
                    Bblock                                                                                                              \
                    INCR(variable,MUL2(taux_d_auto_regulation,variable));                                                               \
                    Eblock
                                        /* Fonctions d'evolution vers le bas et vers le haut de differentes variables (probabilites  */
                                        /* et nombres d'evenements) lors du processus d'auto-regulation...                           */
#define   SEUIL_D_AUTO_REGULATION                                                                                                       \
                    MOIT(nombre_maximal_de_particules_dans_le_proton)                                                                   \
                                        /* Nombre de particules qui est le seuil au-dela duquel on enclenche le processus            */ \
                                        /* d'auto-regulation (pour ne plus jamais l'arreter...). On notera que ce parametre n'est    */ \
                                        /* pas affecte par 'tSCALE(...)' car en effet, il correspond a un etat d'equilibre du        */ \
                                        /* systeme, auquel cas le nombre de particules est independant de la duree de l'observation. */
#define   ___AUTO_REGULATION                                                                                                            \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(auto_reguler_le_modele))                                                                               \
                         Bblock                                                                                                         \
                         Test(IFGT(nombre_instantane_de_particules,SEUIL_D_AUTO_REGULATION))                                            \
                              Bblock                                                                                                    \
                              EGAL(auto_regulation_en_cours,VRAI);                                                                      \
                                        /* Lorsque le nombre total de particules excede la moitie (arbitraire...) du maximum         */ \
                                        /* prevu, on met en marche (a moins qu'il y fut deja) le processus d'auto-regulation...      */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         EGAL(auto_regulation_en_cours,FAUX);                                                                           \
                                        /* Lorsqu'il ne faut pas auto-reguler le modele, le processus est systematiquement           */ \
                                        /* desactive...                                                                              */ \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(EST_VRAI(auto_regulation_en_cours))                                                                            \
                         Bblock                                                                                                         \
                                        /* Cas ou l'auto-regulation est active :                                                     */ \
                         Test(IFGE(nombre_instantane_de_particules,SEUIL_D_AUTO_REGULATION))                                            \
                              Bblock                                                                                                    \
                                        /* Cas ou l'auto-regulation est active et ou il y a trop de particules : on va reduire       */ \
                                        /* les nombres d'evenements ainsi que les probabilites de creation, et on va augmenter       */ \
                                        /* les probabilites de collisions...                                                         */ \
                              Repe(INTE(NEUT(DIVI(FLOT(nombre_instantane_de_particules)                                                 \
                                                 ,FLOT(SEUIL_D_AUTO_REGULATION)                                                         \
                                                  )                                                                                     \
                                             )                                                                                          \
                                        )                                                                                               \
                                   )                                                                                                    \
                                   Bblock                                                                                               \
                                        /* Dans le cas ou il y a trop de particules par rapport a 'SEUIL_D_AUTO_REGULATION' il       */ \
                                        /* convient de "moduler" l'action a entreprendre ; en effet, lorsqu'un tres petit nombre     */ \
                                        /* de particules est desire, les processus de fluctuation du vide et d'injection de nuages   */ \
                                        /* de particules virtuelles creent beaucoup de particules (relativement au seuil), et donc   */ \
                                        /* le nombre de particules 'nombre_instantane_de_particules' depassent alors rapidement et   */ \
                                        /* largement ce seuil. En consequence de quoi, la sequence suivante est repetee un certain   */ \
                                        /* nombre de fois fonction du surplus de particules ; malgre cela, et de facon a ne pas      */ \
                                        /* etre trop drastique, on utilise une fonction de ce rapport : 'RACX(...)' ou actuellement  */ \
                                        /* 'NEUT(...)'...                                                                            */ \
                                   REGULATION_DOWN(nombre_d_evenements_pour_les_fluctuations_quantiques_du_vide);                       \
                                   REGULATION_ZERO(nombre_d_evenements_pour_l_injection_de_nuages_de_quarks_virtuels);                  \
                                   REGULATION_ZERO(nombre_d_evenements_pour_l_injection_de_nuages_d_anti_quarks_virtuels);              \
                                   REGULATION_ZERO(nombre_d_evenements_pour_l_injection_de_nuages_de_gluons_virtuels);                  \
                                   REGULATION_HAUT(probabilite_de_STRONG_ANNHILATION_GxGxGxG___V);                                      \
                                   REGULATION_HAUT(probabilite_de_STRONG_ANNHILATION_GxGxG___V);                                        \
                                   REGULATION_HAUT(probabilite_de_STRONG_ANNHILATION_QxAQxG___V);                                       \
                                   REGULATION_HAUT(probabilite_de_STRONG_ABSORBTION_QxG___Q);                                           \
                                   REGULATION_HAUT(probabilite_de_STRONG_ABSORBTION_AQxG___AQ);                                         \
                                   REGULATION_HAUT(probabilite_de_STRONG_TRANSFORMATION_QxAQ___G);                                      \
                                   REGULATION_HAUT(probabilite_de_STRONG_TRANSFORMATION_GxG___G);                                       \
                                   REGULATION_ZERO(probabilite_de_INCHANGE_V);                                                          \
                                   REGULATION_ZERO(probabilite_de_STRONG_CREATION_V___QxAQxG);                                          \
                                   REGULATION_ZERO(probabilite_de_STRONG_CREATION_V___GxGxG);                                           \
                                   REGULATION_ZERO(probabilite_de_STRONG_CREATION_V___GxGxGxG);                                         \
                                   REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_point_du_vide);                         \
                                   REGULATION_ZERO(probabilite_de_INCHANGE_Q);                                                          \
                                   REGULATION_DOWN(probabilite_de_STRONG_EMISSION_Q___QxG);                                             \
                                   REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_quark);                                 \
                                   REGULATION_ZERO(probabilite_de_INCHANGE_AQ);                                                         \
                                   REGULATION_DOWN(probabilite_de_STRONG_EMISSION_AQ___AQxG);                                           \
                                   REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_anti_quark);                            \
                                   REGULATION_ZERO(probabilite_de_INCHANGE_G);                                                          \
                                   REGULATION_DOWN(probabilite_de_STRONG_TRANSFORMATION_G___QxAQ);                                      \
                                   REGULATION_DOWN(probabilite_de_STRONG_TRANSFORMATION_G___GxG);                                       \
                                   REGULATION_DOWN(probabilite_de_STRONG_TRANSFORMATION_G___GxGxG);                                     \
                                   REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_gluon);                                 \
                                   Eblock                                                                                               \
                              ERep                                                                                                      \
                              TRACE_D_UN_EVENEMENT(Prin2("REGULATION                                   trop de particules (%d/%d)"      \
                                                        ,nombre_instantane_de_particules                                                \
                                                        ,SEUIL_D_AUTO_REGULATION                                                        \
                                                         )                                                                              \
                                                   );                                                                                   \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                                        /* Cas ou l'auto-regulation est active et ou il n'y a pas assez de particules : on va        */ \
                                        /* augmenter les nombres d'evenements ainsi que les probabilites de creation, et on va       */ \
                                        /* reduire les probabilites de collisions...                                                 */ \
                              REGULATION_HAUT(nombre_d_evenements_pour_les_fluctuations_quantiques_du_vide);                            \
                              REGULATION_ZERO(nombre_d_evenements_pour_l_injection_de_nuages_de_quarks_virtuels);                       \
                              REGULATION_ZERO(nombre_d_evenements_pour_l_injection_de_nuages_d_anti_quarks_virtuels);                   \
                              REGULATION_ZERO(nombre_d_evenements_pour_l_injection_de_nuages_de_gluons_virtuels);                       \
                              REGULATION_DOWN(probabilite_de_STRONG_ANNHILATION_GxGxGxG___V);                                           \
                              REGULATION_DOWN(probabilite_de_STRONG_ANNHILATION_GxGxG___V);                                             \
                              REGULATION_DOWN(probabilite_de_STRONG_ANNHILATION_QxAQxG___V);                                            \
                              REGULATION_DOWN(probabilite_de_STRONG_ABSORBTION_QxG___Q);                                                \
                              REGULATION_DOWN(probabilite_de_STRONG_ABSORBTION_AQxG___AQ);                                              \
                              REGULATION_DOWN(probabilite_de_STRONG_TRANSFORMATION_QxAQ___G);                                           \
                              REGULATION_DOWN(probabilite_de_STRONG_TRANSFORMATION_GxG___G);                                            \
                              REGULATION_ZERO(probabilite_de_INCHANGE_V);                                                               \
                              REGULATION_ZERO(probabilite_de_STRONG_CREATION_V___QxAQxG);                                               \
                              REGULATION_ZERO(probabilite_de_STRONG_CREATION_V___GxGxG);                                                \
                              REGULATION_ZERO(probabilite_de_STRONG_CREATION_V___GxGxGxG);                                              \
                              REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_point_du_vide);                              \
                              REGULATION_ZERO(probabilite_de_INCHANGE_Q);                                                               \
                              REGULATION_HAUT(probabilite_de_STRONG_EMISSION_Q___QxG);                                                  \
                              REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_quark);                                      \
                              REGULATION_ZERO(probabilite_de_INCHANGE_AQ);                                                              \
                              REGULATION_HAUT(probabilite_de_STRONG_EMISSION_AQ___AQxG);                                                \
                              REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_anti_quark);                                 \
                              REGULATION_ZERO(probabilite_de_INCHANGE_G);                                                               \
                              REGULATION_HAUT(probabilite_de_STRONG_TRANSFORMATION_G___QxAQ);                                           \
                              REGULATION_HAUT(probabilite_de_STRONG_TRANSFORMATION_G___GxG);                                            \
                              REGULATION_HAUT(probabilite_de_STRONG_TRANSFORMATION_G___GxGxG);                                          \
                              REGULATION_ZERO(probabilite_d_evenement_conditionnel_pour_un_gluon);                                      \
                              TRACE_D_UN_EVENEMENT(Prin2("REGULATION                                   pas assez de particules (%d/%d)" \
                                                        ,nombre_instantane_de_particules                                                \
                                                        ,SEUIL_D_AUTO_REGULATION                                                        \
                                                         )                                                                              \
                                                   );                                                                                   \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                                        /* Cas ou l'auto-regulation n'est pas encore activee...                                      */ \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Tentative d'auto-regulation du nombre de particules preseentes en jouant sur certaines    */ \
                                        /* probabilites et sur certains nombres d'evenements...                                      */

BFonctionI

DEFV(LoF,GENERE__Fonction__OPT(AUTO_REGULATION,A,___AUTO_REGULATION))

EFonctionI



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