/*************************************************************************************************************************************/
/* */
/* M A R C H E A L E A T O I R E D A N S L ' E S P A C E T R I D I M E N S I O N N E L */
/* A V E C I N T E R A C T I O N E N T R E L E S P A R T I C U L E S */
/* L E T O U T E T A N T D A N S U N M I L I E U D E P R O P A G A T I O N : */
/* */
/* */
/* Nota important : */
/* */
/* Aux environs du 20150207093830, il semble */
/* que '$xrk/rdn_walk.52$X' soit une generalisation */
/* compatible de tous les '$xrk/rdn_walk.??$X' et */
/* qu'ainsi il puisse se substituer a chacun d'eux. */
/* De plus, les eventelles anomalies que contenaient */
/* les versions '$xrk/rdn_walk.??$X' anterieures ont */
/* ete corrigees dans '$xrk/rdn_walk.52$X' (cela s'est */
/* vu en regenerant 'v $xiak/REFL.91$R16', ce qui fut */
/* possible en remplacant '$xrk/rdn_walk.41$X' par */
/* '$xrk/rdn_walk.52$X'...). */
/* */
/* Le 20150207100008, je note qu'evidemment de */
/* des differences importantes peuvent apparaitre */
/* dans le cas ou d'une version a l'autre de nouvelles */
/* generations aleatoires ont ete introduites... */
/* */
/* */
/* Author of '$xrk/rdn_walk.52$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19981102090816). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
@define PRAGMA_CL_____MODULE_NON_OPTIMISABLE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P T I O N S D E C O M P A T I B I L I T E A N T E R I E U R E : */
/* */
/*************************************************************************************************************************************/
#define COMPATIBILITE_20160610 \
FAUX
DEFV(Logical,INIT(compatibilite_20160610,COMPATIBILITE_20160610));
/* Permet de revenir a la version qui oubliait de gerer de temps en temps les corps non */
/* encore nes ou bien deja morts... */
#define LE_CORPS_EST_VIVANT(corps) \
IFOU(IL_FAUT(compatibilite_20160610) \
,IFET(IL_NE_FAUT_PAS(compatibilite_20160610) \
,IFET(IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant) \
,IFGT(ACCES_DATES_DE_MORT(corps),temps_courant) \
) \
) \
) \
/* Procedure introduite le 20160610152047... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E B A S E E T U N I V E R S E L L E S : */
/* */
/*************************************************************************************************************************************/
#if ( (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
)
/* Test introduit le 20170126113817 a cause de 'v $xil/defi_K2$vv$DEF 20170126111709'... */
/* */
/* Cela fut complete le 20180404112151 avec 'SYSTEME_APC_LinuxRedHat_GCC' toujours pour la */
/* meme raison, c'est-a-dire supprimer le message : */
/* */
/* warning: variably modified '...' at file scope [enabled by default] */
/* */
/* du a la presence de typage '(double)' dans 'dSCAL(...)'. */
/* */
/* Le 20210906081113, 'SYSTEME_APC_LinuxUbuntu_GCC' fut introduit pour les memes raisons */
/* lors de l'introduction de '$LACT1B'... */
# define NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION \
idSCAL(GRO3(DIX_MILLE),CINQ_CENT_DOUZE,ADD2(MemorySizeMB,SwapSizeMB))
#Aif ( (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
)
# define NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION \
dSCAL(GRO3(DIX_MILLE),CINQ_CENT_DOUZE,ADD2(MemorySizeMB,SwapSizeMB))
#Eif ( (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
)
/* Definition du nombre maximal de periodes de la simulation. On pourrait s'etonner de la */
/* necessite d'une aussi grande valeur pour 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION'. */
/* En fait, elle vient de la definition de 'NOMBRE_MAXIMAL_DE_POINTS_GERABLES' qui utilise */
/* un 'MIN2(...)' qui reference 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION' qui doit donc */
/* etre grand... */
/* */
/* ATTENTION, jusqu'au 20011025133651, on trouvait ici : */
/* */
/* #if ( (defined(LACT14)) \ */
/* ) */
/* # define NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION \ */
/* GRO4(DIX_MILLE) */
/* #Aif ( (defined(LACT14)) \ */
/* ) */
/* #Eif ( (defined(LACT14)) \ */
/* ) */
/* */
/* mais, dorenavant, on est capable de fixer ce parametre en fonction de la taille */
/* reelle de la memoire physique de la MACHINE. On notera, au passage, que cela ne */
/* marche pas bien si la compilation a lieu sur une MACHINE et l'execution sur une autre, */
/* mais il en etait ainsi avant le 20011025133651. D'autre part, le parametre 'MemorySizeMB' */
/* peut etre recupere (dynamiquement donc) via un 'Gvar(...)' ; mais le probleme est que */
/* 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION' peut etre utilise dans des circonstances */
/* ou une constante est absolument necessaire (par exemple dans de l'allocation memoire */
/* statique), d'ou cette solution... */
/* */
/* Le 20011026090224, je suis passe de 'GRO4(...)' a 'GRO3(...)' car, en effet, une */
/* sequence tel 'v _____xivPdf_14_1/013825_014336' montre que 25703 particules sont */
/* quasiment a la limite de la memoire physique de 256 mega-octets et de la zone de swap */
/* (a la date du 20020301143423, le process '$xrk/rdn_walk.52$X' utilise 382 mega-octets */
/* de memoire virtuelle incluant le code, les donnees et la pile). */
/* */
/* Le 20020217124050, je suis revenu a 'GRO4(...)' pour 'v _____xivPdf_14_1/019791_020302'. */
/* Et bien, 'GRO3(...)' est vraiment le maximum restaure le 20020217133950... */
/* */
/* Le 20020304114125, j'ai introduit la memoire de "swap" afin de connaitre l'espace total */
/* memoire reellement disponible, c'est-a-dire l'espace virtuel... */
#ifdef NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION
# define NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES \
NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION \
/* Cette constante est destinee a dimensionner les listes "lineaires" de memorisation des */ \
/* points a visualiser... */
#Aifdef NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION
#Eifdef NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION
#include xrk/attractor.11.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 3 */
/* D E F I N I T I O N D E L ' E S P A C E P H Y S I Q U E D A N S R ( D E B U T ) : */
/* */
/* */
/* Nota : */
/* */
/* Les extrema des coordonnees {x,y,z} */
/* ainsi que ceux de leurs differentielles */
/* {dx,dy,dz} sont fixees un peu arbitrairement */
/* et sans etre parametrees. */
/* */
/* */
/*************************************************************************************************************************************/
#define hXmin_ESPACE \
PARE(-1.0)
#define hYmin_ESPACE \
PARE(-1.0)
#define hZmin_ESPACE \
PARE(-1.0)
/* Definition du "coin" inferieur-gauche-arriere de l'espace physique. */
#define hXmax_ESPACE \
PARE(1.0)
#define hYmax_ESPACE \
PARE(1.0)
#define hZmax_ESPACE \
PARE(1.0)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 3 */
/* D E F I N I T I O N D E L ' E S P A C E P H Y S I Q U E D A N S R ( D E B U T ) : */
/* */
/*************************************************************************************************************************************/
#include xrk/attractor.12.I"
#define dXmin_ESPACE \
FLOT__NOIR
#define dYmin_ESPACE \
FLOT__NOIR
#define dZmin_ESPACE \
FLOT__NOIR
/* Definition des minima des differentielles {dx,dy,dz}. */
#define dXmax_ESPACE \
FLOT__BLANC
#define dYmax_ESPACE \
FLOT__BLANC
#define dZmax_ESPACE \
FLOT__BLANC
/* Definition des maxima des differentielles {dx,dy,dz}. */
#include xrk/attractor.1D.I"
/* Formules de renormalisation des differentielles dans [0,1] ; elles sont utilisees lorsque */
/* la production d'images en couleurs est demandee (voir 'visualiser_en_RVB'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S D I F F E R E N T S E S P A C E S E T D E L ' E F F E T D E B R U M E : */
/* */
/*************************************************************************************************************************************/
#include xrk/attractor.13.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A I D E A U C A D R A G E D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
#include xrk/attractor.1C.I"
DONNEES_DE_RECHERCHE_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES
/* Definition des extrema des coordonnees et des derivees. On notera bien l'absence de */
/* point-virgule apres 'DONNEES_DE_RECHERCHE_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
#include xrv/champs_5.14.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' I N T E R A C T I O N G R A V I T A T I O N N E L L E G E N E R A L I S E E */
/* ( D E B U T ) : */
/* */
/*************************************************************************************************************************************/
#define FAIRE_DE_L_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
FAUX
DEFV(Local,DEFV(Logical,INIT(faire_de_l_interaction_gravitationnelle_generalisee
,FAIRE_DE_L_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* Indique si l'interaction gravitationnelle (generalisee...) doit etre prise en compte */
/* ('VRAI') ou pas ('FAUX'). */
/* */
/* ATTENTION, lorsque 'IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee)' on */
/* aura interet a reduire fortement 'dct' en augmentant correlativement le parametre */
/* 'nombre_de_pas_de_temps_par_periode', par exemple en divisant par 10 et multipliant */
/* par 10 respectivement... */
/* */
/* Cette definition a ete deplacee ici a cause de 'v $xrk/attractor.14$I DCT_EFFECTIF' */
/* le 20011022135917. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S G E N E R A L E S R E L A T I V E S A L A V I S U A L I S A T I O N : */
/* */
/*************************************************************************************************************************************/
#define nombre_de_corps \
nombre_d_iterations \
/* ATTENTION, a ne pas confondre : */ \
/* */ \
/* 1-'nombre_de_periodes_de_la_simulation' qui definit finalement le nombre d'images que */ \
/* l'on va generer et qui conditionne toutes les listes (sans exception...) definies par */ \
/* 'dTRANSFORMAT_31(...)' et 'fTRANSFORMAT_31(...)', et */ \
/* */ \
/* 2-'nombre_d_iterations' qui definit le nombre de particules visualisees dans chaque */ \
/* image ; les listes relatives aux particules sont definies elles-aussi a l'aide de la */ \
/* procedure 'dTRANSFORMAT_31(...)' ce qui signifie que 'nombre_d_iterations' est limite */ \
/* par 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION'... */ \
/* */
#define DCT \
FRA1(FRA10(FU))
DEFV(Local,DEFV(Float,INIT(dct,DCT)));
/* Definition de 'dt'. */
#define DCT_EFFECTIF \
COND(IL_NE_FAUT_PAS(faire_de_l_interaction_gravitationnelle_generalisee) \
,dct \
,FRA1(dct) \
) \
/* Cette definition a ete placee devant l'appel a 'v $xrk/attractor.14$I DCT_EFFECTIF' le */ \
/* 20011022135917 car en effet, l'existence de 'DCT_EFFECTIF' est testee, a compter de */ \
/* cette date, dans ce fichier... */
#define NOMBRE_MAXIMAL_DE_POINTS_GERABLES \
MIN2(NOMBRE_MAXIMAL_DE_POINTS_VISUALISABLES,NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION) \
/* Cette constante permet de gerer d'une facon homogene les listes de dimension */ \
/* 'nombre_de_periodes_de_la_simulation' comme celles de dimension 'nombre_d_iterations'. */ \
/* ATTENTION, avant le 20011026095651, cette definition etait situee apres l'include du */ \
/* fichier '$xrk/attractor.14$I'. */
#define NOMBRE_D_ITERATIONS \
NOMBRE_MAXIMAL_DE_POINTS_GERABLES \
/* Ceci a ete introduit le 20011026093613 afin de donner a 'nombre_de_corps' (qui est en */ \
/* fait 'nombre_d_iterations') la valeur maximale possible, qui peut donc ainsi etre connue */ \
/* a l'exterieur du programme avec l'options "Parametres=VRAI" en examinant "corps="... */
#include xrk/attractor.14.I"
/* ATTENTION, a ne pas confondre : */
/* */
/* 1-'nombre_de_periodes_de_la_simulation' qui definit finalement le nombre d'images que */
/* l'on va generer et qui conditionne toutes les listes (sans exception...) definies par */
/* 'fTRANSFORMAT_31(...)', et */
/* */
/* 2-'nombre_d_iterations' qui definit le nombre de particules visualisees dans chaque */
/* image ; les listes relatives aux particules sont definies elles-aussi a l'aide de la */
/* procedure 'dTRANSFORMAT_31(...)' ce qui signifie que 'nombre_d_iterations' est limite */
/* par 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION'... */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N D E M E M O R I S A T I O N D U P O I N T C O U R A N T : */
/* */
/*************************************************************************************************************************************/
#include xrk/attractor.16.I"
#define RAYON_DE_VISUALISATION \
FRA5(FRA10(mhXYZlongueur_ESPACE))
DEFV(Local,DEFV(Float,INIT(rayon_de_visualisation,RAYON_DE_VISUALISATION)));
/* Rayon du disque materialisant une iteration. */
BFonctionI
DEFV(Local,DEFV(FonctionI,memorisation_1_point_07(AXf,AYf,AZf,AdXf,AdYf,AdZf,numero_de_l_iteration_courante)))
DEFV(Argument,DEFV(Float,AXf));
DEFV(Argument,DEFV(Float,AYf));
DEFV(Argument,DEFV(Float,AZf));
/* Definition de la position {x,y,z} de l'iteration courante. */
DEFV(Argument,DEFV(Float,AdXf));
DEFV(Argument,DEFV(Float,AdYf));
DEFV(Argument,DEFV(Float,AdZf));
/* Definition des differentielles {dx,dy,dz} de la position de l'iteration courante. */
DEFV(Argument,DEFV(Int,numero_de_l_iteration_courante));
/* Numero de l'iteration courante afin d'attenuer eventuellement la luminance des points */
/* materialisant chaque iteration en fonction de leur numero (les premieres iterations etant */
/* plus sombres, et les dernieres etant plus lumineuses). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
#include xrk/attractor.15.I"
INIT_ERROR;
/*..............................................................................................................................*/
MEMORISATION_DU_POINT_COURANT(X_DERIVEE_DANS_01(AdXf)
,Y_DERIVEE_DANS_01(AdYf)
,Z_DERIVEE_DANS_01(AdZf)
);
/* Memorisation du point courant en Noir et Blanc ou en Couleurs, mais uniquement s'il est */
/* visible en fonction des conditions de visualisation... */
RETU_ERROR;
Eblock
EFonctionI
BFonctionI
DEFV(Local,DEFV(FonctionI,memorisation_d_un_point_grave(AXf,AYf,AZf,AdXf,AdYf,AdZf,id,ma,VXf,VYf,VZf,numero_de_l_iteration_courante)))
DEFV(Argument,DEFV(Float,AXf));
DEFV(Argument,DEFV(Float,AYf));
DEFV(Argument,DEFV(Float,AZf));
/* Definition de la position {x,y,z} de l'iteration courante. */
DEFV(Argument,DEFV(Float,AdXf));
DEFV(Argument,DEFV(Float,AdYf));
DEFV(Argument,DEFV(Float,AdZf));
/* Definition des differentielles {dx,dy,dz} de la position de l'iteration courante. */
DEFV(Argument,DEFV(Int,id));
/* Identite de l'iteration courante... */
DEFV(Argument,DEFV(Float,ma));
/* Masse de l'iteration courante... */
DEFV(Argument,DEFV(Float,VXf));
DEFV(Argument,DEFV(Float,VYf));
DEFV(Argument,DEFV(Float,VZf));
/* Definition de la vitesse (Vx,Vy,Vz) de l'iteration courante. */
DEFV(Argument,DEFV(Int,numero_de_l_iteration_courante));
/* Numero de l'iteration courante afin d'attenuer eventuellement la luminance des points */
/* materialisant chaque iteration en fonction de leur numero (les premieres iterations etant */
/* plus sombres, et les dernieres etant plus lumineuses). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
#include xrk/attractor.15.I"
INIT_ERROR;
/*..............................................................................................................................*/
DEFINITION_DE_L_IDENTITE_DE_LA_SPHERE_COURANTE(id);
/* Memorisation de l'identite du point courant. */
DEFINITION_DE_LA_MASSE_DE_LA_SPHERE_COURANTE(ma);
/* Memorisation de la masse du point courant. */
DEFINITION_DE_LA_VITESSE_DE_LA_SPHERE_COURANTE(VXf,VYf,VZf);
/* Memorisation de la vitesse du point courant. */
CALS(memorisation_1_point_07(AXf,AYf,AZf
,AdXf,AdYf,AdZf
,numero_de_l_iteration_courante
)
);
/* Memorisation du point courant en Noir et Blanc ou en Couleurs, mais uniquement s'il est */
/* visible en fonction des conditions de visualisation... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E V I S U A L I S A T I O N E T D ' I N T E R P O L A T I O N : */
/* */
/*************************************************************************************************************************************/
#define __VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND \
/* Afin de permettre la mise en place d'un fond pour chaque image generee (definition */ \
/* deplacee ici le 20030313151603). D'autre part 'PERMETTRE_L_UTILISATION_D_UN_FOND' */ \
/* a ete change en '__VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND' le 20030313145928 */ \
/* afin de permettre sa recuperation dans 'v $xcc/cpp$Z _VERSION_'. */
#include xrk/attractor.17.I"
#include xrv/particule.31.I"
#define VISUALISER_L_ENSEMBLE_DES_INSTANTS \
FAUX
DEFV(Local,DEFV(Logical,INIT(visualiser_l_ensemble_des_instants,VISUALISER_L_ENSEMBLE_DES_INSTANTS)));
/* Doit-on visualiser l'ensemble des instants ('VRAI') ou bien uniquement l'instant */
/* precedent ('FAUX'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' I N V E R S I O N D U P R O C E S S U S : */
/* */
/*************************************************************************************************************************************/
#define INVERSER_LE_PROCESSUS \
FAUX
DEFV(Local,DEFV(Logical,INIT(inverser_le_processus,INVERSER_LE_PROCESSUS)));
/* Doit-on inverser le processus a un certain instant ('VRAI') ou pas ('FAUX') ; lorsque */
/* 'IL_FAUT(inverser_le_processus)', c'est 'periode_d_inversion_du_processus' qui definit */
/* la periode d'inversion... */
#define PERIODE_D_INVERSION_DU_PROCESSUS \
MOINS_L_INFINI
DEFV(Local,DEFV(Int,INIT(periode_d_inversion_du_processus,PERIODE_D_INVERSION_DU_PROCESSUS)));
/* Donne le numero de la periode ou toutes les vitesses seront arbitrairement inversees. */
/* Lorsqu'il n'y a aucun processus aleatoires actifs, cela permet de voir si l'on revient */
/* aux conditions initiales aux environ de 'DOUB(periode_d_inversion_du_processus)'... */
/* En fait, cela ne doit pas fonctionner systematiquement car, en effet, il y a le phenomene */
/* de collisions : on ne decrete pas qu'il y a collision lorsque les particules s'eloignent */
/* les unes des autres (cas par exemple des conditions initiales) ; en inversant pour chaque */
/* particule les vitesses, les particules vont donc se rapprocher les unes des autres, et */
/* on risque donc de decreter des collisions qui n'avaient pas eu lieu a l'aller... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A M A R C H E A L E A T O I R E : */
/* */
/* */
/* Definition : */
/* */
/* Soit la famille {C ,C ,...,C } de 'N' */
/* 1 2 N */
/* corps. A chaque pas de temps, et en coordonnees */
/* spheriques, les coordonnees de ceux-ci sont */
/* translatees a l'aide de trois increments en */
/* 'theta', 'phi' et 'rho'. */
/* */
/* */
/*************************************************************************************************************************************/
#define LIMITER_AUTOMATIQUEMENT_TENTATIVES_RECHERCHE_BONNE_PERTURBATION \
VRAI
DEFV(Local,DEFV(Logical,INIT(limiter_automatiquement_tentatives_recherche_bonne_perturbation
,LIMITER_AUTOMATIQUEMENT_TENTATIVES_RECHERCHE_BONNE_PERTURBATION
)
)
);
#define NOMBRE_MAXIMAL_DE_TENTATIVES_DE_RECHERCHE_D_UNE_BONNE_PERTURBATION \
CENT
DEFV(Local,DEFV(Int,INIT(nombre_maximal_de_tentatives_de_recherche_d_une_bonne_perturbation
,NOMBRE_MAXIMAL_DE_TENTATIVES_DE_RECHERCHE_D_UNE_BONNE_PERTURBATION
)
)
);
/* Lors de la recherche d'une vitesse perturbee satisfaisant aux contraintes imposees (dues */
/* au champ de force et a la distance maximale par rapport a l'origine), lorsque celles-ci */
/* ne peuvent etre satisfaites, il faut imposer un nombre maximal de tentatives afin de ne */
/* pas boucler. Ce nombre peut etre calcule automatiquement a partir des parametres, ou bien */
/* etre impose arbitrairement (l'etat implicite est 'VRAI' afin d'assurer la compatibilite */
/* avec les anciennes sequences generees avant le 1995110200). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C O N S T A N T E S D U P R O B L E M E : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S L I S T E S D E S C R I P T I V E S I N I T I A L E S D E S C O R P S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, a ne pas confondre : */
/* */
/* 1-'nombre_de_periodes_de_la_simulation' qui definit finalement le nombre d'images que */
/* l'on va generer et qui conditionne toutes les listes (sans exception...) definies par */
/* 'fTRANSFORMAT_31(...)', et */
/* */
/* 2-'nombre_d_iterations' qui definit le nombre de particules visualisees dans chaque */
/* image ; les listes relatives aux particules sont definies elles-aussi a l'aide de la */
/* procedure 'dTRANSFORMAT_31(...)' ce qui signifie que 'nombre_d_iterations' est limite */
/* par 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION'... */
/* */
dfTRANSFORMAT_31(liste_initiale_des_IDENTITE,fichier_LISTE_IDENTITE,IDENTITE_IMPLICITE,PREMIER_POINT_DES_LISTES)
#define vIDENTITE_IMPLICITE \
index
#define gACCES_IDENTITES(corps) \
IdTb1(liste_initiale_des_IDENTITE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_IDENTITES(corps) \
INTE(gACCES_IDENTITES(corps))
/* Definition des fichiers de listes des identites (introduit le 19991112155016). En ce */
/* qui concerne la definition inhabituelle (et non constante) de 'vIDENTITE_IMPLICITE', elle */
/* est due au fait que a priori les 'IDENTITE's doivent etre toutes differentes. La */
/* variable 'index' est l'index d'initialisation que l'on trouve dans */
/* 'v $xrv/champs_5.41$I gINITIALISATION_LISTE' via 'v $xrq/nucleon.Lf.2$I iTRANSFORMATION'. */
#define PARTICULE_IMMORTELLE \
F_INFINI
dfTRANSFORMAT_31(liste_initiale_des_DATE_DE_NAISSANCE,fichier_LISTE_DATE_DE_NAISSANCE,DATE_DE_NAISSANCE_IMPLICITE,INSTANT_INITIAL)
dfTRANSFORMAT_31(liste_initiale_des_DATE_DE_MORT,fichier_LISTE_DATE_DE_MORT,DATE_DE_MORT_IMPLICITE,PARTICULE_IMMORTELLE)
/* Definition des fichiers de listes de dates de naissance et de mort. */
dfTRANSFORMAT_31(liste_initiale_des_X,fichier_LISTE_X,X_IMPLICITE,Xcentre_ESPACE)
dfTRANSFORMAT_31(liste_initiale_des_Y,fichier_LISTE_Y,Y_IMPLICITE,Ycentre_ESPACE)
dfTRANSFORMAT_31(liste_initiale_des_Z,fichier_LISTE_Z,Z_IMPLICITE,hZmin_ESPACE)
/* Definition des fichiers de listes de coordonnees. */
/* Definition des coordonnees implicites. On notera l'utilisation de 'hZmin_ESPACE' et non */
/* pas de 'Zcentre_ESPACE' comme le voudrait la logique ; ceci est du au fait que cette */
/* derniere valeur interferait malheureusement avec la position de l'observateur dans le */
/* cube de visualisation, et rendrait invisible les particules... */
dfTRANSFORMAT_31(liste_initiale_des_VX,fichier_LISTE_VX,VX_IMPLICITE,FZERO)
dfTRANSFORMAT_31(liste_initiale_des_VY,fichier_LISTE_VY,VY_IMPLICITE,FZERO)
dfTRANSFORMAT_31(liste_initiale_des_VZ,fichier_LISTE_VZ,VZ_IMPLICITE,FZERO)
/* Definition des fichiers de listes de vitesses. */
dfTRANSFORMAT_31(liste_initiale_des_MOBILITE,fichier_LISTE_MOBILITE,MOBILITE_IMPLICITE,VRAI)
/* Definition du fichier de l'indicateur de mobilite des corps. */
dfTRANSFORMAT_31(liste_initiale_des_MINIMUM_DELTA_RHO
,fichier_LISTE_MINIMUM_DELTA_RHO
,MINIMUM_DELTA_RHO_IMPLICITE
,NEGA(FRA4(FRA10(mhXYZlongueur_ESPACE)))
)
dfTRANSFORMAT_31(liste_initiale_des_MAXIMUM_DELTA_RHO
,fichier_LISTE_MAXIMUM_DELTA_RHO
,MAXIMUM_DELTA_RHO_IMPLICITE
,NEUT(FRA4(FRA10(mhXYZlongueur_ESPACE)))
)
/* Definition des fichiers de listes de variations des 'rho's. */
dfTRANSFORMAT_31(liste_initiale_des_MINIMUM_N_PHI,fichier_LISTE_MINIMUM_N_PHI,MINIMUM_N_PHI_IMPLICITE,NEGA(DEUX))
dfTRANSFORMAT_31(liste_initiale_des_MAXIMUM_N_PHI,fichier_LISTE_MAXIMUM_N_PHI,MAXIMUM_N_PHI_IMPLICITE,NEUT(DEUX))
dfTRANSFORMAT_31(liste_initiale_des_DELTA_PHI,fichier_LISTE_DELTA_PHI,DELTA_PHI_IMPLICITE,PI_SUR_2)
/* Definition des fichiers de listes de variations des 'phi's (ou "longitude"). */
/* */
/* ATTENTION, par la suite, les quantites du type 'MINIMUM_N_?' et 'MAXIMUM_N_?' sont */
/* traitees comme des quantites entieres (en particulier, on fait des 'ARRO(...)' sur les */
/* nombres aleatoires 'variation_de_phi' et 'variation_de_theta' qu'elles permettent de */
/* generer...). */
dfTRANSFORMAT_31(liste_initiale_des_MINIMUM_N_THETA,fichier_LISTE_MINIMUM_N_THETA,MINIMUM_N_THETA_IMPLICITE,NEGA(DEUX))
dfTRANSFORMAT_31(liste_initiale_des_MAXIMUM_N_THETA,fichier_LISTE_MAXIMUM_N_THETA,MAXIMUM_N_THETA_IMPLICITE,NEUT(DEUX))
dfTRANSFORMAT_31(liste_initiale_des_DELTA_THETA,fichier_LISTE_DELTA_THETA,DELTA_THETA_IMPLICITE,PI_SUR_2)
/* Definition des fichiers de listes de variations des 'theta's (ou "distance polaire"). */
dfTRANSFORMAT_31(liste_initiale_des_DISTANCE_MAXIMALE
,fichier_LISTE_DISTANCE_MAXIMALE
,DISTANCE_MAXIMALE_IMPLICITE
,MOIT(mhXYZlongueur_ESPACE)
)
/* Definition des fichiers de listes de distances maximales. */
dfTRANSFORMAT_31(liste_initiale_des_STABILITE,fichier_LISTE_STABILITE,STABILITE_IMPLICITE,MOIT(FLOT(INFINI)))
/* Definition des fichiers de listes de stabilite. La "stabilite" est le nombre de periodes */
/* pendant lequel un corps ne change pas de direction de facon aleatoire. Jusqu'au */
/* 20010925114526, la valeur de 'STABILITE_IMPLICITE' etait de 'HUIT'. En fait cette */
/* valeur provient des versions anterieures (par exemple 'v $xrk/rdn_walk.21$K HUIT') lors */
/* d'utilisation de type "marche aleatoire pure et dure". Or, par exemple, avec cette */
/* version, la marche aleatoire n'est pratiquement plus utilisee ; il est donc preferable */
/* (car moins dangereux...) d'utiliser une valeur quasiment infinie. Ainsi, on ne verra */
/* jamais (du moins jamais au bout d'un temps raisonnable...) une particule subir une */
/* deviation aleatoire, sauf, evidemment, si elle est demandee explicitement. On notera */
/* l'utilisation de 'FLOT(INFINI)' (et non de 'F_PETIT_INFINI' comme je l'avais tente) a */
/* cause de la liste 'liste_des_stabilites_a_l_instant_courant' qui est de type 'Int' */
/* et qui est initialisee avec 'STABILITE_IMPLICITE'... */
/* */
/* Le 20111027092810, 'FLOT(INFINI)' a ete remplace par 'MOIT(FLOT(INFINI))' afin d'eviter */
/* le message : */
/* */
/* warning: overflow in implicit constant conversion */
/* */
/* sur '$LACT19'... */
dfTRANSFORMAT_31(liste_initiale_des_RAYON,fichier_LISTE_RAYON,RAYON_IMPLICITE,RAYON_DE_VISUALISATION)
/* Definition du fichier de liste des rayons de materialisation. */
/* */
/* ATTENTION, le rayon est en unite d'ecran [0,1]. */
dfTRANSFORMAT_31(liste_initiale_des_RAYON_D_INTERACTION
,fichier_LISTE_RAYON_D_INTERACTION
,RAYON_D_INTERACTION_IMPLICITE
,RAYON_DE_VISUALISATION
)
/* Definition du fichier de liste des rayons d'interaction (introduit le 19980115090818). */
/* Le 19980213090623, je suis passe de 'RAYON_D_INTERACTION_IMPLICITE' ayant la valeur */
/* 'FRA4(FRA10(FU))' a 'FACTEUR_DU_RAYON_D_INTERACTION_IMPLICITE' valant 'FU' car c'est */
/* plus logique de definir l'interaction en fonction du rayon des particules et non pas */
/* de facon absolue. Le 19980224182217, je suis en fait revenu a la notion anterieure car, */
/* en effet, sur des sequences du type : */
/* */
/* xivPdf 11 2 / 003073_003584 */
/* */
/* qui sont generees par superposition des trajectoires filiformes et de cometes. Il est */
/* donc imperatif de faire les deux calculs dans les memes conditions, meme si les rayons */
/* de visualisation sont differents... */
dfTRANSFORMAT_31(liste_initiale_des_ROUGE,fichier_LISTE_ROUGE,ROUGE_IMPLICITE,BLANC)
dfTRANSFORMAT_31(liste_initiale_des_VERTE,fichier_LISTE_VERTE,VERTE_IMPLICITE,BLANC)
dfTRANSFORMAT_31(liste_initiale_des_BLEUE,fichier_LISTE_BLEUE,BLEUE_IMPLICITE,BLANC)
/* Definition des fichiers de listes de couleurs. */
/* */
/* ATTENTION, les couleurs des points a visualiser doivent etre definies ainsi : */
/* */
/* ROUGE E [NOIR,BLANC] */
/* VERTE E [NOIR,BLANC] */
/* BLEUE E [NOIR,BLANC] */
/* */
dfTRANSFORMAT_31(liste_initiale_des_MASSE,fichier_LISTE_MASSE,MASSE_IMPLICITE,FU)
#define ACCES_MASSES(corps) \
IdTb1(liste_initiale_des_MASSE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition du fichier de liste des masses et de son acces. */
dfTRANSFORMAT_31(liste_initiale_des_CHARGE_A,fichier_LISTE_CHARGE_A,CHARGE_A_IMPLICITE,FU)
#define ACCES_CHARGES_A(corps) \
IdTb1(liste_initiale_des_CHARGE_A \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
dfTRANSFORMAT_31(liste_initiale_des_CHARGE_R,fichier_LISTE_CHARGE_R,CHARGE_R_IMPLICITE,FU)
#define ACCES_CHARGES_R(corps) \
IdTb1(liste_initiale_des_CHARGE_R \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition des fichiers de liste des charges et de son acces. */
dfTRANSFORMAT_31(liste_initiale_des_SOURCE_DU_POTENTIEL,fichier_LISTE_SOURCE_DU_POTENTIEL,SOURCE_DU_POTENTIEL_IMPLICITE,VRAI)
#define gACCES_SOURCES_DU_POTENTIEL(corps) \
IdTb1(liste_initiale_des_SOURCE_DU_POTENTIEL \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_SOURCES_DU_POTENTIEL(corps) \
LOGI(gACCES_SOURCES_DU_POTENTIEL(corps))
/* Definition du fichier de liste des indicateurs de source gravitationnelle possible. */
#define NOMBRE_DE_PERIODES_PAR_IMAGE \
UN
DEFV(Local,DEFV(Int,INIT(nombre_de_periodes_par_image,NOMBRE_DE_PERIODES_PAR_IMAGE)));
/* Nombre de periodes par image introduit le 20020828095224 afin de resoudre un probleme */
/* rencontre avec la sequence 'v _____xivPdf_12_1/011777_012288' ou le temps ecoule entre */
/* deux images est trop important et ou donc le point representatif se "deplace trop vite". */
/* Ainsi, sur la meme image il sera possible de visualiser plusieurs periodes... */
/* */
/* En resume, une image correspondra a : */
/* */
/* nombre_de_periodes_par_image*nombre_de_pas_de_temps_par_periode */
/* */
/* pas de temps et dans chaque image seront visualises 'nombre_de_periodes_par_image' */
/* pas de temps, espaces de 'nombre_de_pas_de_temps_par_periode' pas de temps. Ainsi, */
/* on peut dire que dorenavant, il est possible (a compter du 20020828095224) de generer */
/* des images qui sont la "superposition" de 'nombre_de_periodes_par_image' images du */
/* type anterieur... */
/* */
/* On notera que ce nouveau parametre a conduit a l'introduction le 20020828144254 de */
/* 'v $ximd/operator.1$FON TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE_____faire_un_IFGT' */
/* qui permet de jouer sur l'ordre du tri d'une liste ne contenant que des elements */
/* identiques par 'TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_AU_CARRE(...)'. En effet, lorsque */
/* tous les 'Z' sont identiques et que plusieurs periodes sont a visualiser dans chaque */
/* image, il est essentiel que, pour chaque particule, la plus recente soit visualisee en */
/* premier afin qu'elle semble etre devant les plus anciennes (ce qui simule visuellement */
/* une fleche...). Cela s'est vu en generant la sequence : */
/* */
/* xivPdf 12 1 / 012801_013312 */
/* */
#define NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE \
GRO1(GRO1(UN))
DEFV(Local,DEFV(Int,INIT(nombre_de_pas_de_temps_par_periode,NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE)));
/* Definition du nombre de pas de temps que l'on effectue pour une periode (c'est-a-dire */
/* entre deux images calculees). On notera que lorsqu'il y a prise en compte de phenomenes */
/* telle la reflexion ou la refraction, il est essentiel que le pas de temps ait une valeur */
/* telle que l'on ne manque pas des details petits des champs. On aura interet alors a */
/* utiliser un petit pas de temps et un nombre de pas de temps par periode important. */
#define UTILISER_UN_PAS_DE_TEMPS_VARIABLE \
FAUX
DEFV(Local,DEFV(Logical,INIT(utiliser_un_pas_de_temps_variable,UTILISER_UN_PAS_DE_TEMPS_VARIABLE)));
/* La possibilite d'avoir un pas de temps variable a ete introduite le 20011022110739. */
/* Une premiere application de cela sera de permettre l'acceleration ou encore le ralenti */
/* d'une simulation en "cours de route". Une seconde application sera de permettre de figer */
/* (avec un 'dct' tres petit ou nul) une simulation afin de permettre pendant quelques temps */
/* de tourner, par exemple, autour d'elle... */
dfTRANSFORMAT_31(liste_initiale_des_PAS_DE_TEMPS,fichier_LISTE_PAS_DE_TEMPS,PAS_DE_TEMPS_IMPLICITE,DCT)
#define ACCES_PAS_DE_TEMPS(numero_de_la_periode) \
sTRANSFORMAT_31(numero_de_la_periode \
,liste_initiale_des_PAS_DE_TEMPS \
) \
/* Definition du fichier de liste des pas de temps. */
dfTRANSFORMAT_31(liste_initiale_des_NOMBRES,fichier_LISTE_NOMBRES,NOMBRES_IMPLICITE,NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE)
#define ACCES_NOMBRES(numero_de_la_periode) \
sTRANSFORMAT_31(numero_de_la_periode \
,liste_initiale_des_NOMBRES \
) \
/* Definition du fichier de liste des nombres. */
#define NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE_EFFECTIF \
COND(IL_NE_FAUT_PAS(faire_de_l_interaction_gravitationnelle_generalisee) \
,nombre_de_pas_de_temps_par_periode \
,GRO1(nombre_de_pas_de_temps_par_periode) \
)
/* Lorsque 'IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee)', on pourra etre */
/* amene ulterieurement a reduire le pas de temps et a augmenter correlativement le nombre */
/* de pas de temps par periode... */
#include xrv/particule.21.I"
/* ATTENTION, a ne pas confondre : */
/* */
/* 1-'nombre_de_periodes_de_la_simulation' qui definit finalement le nombre d'images que */
/* l'on va generer et qui conditionne toutes les listes (sans exception...) definies par */
/* 'fTRANSFORMAT_31(...)', et */
/* */
/* 2-'nombre_d_iterations' qui definit le nombre de particules visualisees dans chaque */
/* image ; les listes relatives aux particules sont definies elles-aussi a l'aide de la */
/* procedure 'dTRANSFORMAT_31(...)' ce qui signifie que 'nombre_d_iterations' est limite */
/* par 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION'... */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S L I S T E S D E S C R I P T I V E S C O U R A N T E S D E S C O R P S : */
/* */
/*************************************************************************************************************************************/
DEFV(Float,DdTb1(POINTERf
,liste_des_dates_de_naissance
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_DATES_DE_NAISSANCE(corps) \
IdTb1(liste_des_dates_de_naissance \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Float,DdTb1(POINTERf
,liste_des_dates_de_mort
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_DATES_DE_MORT(corps) \
IdTb1(liste_des_dates_de_mort \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(pointF_3D,DdTb1(POINTERs
,liste_des_coordonnees_a_l_instant_initial
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COORDONNEES_INITIALES(corps) \
IdTb1(liste_des_coordonnees_a_l_instant_initial \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(deltaF_3D,DdTb1(POINTERs
,liste_des_vitesses_a_l_instant_initial
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_VITESSE_INITIALE(corps) \
IdTb1(liste_des_vitesses_a_l_instant_initial \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition de l'instant initial. */
DEFV(pointF_3D,DdTb1(POINTERs
,liste_des_coordonnees_a_l_instant_precedent
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COORDONNEES_PRECEDENTES(corps) \
IdTb1(liste_des_coordonnees_a_l_instant_precedent \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Float,DdTb2(POINTERf
,matrice_des_distances_a_l_instant_precedent
,nombre_de_corps
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_DISTANCES_PRECEDENTES(corpsI,corpsJ) \
IdTb2(matrice_des_distances_a_l_instant_precedent \
,INDX(corpsI,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
,INDX(corpsJ,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition de l'instant precedent. */
DEFV(deltaF_3D,DdTb1(POINTERs
,liste_des_vitesses_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_VITESSE_COURANTE(corps) \
IdTb1(liste_des_vitesses_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(pointF_3D,DdTb1(POINTERs
,liste_des_coordonnees_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COORDONNEES_COURANTES(corps) \
IdTb1(liste_des_coordonnees_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Int,DdTb1(POINTERi
,liste_des_stabilites_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_STABILITES_COURANTES(corps) \
IdTb1(liste_des_stabilites_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Logical,DdTb1(POINTERl
,liste_des_blocages_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_BLOCAGES_COURANTS(corps) \
IdTb1(liste_des_blocages_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Logical,DdTb1(POINTERl
,liste_des_reflexions_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_REFLEXIONS_COURANTS(corps) \
IdTb1(liste_des_reflexions_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Logical,DdTb1(POINTERl
,liste_des_refractions_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_REFRACTIONS_COURANTS(corps) \
IdTb1(liste_des_refractions_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(genere_Float,DdTb1(POINTERf
,liste_des_niveaux_locaux_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define NIVEAU_LOCAL_COURANT_INITIAL \
F_MOINS_L_INFINI \
/* Il est imperatif que cette valeur soit hors de [0,1] (introduit le 19990927173502). */
#define ACCES_NIVEAUX_LOCAUX_COURANTS(corps) \
IdTb1(liste_des_niveaux_locaux_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Positive,DdTb1(POINTERi
,liste_des_compteurs_de_collisions_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COMPTEURS_COLLISIONS_COURANTS(corps) \
IdTb1(liste_des_compteurs_de_collisions_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Positive,DdTb1(POINTERi
,liste_des_compteurs_de_reflexions_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COMPTEURS_REFLEXIONS_COURANTS(corps) \
IdTb1(liste_des_compteurs_de_reflexions_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
DEFV(Positive,DdTb1(POINTERi
,liste_des_compteurs_de_refractions_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COMPTEURS_REFRACTIONS_COURANTS(corps) \
IdTb1(liste_des_compteurs_de_refractions_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition de l'instant courant. */
#define NOMBRE_EFFECTIF_DE_PERIODES_DE_LA_SIMULATION \
MUL2(nombre_de_periodes_de_la_simulation,nombre_de_periodes_par_image) \
/* Nombre de periodes de la simulation a compter du 20020828095224 qui peut donc etre a */ \
/* compter de cette date un multiple (via 'nombre_de_periodes_par_image') du nombre */ \
/* d'images generees ('nombre_de_periodes_de_la_simulation'). */
DEFV(pointF_3D,DdTb2(POINTERs
,liste_des_coordonnees_cumule_sur_toute_la_duree
,nombre_de_corps
,NOMBRE_EFFECTIF_DE_PERIODES_DE_LA_SIMULATION
,ADRESSE_NON_ENCORE_DEFINIE
)
);
#define ACCES_COORDONNEES_CUMULEES(corps,periode) \
IdTb2(liste_des_coordonnees_cumule_sur_toute_la_duree \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
,INDX(periode,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION) \
,NOMBRE_EFFECTIF_DE_PERIODES_DE_LA_SIMULATION \
) \
/* Definition de l'ensemble des instants cumules. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U X L I S T E S : */
/* */
/*************************************************************************************************************************************/
#define DERNIER_POINT_DES_LISTES \
LSTX(PREMIER_POINT_DES_LISTES,nombre_de_corps) \
/* Definition du dernier point des listes. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U P O I N T D E R E F E R E N C E C O U R A N T : */
/* */
/*************************************************************************************************************************************/
#include xrr/N_corps.11.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N A L B U M : */
/* */
/*************************************************************************************************************************************/
#include xrk/rdn_walk.31.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P E R I O D I S A T I O N D E L ' U N I V E R S : */
/* */
/*************************************************************************************************************************************/
#define PERIODISER_L_UNIVERS_X \
FAUX
#define PERIODISER_L_UNIVERS_Y \
FAUX
#define PERIODISER_L_UNIVERS_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(periodiser_l_univers_X,PERIODISER_L_UNIVERS_X)));
DEFV(Local,DEFV(Logical,INIT(periodiser_l_univers_Y,PERIODISER_L_UNIVERS_Y)));
DEFV(Local,DEFV(Logical,INIT(periodiser_l_univers_Z,PERIODISER_L_UNIVERS_Z)));
/* Indique si l'univers doit etre periodise ('VRAI') par rapport a : */
/* */
/* {Xmin_ESPACE,Ymin_ESPACE,Zmin_ESPACE}x{Xmax_ESPACE,Ymax_ESPACE,Zmax_ESPACE} */
/* */
/* ou pas ('FAUX'). Cette option ('FAUX' par defaut pour des raisons de compatibilite) */
/* a ete introduite le 19991215115703. */
/* */
/* ATTENTION, le 20000426173130, j'ai decouvert un probleme delicat lors de la periodisation */
/* des coordonnees. En effet, une particule P1 lors de cette operation de trouve transportee */
/* de facon brutale d'un point a un autre sans respecter les regles habituelles de gestion */
/* des collisions en particulier. Ainsi P1 peut donc se retrouver en un lieu deja occupe */
/* (a epsilon pres) par une autre particule P2, alors que par des voies "normales", cela */
/* aurait ete impossible. Ensuite, en quelques pas de temps, le mecanisme des collisions */
/* fera son office, et P1 et P2 s'eloigneront l'une de l'autre... */
#define PERIODISER_L_UNIVERS_PAR_SYMETRIE_CENTRALE \
FAUX
DEFV(Local,DEFV(Logical,INIT(periodiser_l_univers_par_symetrie_centrale,PERIODISER_L_UNIVERS_PAR_SYMETRIE_CENTRALE)));
/* Cette option a ete introduite le 20000426134444 afin de conserver une possibilite de */
/* compatibilite avec les sequences generees anterieurement : on utilisera alors la */
/* valeur 'VRAI', alors que la valeur 'FAUX' par defaut correspond a la methode correcte */
/* de periodisation... */
#define PERIODISER_L_UNIVERS \
Bblock \
Test(I3OU(IL_FAUT(periodiser_l_univers_X) \
,IL_FAUT(periodiser_l_univers_Y) \
,IL_FAUT(periodiser_l_univers_Z) \
) \
) \
Bblock \
Komp(corps,nombre_de_corps) \
Bblock \
INITIALISATION_POINT_3D(ACCES_COORDONNEES_COURANTES(corps) \
,COND(IFOU(IL_NE_FAUT_PAS(periodiser_l_univers_X) \
,IFINff(ASD1(ACCES_COORDONNEES_COURANTES(corps),x) \
,ASD2(espace_physique,origine,x) \
,ASD2(espace_physique,extremite,x) \
) \
) \
,NEUT(ASD1(ACCES_COORDONNEES_COURANTES(corps),x)) \
,COND(IL_FAUT(periodiser_l_univers_par_symetrie_centrale) \
,ADD2(NEGA(SOUS(ASD1(ACCES_COORDONNEES_COURANTES(corps),x) \
,ASD1(centre_de_l_espace_physique,x) \
) \
) \
,ASD1(centre_de_l_espace_physique,x) \
) \
,MODF(ASD1(ACCES_COORDONNEES_COURANTES(corps),x) \
,ASD2(espace_physique,origine,x) \
,ASD2(espace_physique,extremite,x) \
) \
) \
) \
,COND(IFOU(IL_NE_FAUT_PAS(periodiser_l_univers_Y) \
,IFINff(ASD1(ACCES_COORDONNEES_COURANTES(corps),y) \
,ASD2(espace_physique,origine,y) \
,ASD2(espace_physique,extremite,y) \
) \
) \
,NEUT(ASD1(ACCES_COORDONNEES_COURANTES(corps),y)) \
,COND(IL_FAUT(periodiser_l_univers_par_symetrie_centrale) \
,ADD2(NEGA(SOUS(ASD1(ACCES_COORDONNEES_COURANTES(corps),y) \
,ASD1(centre_de_l_espace_physique,y) \
) \
) \
,ASD1(centre_de_l_espace_physique,y) \
) \
,MODF(ASD1(ACCES_COORDONNEES_COURANTES(corps),y) \
,ASD2(espace_physique,origine,y) \
,ASD2(espace_physique,extremite,y) \
) \
) \
) \
,COND(IFOU(IL_NE_FAUT_PAS(periodiser_l_univers_Z) \
,IFINff(ASD1(ACCES_COORDONNEES_COURANTES(corps),z) \
,ASD2(espace_physique,origine,z) \
,ASD2(espace_physique,extremite,z) \
) \
) \
,NEUT(ASD1(ACCES_COORDONNEES_COURANTES(corps),z)) \
,COND(IL_FAUT(periodiser_l_univers_par_symetrie_centrale) \
,ADD2(NEGA(SOUS(ASD1(ACCES_COORDONNEES_COURANTES(corps),z) \
,ASD1(centre_de_l_espace_physique,z) \
) \
) \
,ASD1(centre_de_l_espace_physique,z) \
) \
,MODF(ASD1(ACCES_COORDONNEES_COURANTES(corps),z) \
,ASD2(espace_physique,origine,z) \
,ASD2(espace_physique,extremite,z) \
) \
) \
) \
); \
/* Et on periodise par rapport au centre de l'univers (suppose au centre...). */ \
/* */ \
/* ATTENTION, jusqu'au 20000426134444, je me suis rendu compte d'une anomalie dans la */ \
/* gestion de la periodisation, d'ou loption 'periodiser_l_univers_par_symetrie_centrale'. */ \
Eblock \
EKom \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Periodisation de l'univers. ATTENTION 'PERIODISER_L_UNIVERS' ne peut etre appelee */ \
/* qu'apres 'MOYENNAGE_DES_VITESSES_PAR_FAMILLE' car cette derniere procedure, lorsqu'elle */ \
/* est utile, recalcule 'ACCES_COORDONNEES_COURANTES(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' U N C H A M P D E F O R C E T R I D I M E N S I O N N E L : */
/* */
/*************************************************************************************************************************************/
dfTRANSFORMAT_31(liste_initiale_des_BORNE_INFERIEURE_DE_L_OUVERTURE
,fichier_LISTE_BORNE_INFERIEURE_DE_L_OUVERTURE
,BORNE_INFERIEURE_DE_L_OUVERTURE_IMPLICITE
,FZERO
)
dfTRANSFORMAT_31(liste_initiale_des_BORNE_SUPERIEURE_DE_L_OUVERTURE
,fichier_LISTE_BORNE_SUPERIEURE_DE_L_OUVERTURE
,BORNE_SUPERIEURE_DE_L_OUVERTURE_IMPLICITE
,PI
)
/* Definition du segment [inf,sup] dans lequel doit se trouver l'angle entre la vitesse */
/* perturbee et le gradient du champ de force pour que le deplacement aleatoire soit */
/* accepte. */
#define UTILISER_UN_CHAMP_DE_FORCE \
FAUX
DEFV(Local,DEFV(Logical,INIT(utiliser_un_champ_de_force,UTILISER_UN_CHAMP_DE_FORCE)));
/* Indique s'il faut contraindre le generateur par un champ de force defini par un album */
/* d'images ('VRAI') ou pas ('FAUX') auquel cas on n'utilise que 'LISTE_DISTANCE_MAXIMALE'. */
#define F_nPASX \
QUATRE
#define F_nPASY \
QUATRE
#define F_nPASZ \
UN
DEFV(Local,DEFV(Int,INIT(F_NpasX,F_nPASX)));
DEFV(Local,DEFV(Int,INIT(F_NpasY,F_nPASY)));
DEFV(Local,DEFV(Int,INIT(F_NpasZ,F_nPASZ)));
/* Indique les demi-dimensions (en nombre de points) des volumes elementaires du champ */
/* de force dans lequel on calcule le gradient. */
#define ADAPTER_LES_F_nPAS \
FAUX
DEFV(Local,DEFV(Logical,INIT(adapter_les_F_nPAS,ADAPTER_LES_F_nPAS)));
/* Indique si les 'F_Npas?' doivent etre adaptes automatiquement en fonction du mouvement */
/* de chaque particule ('VRAI') ou bien utilises tel quels ('FAUX'). */
#include xci/sequence.01.I"
/* ATTENTION, on definit ainsi le symbole 'DERNIERE_IMAGE' qui ne sert a rien ici, puisque */
/* c'est en effet 'Zmax' qui joue ce role... */
DEFV(Local,DEFV(Int,INIT(F_premiere_coupe,PREMIERE_IMAGE)));
/* Numero de la premiere coupe du champ de force. */
DEFV(Local,DEFV(Int,INIT(F_pas_des_coupes,PAS_DES_IMAGES)));
/* Pas de passage d'un numero de coupe a une autre. */
DEFV(Local,DEFV(Int,INIT(F_nombre_de_chiffres_pour_le_champ,NOMBRE_DE_CHIFFRES)));
/* Nombre de chiffres codant le numero des coupes de la serie... */
#define F_ATTENDRE_LES_IMAGES_INEXISTANTES \
VRAI
DEFV(Local,DEFV(Logical,INIT(F_attendre_les_images_inexistantes,F_ATTENDRE_LES_IMAGES_INEXISTANTES)));
/* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien s'il faut */
/* attendre qu'elles aient ete calculees ('VRAI'). */
#define F_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_ACCES_ALBUM \
NE_PAS_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_UN_ALBUM
DEFV(Local,DEFV(Logical,INIT(F_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,F_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_ACCES_ALBUM
)
)
);
/* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien s'il faut */
/* accepter leur inexistence ('VRAI') ; cela permet d'avoir moins d'images dans un album */
/* que necessaire vis a vis de la definition de {Zmin,Zmax}. */
#define F_PERIODISER_X \
FAUX
#define F_PERIODISER_Y \
FAUX
#define F_PERIODISER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(F_periodiser_X,F_PERIODISER_X)));
DEFV(Local,DEFV(Logical,INIT(F_periodiser_Y,F_PERIODISER_Y)));
DEFV(Local,DEFV(Logical,INIT(F_periodiser_Z,F_PERIODISER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] est periodique ('VRAI') ou pas */
/* ('FAUX'). */
#define F_SYMETRISER_X \
FAUX
#define F_SYMETRISER_Y \
FAUX
#define F_SYMETRISER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(F_symetriser_X,F_SYMETRISER_X)));
DEFV(Local,DEFV(Logical,INIT(F_symetriser_Y,F_SYMETRISER_Y)));
DEFV(Local,DEFV(Logical,INIT(F_symetriser_Z,F_SYMETRISER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] est symetrique ('VRAI') ou pas */
/* ('FAUX'). Ceci a ete introduit le 20050721095823... */
#define F_PROLONGER_X \
FAUX
#define F_PROLONGER_Y \
FAUX
#define F_PROLONGER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(F_prolonger_X,F_PROLONGER_X)));
DEFV(Local,DEFV(Logical,INIT(F_prolonger_Y,F_PROLONGER_Y)));
DEFV(Local,DEFV(Logical,INIT(F_prolonger_Z,F_PROLONGER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] doit etre prolonge a l'exterieur */
/* comme il est au bord ('VRAI') ou pas ('FAUX'). */
#define F_NIVEAU_HORS_DU_CHAMP_DE_FORCE \
NIVEAU_HORS_ECRAN
DEFV(Local,DEFV(genere_p,INIT(F_niveau_hors_du_champ_de_force,F_NIVEAU_HORS_DU_CHAMP_DE_FORCE)));
/* Valeur a forcer a l'exterieur du champ de force, lorsqu'il ne faut ni periodiser, ni */
/* prolonger... */
#define F_NIVEAU_INITIAL_DU_CHAMP_DE_FORCE \
BLANC
DEFV(Local,DEFV(genere_p,INIT(F_niveau_initial_du_champ_de_force,F_NIVEAU_INITIAL_DU_CHAMP_DE_FORCE)));
/* Valeur pour initialiser eventuellement le champ de force dans 'ACCES_ALBUM(...)'. */
#define F_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM \
NE_PAS_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM
DEFV(Local,DEFV(Logical,INIT(F_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM,F_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM)));
/* Indique si l'ordre des coupes doit etre inverses ('VRAI') ou pas ('FAUX') dans la */
/* procedure 'ACCES_ALBUM(...)' pour le champ de Force. */
#define PRENDRE_LA_PREMIERE_DIRECTION_TROUVEE \
VRAI
DEFV(Local,DEFV(Logical,INIT(prendre_la_premiere_direction_trouvee,PRENDRE_LA_PREMIERE_DIRECTION_TROUVEE)));
/* Si cet indicateur est 'VRAI', des que l'on a trouve une direction perturbee qui colle */
/* au mieux avec le gradient, on la garde. S'il est 'FAUX', un tirage au sort determine */
/* si on la conserve ou si on continue a chercher... */
#define NOMBRE_D_ITERATIONS_SI_ON_NE_PREND_PAS_LA_PREMIERE_DIRECTION_TROUVEE \
UN
DEFV(Local,DEFV(Positive,INIT(nombre_d_iterations_si_on_ne_prend_pas_la_premiere_direction_trouvee
,NOMBRE_D_ITERATIONS_SI_ON_NE_PREND_PAS_LA_PREMIERE_DIRECTION_TROUVEE
)
)
);
/* Nombre de "selecteur"s a generer lorsque l'on ne prend pas la premiere direction trouvee. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U M I L I E U D E P R O P A G A T I O N : */
/* */
/*************************************************************************************************************************************/
#define UTILISER_UN_MILIEU_DE_PROPAGATION \
FAUX
DEFV(Local,DEFV(Logical,INIT(utiliser_un_milieu_de_propagation,UTILISER_UN_MILIEU_DE_PROPAGATION)));
/* Indique si la propagation a lieu dans un milieu "optique" ('VRAI') ou pas ('FAUX') ; on */
/* appel "milieu optique" un milieu ou vont avoir lieu des phenomenes de reflexion et de */
/* refraction. */
/* */
/* En toute generalite c'est l'etude de la propagation dans le milieu qui est la plus */
/* gourmande en temps de calcul ; cela est du aux calculs des gradients tridimensionnels, */
/* la duree de chacun d'eux etant proportionnel au cube du rayon des particules... */
#define UTILISER_UN_MILIEU_DE_PROPAGATION_DYNAMIQUE \
FAUX
DEFV(Local,DEFV(Logical,INIT(utiliser_un_milieu_de_propagation_dynamique,UTILISER_UN_MILIEU_DE_PROPAGATION_DYNAMIQUE)));
/* Si 'IL_FAUT(utiliser_un_milieu_de_propagation)', indique si ce milieu evolue au cours */
/* du temps ('VRAI') ou pas ('FAUX'). */
/* */
/* ATTENTION : cette facilite introduite le 20010228095632 est relativement simpliste. En */
/* particulier, si le milieu voit, par exemple, son "volume" diminuer, les particules qui */
/* se trouvent alors "hors-volume" continuent a etre traitees comme si de rien n'etait... */
#define TESTER_LES_DETAILS_FINS \
FAUX
DEFV(Local,DEFV(Logical,INIT(tester_les_details_fins,TESTER_LES_DETAILS_FINS)));
/* Permet d'inhiber le test des details fins qui peut generer des fichiers d'erreurs */
/* gigantesques ce qui s'est vu lors de la generation des sequences du type : */
/* */
/* xivPdf 11 2 / 034580_035091 */
/* */
/* le 19981021101413. */
/* */
/* Le 20150207093428, la valeur par defaut est passee de 'VRAI' a 'FAUX' lors de tests */
/* de reproductibilite de 'v $xiak/REFL.91$R16'... */
#define IL_PEUT_Y_AVOIR_REFLEXION \
VRAI
DEFV(Local,DEFV(Logical,INIT(il_peut_y_avoir_reflexion,IL_PEUT_Y_AVOIR_REFLEXION)));
/* Indique si la reflexion est possible ('VRAI') ou pas ('FAUX'). */
#define IL_PEUT_Y_AVOIR_REFRACTION \
VRAI
DEFV(Local,DEFV(Logical,INIT(il_peut_y_avoir_refraction,IL_PEUT_Y_AVOIR_REFRACTION)));
/* Indique si la refraction est possible ('VRAI') ou pas ('FAUX'). */
#define ANGLE_INFERIEUR_DU_CONE_DE_REFLEXION \
GRO1(PI_SUR_2)
#define ANGLE_SUPERIEUR_DU_CONE_DE_REFLEXION \
GRO3(PI_SUR_2)
DEFV(Local,DEFV(Float,INIT(angle_inferieur_du_cone_de_reflexion,ANGLE_INFERIEUR_DU_CONE_DE_REFLEXION)));
DEFV(Local,DEFV(Float,INIT(angle_superieur_du_cone_de_reflexion,ANGLE_SUPERIEUR_DU_CONE_DE_REFLEXION)));
/* Definition du cone a l'interieur duquel il y a reflexion... */
#define MODULER_LA_VITESSE_LORS_D_UNE_REFRACTION \
FAUX
DEFV(Local,DEFV(Logical,INIT(moduler_la_vitesse_lors_d_une_refraction,MODULER_LA_VITESSE_LORS_D_UNE_REFRACTION)));
/* Indique lorsque 'EST_VRAI(il_peut_y_avoir_refraction)' si la vitesse des particules */
/* doit etre modulee par l'indice de refraction comme le veulent les lois de l'optique */
/* ('VRAI') ou pas ('FAUX'), ce qui permet alors d'eviter des pseudo-immobilisations */
/* lorsque les rapports d'indice sont trop eleves... */
#define FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION \
FU
#define TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION \
FZERO
DEFV(Local,DEFV(Float,INIT(facteur_vitesse_OX2_refraction_reflexion,FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION)));
DEFV(Local,DEFV(Float,INIT(translation_vitesse_OX2_refraction_reflexion,TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION)));
dfTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION
,fichier_LISTE_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION
,FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION_IMPLICITE
,FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION
)
dfTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
,fichier_LISTE_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
,TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION_IMPLICITE
,TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
)
#define ACCES_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION(corps) \
IdTb1(liste_initiale_des_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION(corps) \
IdTb1(liste_initiale_des_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Facteurs multiplicatif et additif relatifs a la composante 'OX2' d'une vitesse apres une */
/* reflexion ou une refraction. Cette composante est aussi appelee "normale" car elle est */
/* alignee avec le Gradient, c'est-a-dire donc orthogonale au plan de reflexion/refraction. */
/* Ils vont permettre de simuler des echanges d'energie avec le milieu. Ceci a ete introduit */
/* le 19980909093853. */
#define FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION \
FU
#define TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION \
FZERO
DEFV(Local,DEFV(Float,INIT(facteur_vitesse_OZ2_refraction_reflexion,FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION)));
DEFV(Local,DEFV(Float,INIT(translation_vitesse_OZ2_refraction_reflexion,TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION)));
dfTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION
,fichier_LISTE_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION
,FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION_IMPLICITE
,FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION
)
dfTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
,fichier_LISTE_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
,TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION_IMPLICITE
,TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
)
#define ACCES_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION(corps) \
IdTb1(liste_initiale_des_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION(corps) \
IdTb1(liste_initiale_des_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Facteurs multiplicatif et additif relatifs a la composante 'OZ2' d'une vitesse apres une */
/* reflexion ou une refraction. Cette composante est aussi appelee "tangentielle" car elle */
/* est dans le plan de reflexion/refraction. */
/* Ils vont permettre de simuler des echanges d'energie avec le milieu. Ceci a ete introduit */
/* le 19980909093853. */
#define CALCULER_LA_MOYENNE_DES_Mgradient_3x3x3_tri_dimensionnel \
VRAI
DEFV(Local,DEFV(Logical,INIT(calculer_la_moyenne_des_Mgradient_3x3x3_tri_dimensionnel
,CALCULER_LA_MOYENNE_DES_Mgradient_3x3x3_tri_dimensionnel
)
)
);
/* Indique si l'on doit calculer la moyenne des gradients 3x3x3 ('VRAI') ou bien la moyenne */
/* des {Rho,Phi,Theta} des gradients 3x3x3, puis reconstituer a partir de la un gradient */
/* moyen ('FAUX'). Cette option a ete introduite le 20010326161323 apres experiences faites */
/* grace a 'v $xiii/di_image$FON IFgradient_simplifie_____evaluer_le_gradient_local_moyen' */
/* via 'v $xci/gradient.02$K'. Le comportement anterieur a cette date correspond a la */
/* valeur 'VRAI' de cette options. ATTENTION : cette methode a un gros defaut. */
/* En effet, les petites imprecisions sur {Phi,Theta} peuvent provoquer des anomalies ; par */
/* exemple, dans une simulation bidimensionnelle a 'Z' constant, les particules peuvent */
/* ainsi s'echapper de leur plan 'Z' de depart. Ce probleme est evidemment cause par les */
/* passages des coordonnees cartesiennes aux coordonnees spheriques, puis retour (cela peut */
/* etre vu grace au programme 'v $xtKi/CartSph3D.01$K'). Ce probleme est corrigeable */
/* approximativement via 'seuil_de_Mgradient_local_tri_dimensionnel_?' ci-apres. */
/* */
/* On notera au passage qu'un plan de coordonnee 'Z' constante a un 'Theta' egal a pi/2. */
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF \
FZERO
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_ACTIF \
tgEPSILON
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_X \
SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_Y \
SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_Z \
SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF
/* ATTENTION, les valeurs par defaut {FZERO,FZERO,tgEPSILON} correspondent a une utilisation */
/* bidimensionnelle {OX,OY} du programme... */
DEFV(Local,DEFV(Float,INIT(seuil_de_Mgradient_local_tri_dimensionnel_X,SEUIL_DE_Mgradient_local_tri_dimensionnel_X)));
DEFV(Local,DEFV(Float,INIT(seuil_de_Mgradient_local_tri_dimensionnel_Y,SEUIL_DE_Mgradient_local_tri_dimensionnel_Y)));
DEFV(Local,DEFV(Float,INIT(seuil_de_Mgradient_local_tri_dimensionnel_Z,SEUIL_DE_Mgradient_local_tri_dimensionnel_Z)));
/* Si 'IL_NE_FAUT_PAS(calculer_la_moyenne_des_Mgradient_3x3x3_tri_dimensionnel)', donne le */
/* seuil en deca duquel les composantes du gradient calcule a partir des valeurs moyennes */
/* de {Rho,Phi,Theta} sont annulees car considerees comme trop petites. On notera qu'une */
/* valeur nulle retablit ces defauts (introduit le 20010328100529). */
#define ARRONDIR_PAR_DEFAUT_LES_COORDONNEES_DU_M_GRADIENT \
VRAI
DEFV(Local,DEFV(Logical,INIT(arrondir_par_defaut_les_coordonnees_du_M_gradient,ARRONDIR_PAR_DEFAUT_LES_COORDONNEES_DU_M_GRADIENT)));
/* Indique si l'arrondi dans le calcul des coordonnees {X,Y,Z} est par defaut ('VRAI') ou */
/* a la plus proche valeur entiere ('FAUX'). */
#define AFFINER_LE_MAILLAGE_DE_CALCUL_DU_M_GRADIENT \
FAUX
DEFV(Local,DEFV(Logical,INIT(affiner_le_maillage_de_calcul_du_M_gradient,AFFINER_LE_MAILLAGE_DE_CALCUL_DU_M_GRADIENT)));
/* Indique si le maillage de calcul du 'M-Gradient' doit etre affine ('VRAI') ou pas */
/* ('FAUX'). En effet, le milieu de propagation peut contenir des "details" trop fins */
/* par rapport au deplacement d'une particule pendant le temps 'dct'. Cela se voit, par */
/* exemple, dans la sequence : */
/* */
/* xivPdf 11 1 / 023323_023834 */
/* */
/* sur l'image '023508' ou une particule (blanchatre) rencontre la pointe qui "rentre" */
/* dans l'ensemble de Mandelbrot sur la portie positive de l'axe Reel. */
#define CALCULER_UN_M_GRADIENT_TRIDIMENSIONNEL_SIMPLIFIE \
FAUX
DEFV(Local,DEFV(Logical,INIT(calculer_un_M_gradient_tridimensionnel_simplifie,CALCULER_UN_M_GRADIENT_TRIDIMENSIONNEL_SIMPLIFIE)));
/* Indique lorsque 'IL_NE_FAUT_PAS(affiner_le_maillage_de_calcul_du_M_gradient)' si le */
/* calcul du 'M-Gradient' est simplifie, c'est-a-dire 3 fois monodimensionnel ('VRAI') */
/* ou reellement tridimensionnel ('FAUX'). */
/* */
/* Lorsque 'IL_FAUT(calculer_un_M_gradient_tridimensionnel_simplifie)', le gradient */
/* obtenu est tres approximatif et son "inclinaison" est tres quantifiee ; par exemple, */
/* en mode bidimensionnel, il a tendance a s'aligner parallelement aux axes de coordonnees */
/* lorsque le milieu de propagation est homogene et surtout binaire. C'est ce phenomene */
/* qui explique par exemple le collage d'une particule sur l'image '024416' de la sequence : */
/* */
/* xivPdf 11 1 / 024347_024858 */
/* */
/* Cette particule est celle qui est pratiquement le plus haut sur l'image. Pour elle le */
/* gradient fut tres certainement calcule horizontal, alors que sa vitesse incidente etait */
/* pratiquement verticale, mais faisant un angle inferieur a pi/2 avec ce gradient. Dans */
/* ces conditions, on decrete qu'il y a refraction, d'ou le collage apparent (en fait, de */
/* par le rapport enorme des indices de refraction, la vitesse est considerablement reduite */
/* d'ou cet effet de pseudo-immobilisation). */
/* */
/* Le 19971222111857, 'CALCULER_UN_M_GRADIENT_TRIDIMENSIONNEL_SIMPLIFIE' est passe de la */
/* valeur 'VRAI' a la valeur 'FAUX'. */
/* */
/* On notera que la conjonction de 'IL_FAUT(adapter_les_M_nPAS)' et de */
/* 'IL_NE_FAUT_PAS(calculer_un_M_gradient_tridimensionnel_simplifie)' permet de lutter */
/* contre un phenomene "classique" qui consiste apres une REFLEXION a faire une REFRACTION */
/* qui peut etre consideree comme l'inverse ; en effet, on voit le gradient oppose de celui */
/* de la REFLEXION. La solution est donc d'adapter les pas... */
#define M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_FILTRER \
VRAI
DEFV(Local,DEFV(Logical,INIT(M_gradient_tridimensionnel_non_simplifie_filtrer
,M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_FILTRER
)
)
);
/* La valeur implicite est passee de 'FAUX' a 'VRAI' le 19980302151517. */
#define M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_TOLERANCE \
GRO3(FRA4(______________BLANC_NORMALISE))
DEFV(Local,DEFV(Float,INIT(M_gradient_tridimensionnel_non_simplifie_tolerance
,FLOT__NIVEAU_UNDEF
)
)
);
/* Indique lorsque 'IL_NE_FAUT_PAS(calculer_un_M_gradient_tridimensionnel_simplifie)' si le */
/* calcul du gradient filtre les niveaux en excluant ceux qui sont trop eloignes de la */
/* moyenne ('VRAI') ou en les prenant tous ('FAUX'). La tolerance est alors utilisee pour */
/* definir l'intervalle des niveaux dans [0,1] autorises a participer au calcul du gradient. */
/* */
/* ATTENTION, le 19980914135745, en preparant la sequence : */
/* */
/* xivPdf 11 2 / 029972_030483 */
/* */
/* j'ai pu constater que cela pouvait etre tres ennuyeux, meme sur des images "milieu" ne */
/* contenant que du 'NOIR' et du 'BLANC'. En effet, imaginons qu'il n'y ait, par exemple, */
/* qu'un seul point 'NOIR' ; le niveau moyen est alors tres proche de 'BLANC' et si le */
/* facteur de tolerance est inferieur a 1, le seul point 'NOIR' sera ignore lors du calcul */
/* du gradient, et celui-ci sera donc de module nul... */
/* */
/* Cela s'est reproduit le 20010320163540 avec les sequences : */
/* */
/* xivPdf 10 2 / 031117_031628 */
/* */
/* et : */
/* */
/* xivPdf 10 2 / 031629_032140 */
/* */
/* pour des points consideres comme isoles et etant en fait des coins "sortants" des */
/* bords du billiard de Sierpinski (ces points figurent a des sommets des carres/cubes a */
/* l'interieur desquels le gradient est calcule). */
/* */
/* En resume, si cette valeur est egale a 1, aucun point (meme "isole") ne sera ignore ; */
/* pour une valeur inferieure a 1, des points "isoles" pourront etre ignores, et donc */
/* provoquer de faux gradients nuls. Voir donc a ce sujet l'option "Mtolerance=". */
/* */
/* Le 20091023085850, 'M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_TOLERANCE' fut remplace par */
/* 'FLOT__NIVEAU_UNDEF' a cause de l'usage de '______________BLANC_NORMALISE' */
/* et donc par 'v $xiiD/definit.2$DEF ______NORMALISE_NIVEAU' qui lui-meme utilise */
/* 'v $xiiD/definit.2$DEF AXE_NIVEAUX_OUVERT_FERME'. Alors 'NIVEAU_DU_CHAMP_NOIR_et_BLANC' */
/* ne peut etre dans un 'DEFV(Local,DEFV(genere_Float,INIT(...)))' puisqu'il teste une */
/* variable... */
#define M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_SPHERIQUE \
VRAI
DEFV(Local,DEFV(Logical,INIT(M_gradient_tridimensionnel_non_simplifie_spherique
,M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_SPHERIQUE
)
)
);
/* Indique lorsque 'IL_NE_FAUT_PAS(calculer_un_M_gradient_tridimensionnel_simplifie)' si le */
/* calcul du gradient se fait dans une fenetre circulaire ('VRAI') ou carree ('FAUX'). */
/* La valeur implicite est passee de 'FAUX' a 'VRAI' le 19980302151517. */
#define PONDERER_UN_M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE \
FAUX
DEFV(Local,DEFV(Logical,INIT(ponderer_un_M_gradient_tridimensionnel_non_simplifie
,PONDERER_UN_M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE
)
)
);
/* Indique lorsque 'IL_NE_FAUT_PAS(calculer_un_M_gradient_tridimensionnel_simplifie)' si le */
/* calcul du gradient doit etre une somme ponderee ('VRAI') ou pas ('FAUX') des gradients */
/* elementaires. */
#define M_nPASX \
FQUATRE
#define M_nPASY \
FQUATRE
#define M_nPASZ \
FU
DEFV(Local,DEFV(Float,INIT(fM_NpasX,M_nPASX)));
DEFV(Local,DEFV(Float,INIT(fM_NpasY,M_nPASY)));
DEFV(Local,DEFV(Float,INIT(fM_NpasZ,M_nPASZ)));
/* Indique les demi-dimensions (en nombre de points) des volumes elementaires du milieu */
/* de propagation dans lequel on calcule le gradient. */
/* */
/* Le 19990406122809, {fM_NpasX,fM_NpasY,fM_NpasZ} sont passes de 'Int' a 'Float' afin de */
/* donner "un peu plus de souplesse" dans la definition du volume a l'interieur duquel */
/* calculer le gradient... */
#define ADAPTER_LES_M_nPAS \
VRAI
DEFV(Local,DEFV(Logical,INIT(adapter_les_M_nPAS,ADAPTER_LES_M_nPAS)));
/* Indique si les 'M_Npas?' doivent etre adaptes automatiquement en fonction du mouvement */
/* de chaque particule ('VRAI') ou bien utilises tel quels ('FAUX'). */
/* */
/* Le 19971222111857, 'ADAPTER_LES_M_nPAS' est passe de la valeur 'FAUX' a la valeur 'VRAI'. */
/* */
/* On notera que la conjonction de 'IL_FAUT(adapter_les_M_nPAS)' et de */
/* 'IL_NE_FAUT_PAS(calculer_un_M_gradient_tridimensionnel_simplifie)' permet de lutter */
/* contre un phenomene "classique" qui consiste apres une REFLEXION a faire une REFRACTION */
/* qui peut etre consideree comme l'inverse ; en effet, on voit le gradient oppose de celui */
/* de la REFLEXION. La solution est donc d'adapter les pas... */
#define PRENDRE_EN_COMPTE_M_L_ENCOMBREMENT_DES_PARTICULES \
VRAI
DEFV(Local,DEFV(Logical,INIT(prendre_en_compte_M_l_encombrement_des_particules,PRENDRE_EN_COMPTE_M_L_ENCOMBREMENT_DES_PARTICULES)));
/* Indique si 'IL_FAUT(adapter_les_M_nPAS)' si le rayon des particules doit etre pris en */
/* compte pour calculer le gradient. Cela permet de ne plus considerer les particules */
/* comme ponctuelles lors de leur interaction avec le Milieu (introduit le 19991224132633). */
/* On notera que la 'FAUX' redonne le fonctionnement anterieur au 19991224132633... */
#define EDITER_LES_MESSAGES_D_ERREUR_DU_CALCUL_DU_GRADIENT \
FAUX
DEFV(Local,DEFV(Logical,INIT(editer_les_messages_d_erreur_du_calcul_du_gradient,EDITER_LES_MESSAGES_D_ERREUR_DU_CALCUL_DU_GRADIENT)));
/* Indique si il faut editer les volumineux messages d'erreur possibles lors du calcul du */
/* gradient (introduit le 20150208081236). */
DEFV(Local,DEFV(Int,INIT(M_premiere_coupe,PREMIERE_IMAGE)));
/* Numero de la premiere coupe du milieu de propagation. */
DEFV(Local,DEFV(Int,INIT(M_pas_des_coupes,PAS_DES_IMAGES)));
/* Pas de passage d'un numero de coupe a une autre. */
DEFV(Local,DEFV(Int,INIT(M_nombre_de_chiffres_pour_le_milieu,NOMBRE_DE_CHIFFRES)));
/* Nombre de chiffres codant le numero des coupes de la serie... */
DEFV(Local,DEFV(Int,INIT(M_nombre_de_chiffres_pour_le_milieu_dynamique,NOMBRE_DE_CHIFFRES)));
/* Si 'IL_FAUT(utiliser_un_milieu_de_propagation_dynamique)', donne le nombre de chiffres */
/* codant le numero de periode... */
#define M_ATTENDRE_LES_IMAGES_INEXISTANTES \
VRAI
DEFV(Local,DEFV(Logical,INIT(M_attendre_les_images_inexistantes,M_ATTENDRE_LES_IMAGES_INEXISTANTES)));
/* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien s'il faut */
/* attendre qu'elles aient ete calculees ('VRAI'). */
#define M_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_ACCES_ALBUM \
NE_PAS_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_UN_ALBUM
DEFV(Local,DEFV(Logical,INIT(M_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,M_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_ACCES_ALBUM
)
)
);
/* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien s'il faut */
/* accepter leur inexistence ('VRAI') ; cela permet d'avoir moins d'images dans un album */
/* que necessaire vis a vis de la definition de {Zmin,Zmax}. */
#define M_PERIODISER_X \
FAUX
#define M_PERIODISER_Y \
FAUX
#define M_PERIODISER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(M_periodiser_X,M_PERIODISER_X)));
DEFV(Local,DEFV(Logical,INIT(M_periodiser_Y,M_PERIODISER_Y)));
DEFV(Local,DEFV(Logical,INIT(M_periodiser_Z,M_PERIODISER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] est periodique ('VRAI') ou pas */
/* ('FAUX'). */
#define M_SYMETRISER_X \
FAUX
#define M_SYMETRISER_Y \
FAUX
#define M_SYMETRISER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(M_symetriser_X,M_SYMETRISER_X)));
DEFV(Local,DEFV(Logical,INIT(M_symetriser_Y,M_SYMETRISER_Y)));
DEFV(Local,DEFV(Logical,INIT(M_symetriser_Z,M_SYMETRISER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] est symetrique ('VRAI') ou pas */
/* ('FAUX'). Ceci a ete introduit le 20050721095823... */
#define M_PROLONGER_X \
FAUX
#define M_PROLONGER_Y \
FAUX
#define M_PROLONGER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(M_prolonger_X,M_PROLONGER_X)));
DEFV(Local,DEFV(Logical,INIT(M_prolonger_Y,M_PROLONGER_Y)));
DEFV(Local,DEFV(Logical,INIT(M_prolonger_Z,M_PROLONGER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] doit etre prolonge a l'exterieur */
/* comme il est au bord ('VRAI') ou pas ('FAUX'). */
/* ATTENTION, le 20010206095440, lors de la generation de la sequence : */
/* */
/* xivPdf 10 2 / 026509_027020 */
/* */
/* j'ai pris conscience du fait que les valeurs 'M_NIVEAU_HORS_DU_MILIEU_DE_PROPAGATION' et */
/* 'M_NIVEAU_INITIAL_DU_MILIEU_DE_PROPAGATION' etaient "inversees". J'ai donc retabli a */
/* cette date les bonnes valeurs ; il est en effet plus logique d'avoir 'BLANC' a */
/* l'interieur et 'NOIR' a l'exterieur, ce qui permet de faire de la reflexion a l'interieur */
/* du milieu, lorsque des particules vont du centre vers l'exterieur, par exemple... */
/* */
/* Donc, en general, on aura : */
/* */
/* exterieur = NOIR */
/* interieur = BLANC */
/* */
#define M_NIVEAU_HORS_DU_MILIEU_DE_PROPAGATION \
NOIR
DEFV(Local,DEFV(genere_p,INIT(M_niveau_hors_du_milieu_de_propagation,M_NIVEAU_HORS_DU_MILIEU_DE_PROPAGATION)));
/* Valeur a forcer a l'exterieur du milieu de propagation, lorsqu'il ne faut ni periodiser, */
/* ni prolonger... */
#define M_NIVEAU_INITIAL_DU_MILIEU_DE_PROPAGATION \
BLANC
DEFV(Local,DEFV(genere_p,INIT(M_niveau_initial_du_milieu_de_propagation,M_NIVEAU_INITIAL_DU_MILIEU_DE_PROPAGATION)));
/* Valeur pour initialiser eventuellement le milieu de propagation dans 'ACCES_ALBUM(...)'. */
/* ATTENTION, le 20010206095440, lors de la generation de la sequence : */
/* */
/* xivPdf 10 2 / 026509_027020 */
/* */
/* j'ai pris conscience du fait que les valeurs 'M_NIVEAU_HORS_DU_MILIEU_DE_PROPAGATION' et */
/* 'M_NIVEAU_INITIAL_DU_MILIEU_DE_PROPAGATION' etaient "inversees". J'ai donc retabli a */
/* cette date les bonnes valeurs ; il est en effet plus logique d'avoir 'BLANC' a */
/* l'interieur et 'NOIR' a l'exterieur, ce qui permet de faire de la reflexion a l'interieur */
/* du milieu, lorsque des particules vont du centre vers l'exterieur, par exemple... */
/* */
/* Donc, en general, on aura : */
/* */
/* exterieur = NOIR */
/* interieur = BLANC */
/* */
#define M_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM \
NE_PAS_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM
DEFV(Local,DEFV(Logical,INIT(M_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM,M_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM)));
/* Indique si l'ordre des coupes doit etre inverses ('VRAI') ou pas ('FAUX') dans la */
/* procedure 'ACCES_ALBUM(...)' pour le Milieu. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E N T E R D E S O R T I R L A " G E O M E T R I E " D U M I L I E U D E P R O P A G A T I O N : */
/* */
/*************************************************************************************************************************************/
#define GENERER_LA_GEOMETRIE_DU_MILIEU_DE_PROPAGATION \
FAUX
DEFV(Local,DEFV(Logical,INIT(generer_la_geometrie_du_milieu_de_propagation,GENERER_LA_GEOMETRIE_DU_MILIEU_DE_PROPAGATION)));
/* Indique si l'on doit generer une image donnant une bonne idee de la geometrie du milieu */
/* de propagation via le 'Z Buffer accumule'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C H O C S E N T R E P A R T I C U L E S : */
/* */
/*************************************************************************************************************************************/
#define DETECTER_LES_COLLISIONS_VERSION_N_AU_CARRE \
VRAI
DEFV(Local,DEFV(Logical,INIT(detecter_les_collisions_VERSION_N_AU_CARRE,DETECTER_LES_COLLISIONS_VERSION_N_AU_CARRE)));
/* Indique si la methode de detection des collisions sera en 'N*N' ('VRAI') ou bien en */
/* 'N*Log(N)' ('FAUX'). Cette optimisation possible a ete introduite le 20010920103622. */
/* */
/* ATTENTION : les deux methodes ne donnent pas les memes resultats car, en effet, les */
/* collisions entre particules modifient leurs vitesses. Or une particule P, a un instant */
/* donne peut subir plusieurs collisions ; ainsi donc, l'ordre dans lequel ces differentes */
/* collisions sont traitees joue un role important dans la vitesse finalement attribuee */
/* a la particule P, a cet instant precis. Or ces deux methodes ne traitent evidemment pas */
/* les points dans le meme ordre, d'ou les differences. Ceci peut etre demontre de la */
/* facon suivante ('v $xrk/rdn_walk.41$I gVITESSE_CORPS_APRES_COLLISION') : supposons pour */
/* simplifier (mais c'est le cas de la sequence 'xivPdf 14 1 / 005121_005632' sur laquelle */
/* a ete teste cette methode) que l'on a : */
/* */
/* Mi = 1 \-/ i (toutes les particules ont la meme masse), */
/* k=1 (chocs parfaitement elastiques). */
/* */
/* Interessons nous a la composante "normale" des vitesses (qui est portee par la ligne */
/* des centres de deux particules en collision). Soit A une particule subissant des chocs */
/* avec deux particules B1 et B2. */
/* */
/* La formule 'v $xrk/rdn_walk.41$I gVITESSE_CORPS_APRES_COLLISION' montre qu'alors les */
/* composantes "normales" sont echangees. Supposons, la encore pour simplifier, que les */
/* deux particules B1 et B2 sont superposees (ce n'est pas tres physique, mais peu importe, */
/* c'est pour simplifier la demonstration). Deux cas vont donc se rencontrer dans l'ordre */
/* des collisions en etudiant l'evolution de la vitesse des trois particules au cours du */
/* calcul des chocs ('V0(...)' designe la vitesse d'une particule avant l'etude des chocs) : */
/* */
/* 1-choc {A,B1}, puis choc {A,B2} : */
/* */
/* vitesse(A) : V0(A) ----Pe---> V0(B1) ----Pe---> V0(B2) */
/* vitesse(B1) : V0(B1) ----Pe---> V0(A) V0(A) */
/* vitesse(B2) : V0(B2) V0(B2) ----Pe---> V0(B1) */
/* */
/* 2-choc {A,B2}, puis choc {A,B1} : */
/* */
/* vitesse(A) : V0(A) ----Pe---> V0(B2) ----Pe---> V0(B1) */
/* vitesse(B1) : V0(B1) V0(B1) ----Pe---> V0(B2) */
/* vitesse(B2) : V0(B2) ----Pe---> V0(A) V0(A) */
/* */
/* ('----Pe--->' designe la permutation de deux vitesses). ^ */
/* | */
/* | */
/* On voit ainsi que l'etat final n'est pas le meme dans les deux cas ------------ */
/* */
/* L'operation 'gVITESSE_CORPS_APRES_COLLISION' n'est donc pas commutative... */
#define UNE_COLLISION_NECESSITE_DEUX_CORPS_COLLISIONNABLES \
VRAI
DEFV(Local,DEFV(Logical,INIT(une_collision_necessite_deux_corps_collisionnables
,UNE_COLLISION_NECESSITE_DEUX_CORPS_COLLISIONNABLES
)
)
);
/* Indique si pour qu'il y ait collision il faut que les deux corps en cause soient */
/* "collisionnables" ('VRAI') ou bien si un seul suffit ('FAUX'). */
dfTRANSFORMAT_31(liste_initiale_des_COLLISIONNABLE,fichier_LISTE_COLLISIONNABLE,COLLISIONNABLE_IMPLICITE,VRAI)
#define gACCES_COLLISIONNABLES(corps) \
IdTb1(liste_initiale_des_COLLISIONNABLE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_COLLISIONNABLES(corps) \
LOGI(gACCES_COLLISIONNABLES(corps))
/* Definition des fichiers de la liste des collisionnables (introduit le 20000719091407). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S I N T E R A C T I O N S E N T R E P A R T I C U L E S : */
/* */
/*************************************************************************************************************************************/
#define FACTEUR_DES_RAYON_D_INTERACTION \
FU
DEFV(Local,DEFV(Float,INIT(facteur_des_rayon_d_interaction,FACTEUR_DES_RAYON_D_INTERACTION)));
/* Permet de moduler la somme des rayons d'interaction entre deux particules. La logique */
/* voudrait evidemment que ce facteur vaille 1. Mais a cause du rendu des particules sous */
/* la forme de spheres estompees, leur contour apparent semble beaucoup plus reduit qu'il */
/* n'est en realite ; cela s'est vu en utilisant la palette '$xiP/masque' sur les images */
/* '0005' et '0006' lors de la generation de la sequence : */
/* */
/* xivPdf 11 2 / 003073_003584 */
/* */
/* lorsque les deux particules en haut et a gauche interagissent... */
/* */
/* Le 20000629101913, j'ai restaure la bonne valeur par defaut ('FU'), alors qu'avant */
/* cette date, il y avait 'FDU'... */
#define SEUIL_D_INTERACTION \
FZERO
DEFV(Local,DEFV(Float,INIT(seuil_d_interaction,SEUIL_D_INTERACTION)));
/* Indique la distance en deca de laquelle deux particules vont interagir. On notera qu'une */
/* valeur nulle inhibe a priori ce mecanisme (voir l'utilisation d'un 'IFLT(...)'). Ainsi, */
/* on espere pouvoir construire des 'DLA' (ou 'Diffusion Limited Aggregation'). Une valeur */
/* de 0.025 permet de bien simuler les collisions... */
#define GENERER_DES_DiffusionLimitedAggregation \
FAUX
DEFV(Local,DEFV(Logical,INIT(generer_des_DiffusionLimitedAggregation,GENERER_DES_DiffusionLimitedAggregation)));
/* Indique s'il faut generer des 'DLA' ('VRAI') ou pas ('FAUX')... */
#include xrk/rdn_walk.41.I"
/* Gestion des collisions... */
#define FACTEUR_VITESSE_OX2_COLLISION \
FU
#define TRANSLATION_VITESSE_OX2_COLLISION \
FZERO
dfTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OX2_COLLISION
,fichier_LISTE_FACTEUR_VITESSE_OX2_COLLISION
,FACTEUR_VITESSE_OX2_COLLISION_IMPLICITE
,FACTEUR_VITESSE_OX2_COLLISION
)
dfTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OX2_COLLISION
,fichier_LISTE_TRANSLATION_VITESSE_OX2_COLLISION
,TRANSLATION_VITESSE_OX2_COLLISION_IMPLICITE
,TRANSLATION_VITESSE_OX2_COLLISION
)
#define ACCES_FACTEUR_VITESSE_OX2_COLLISION(corps) \
IdTb1(liste_initiale_des_FACTEUR_VITESSE_OX2_COLLISION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_TRANSLATION_VITESSE_OX2_COLLISION(corps) \
IdTb1(liste_initiale_des_TRANSLATION_VITESSE_OX2_COLLISION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Facteurs multiplicatif et additif relatifs a la composante 'OX2' d'une vitesse apres une */
/* collision (ceci a ete ajoute le 19991110082506 dans le but de permettre de garder le plus */
/* longtemps possible la "cohesion" d'un ensemble de particules -tel un "piston"-). */
#define FACTEUR_VITESSE_OY2_COLLISION \
FU
#define TRANSLATION_VITESSE_OY2_COLLISION \
FZERO
dfTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OY2_COLLISION
,fichier_LISTE_FACTEUR_VITESSE_OY2_COLLISION
,FACTEUR_VITESSE_OY2_COLLISION_IMPLICITE
,FACTEUR_VITESSE_OY2_COLLISION
)
dfTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OY2_COLLISION
,fichier_LISTE_TRANSLATION_VITESSE_OY2_COLLISION
,TRANSLATION_VITESSE_OY2_COLLISION_IMPLICITE
,TRANSLATION_VITESSE_OY2_COLLISION
)
#define ACCES_FACTEUR_VITESSE_OY2_COLLISION(corps) \
IdTb1(liste_initiale_des_FACTEUR_VITESSE_OY2_COLLISION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_TRANSLATION_VITESSE_OY2_COLLISION(corps) \
IdTb1(liste_initiale_des_TRANSLATION_VITESSE_OY2_COLLISION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Facteurs multiplicatif et additif relatifs a la composante 'OY2' d'une vitesse apres une */
/* collision (ceci a ete ajoute le 19991110082506 dans le but de permettre de garder le plus */
/* longtemps possible la "cohesion" d'un ensemble de particules -tel un "piston"-). */
#define FACTEUR_VITESSE_OZ2_COLLISION \
FU
#define TRANSLATION_VITESSE_OZ2_COLLISION \
FZERO
dfTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OZ2_COLLISION
,fichier_LISTE_FACTEUR_VITESSE_OZ2_COLLISION
,FACTEUR_VITESSE_OZ2_COLLISION_IMPLICITE
,FACTEUR_VITESSE_OZ2_COLLISION
)
dfTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OZ2_COLLISION
,fichier_LISTE_TRANSLATION_VITESSE_OZ2_COLLISION
,TRANSLATION_VITESSE_OZ2_COLLISION_IMPLICITE
,TRANSLATION_VITESSE_OZ2_COLLISION
)
#define ACCES_FACTEUR_VITESSE_OZ2_COLLISION(corps) \
IdTb1(liste_initiale_des_FACTEUR_VITESSE_OZ2_COLLISION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_TRANSLATION_VITESSE_OZ2_COLLISION(corps) \
IdTb1(liste_initiale_des_TRANSLATION_VITESSE_OZ2_COLLISION \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Facteurs multiplicatif et additif relatifs a la composante 'OZ2' d'une vitesse apres une */
/* collision (ceci a ete ajoute le 19991110082506 dans le but de permettre de garder le plus */
/* longtemps possible la "cohesion" d'un ensemble de particules -tel un "piston"-). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E L A C O A L E S C E N C E : */
/* */
/*************************************************************************************************************************************/
#define PROCEDER_A_LA_COALESCENCE_DES_CORPS_LORS_DES_COLLISIONS \
FAUX
DEFV(Local,DEFV(Logical,INIT(proceder_a_la_coalescence_des_corps_lors_des_collisions
,PROCEDER_A_LA_COALESCENCE_DES_CORPS_LORS_DES_COLLISIONS
)
)
);
/* Indique s'il faut moyenner les vitesses des particules a l'interieur de chaque famille */
dfTRANSFORMAT_31(liste_initiale_des_COALESCENCE,fichier_LISTE_COALESCENCE,COALESCENCE_IMPLICITE,FAUX)
#define gACCES_COALESCENCES(corps) \
IdTb1(liste_initiale_des_COALESCENCE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_COALESCENCES(corps) \
LOGI(gACCES_COALESCENCES(corps))
/* Definition des fichiers de la liste des coalescences (introduit le 20211116115514). */
DEFV(Int,INIT(dimension_du_milieu,UNDEF));
/* Dimension du milieu evaluee heuristiquement (introduite le 20211116134817). */
#define RAYON_APRES_COALESCENCE(liste_rayon,corps1,corps2) \
Bblock \
EGAL(ACCES_LISTE(liste_rayon,corps2) \
,PUIX(ADD2(PUIX(ACCES_LISTE(liste_rayon,corps1),FLOT(dimension_du_milieu)) \
,PUIX(ACCES_LISTE(liste_rayon,corps2),FLOT(dimension_du_milieu)) \
) \
,INVE(FLOT(dimension_du_milieu)) \
) \
); \
Eblock \
/* Changement de rayon apres coalescence. Cette formule vient du fait que : */ \
/* */ \
/* 2 */ \
/* surface = pi.R (cas 'BI_DIMENSIONNEL', en notant le */ \
/* commentaire relatif a la determination de */ \
/* 'dimension_du_milieu' ci-apres a la date */ \
/* du 20211116144028...) */ \
/* */ \
/* */ \
/* et : */ \
/* */ \
/* 4 3 */ \
/* volume = ---.pi.R (cas 'TRI_DIMENSIONNEL') */ \
/* 3 */ \
/* */ \
/* Etant donne que les masses (et donc les surfaces et les volumes) sont ajoutees (via */ \
/* les 'INCR(...)'s qui suivent), ce sont donc les puissances 2 et 3 des rayons qu'il */ \
/* faut ajouter respectivement... */
#define COULEUR_APRES_COALESCENCE(liste_couleur,corps1,corps2) \
Bblock \
EGAL(ACCES_LISTE(liste_couleur,corps2) \
,LRZ2(ACCES_MASSES(corps1),ACCES_LISTE(liste_couleur,corps1) \
,ACCES_MASSES(corps2),ACCES_LISTE(liste_couleur,corps2) \
) \
); \
Eblock \
/* Changement de couleur apres coalescence. */
#define COALESCENCE_EVENTUELLE_LORS_DES_COLLISIONS \
Bblock \
Test(IL_FAUT(proceder_a_la_coalescence_des_corps_lors_des_collisions)) \
Bblock \
Test(IFET(EST_VRAI(ACCES_COALESCENCES(corpsI)) \
,EST_VRAI(ACCES_COALESCENCES(corpsJ)) \
) \
) \
/* Cas ou les deux corps peuvent fusionner (introduit le 20211116121537) : */ \
Bblock \
DEFV(Int,INIT(CorpsSurvivant,UNDEF)); \
DEFV(Int,INIT(CorpsDisparu__,UNDEF)); \
\
Test(IFGT(ACCES_MASSES(corpsJ),ACCES_MASSES(corpsI))) \
Bblock \
EGAL(CorpsSurvivant,corpsJ); \
EGAL(CorpsDisparu__,corpsI); \
/* C'est le corps le plus massif ('corpsJ') qui survit (introduit le 20211117114759)... */ \
Eblock \
ATes \
Bblock \
Test(IFLT(ACCES_MASSES(corpsJ),ACCES_MASSES(corpsI))) \
Bblock \
EGAL(CorpsSurvivant,corpsI); \
EGAL(CorpsDisparu__,corpsJ); \
/* C'est le corps le plus massif ('corpsI') qui survit (introduit le 20211117114759)... */ \
Eblock \
ATes \
Bblock \
DEFV(Float,INIT(probabilite,FLOT__UNDEF)); \
GENERATION_D_UNE_VALEUR(probabilite,PROBABILITE_NULLE,PROBABILITE_UNITE); \
/* Losrque les deux corps ('corpsI' et 'corpsJ') ont la meme masse, on tire au sort celui */ \
/* qui va survivre (introduit le 20211117114759) : */ \
\
Test(IFLT(probabilite,PROBABILITE_MOYENNE)) \
Bblock \
EGAL(CorpsSurvivant,corpsJ); \
EGAL(CorpsDisparu__,corpsI); \
Eblock \
ATes \
Bblock \
EGAL(CorpsSurvivant,corpsI); \
EGAL(CorpsDisparu__,corpsJ); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
\
INCR(ACCES_MASSES(CorpsSurvivant),ACCES_MASSES(CorpsDisparu__)); \
\
RAYON_APRES_COALESCENCE(liste_initiale_des_RAYON,CorpsDisparu__,CorpsSurvivant); \
RAYON_APRES_COALESCENCE(liste_initiale_des_RAYON_D_INTERACTION,CorpsDisparu__,CorpsSurvivant); \
\
COULEUR_APRES_COALESCENCE(liste_initiale_des_ROUGE,CorpsDisparu__,CorpsSurvivant); \
COULEUR_APRES_COALESCENCE(liste_initiale_des_VERTE,CorpsDisparu__,CorpsSurvivant); \
COULEUR_APRES_COALESCENCE(liste_initiale_des_BLEUE,CorpsDisparu__,CorpsSurvivant); \
/* Ainsi, le 'CorpsSurvivant' integre les caracteristiques du 'CorpsDisparu__'. En ce qui */ \
/* concerne les 'MASSE's, la formule est correcte, mais par contre pour les 'RAYON's, c'est */ \
/* un peu arbitraire... */ \
\
EGAL(ACCES_DATES_DE_MORT(CorpsDisparu__),SOUS(temps_courant,dct)); \
/* Et enfin, on tue le 'CorpsDisparu__'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Coalescence des particules en collision (introduit le 20211116115514). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U M O Y E N N A G E D E S V I T E S S E S P A R F A M I L L E : */
/* */
/* */
/* Definition : */
/* */
/* Les particules, via 'ACCES_IDENTITES(...)' */
/* peuvent etre reparties en plusieurs familles. */
/* Implicitement les familles ne comportent */
/* qu'une seule particule. Soit donc une famille */
/* contenant 'N' particules de masses et de */
/* vitesses {M ,V } respectivement. */
/* i i */
/* */
/* La quantite de mouvement totale de cette */
/* famille est : */
/* */
/* */
/* i=N */
/* ______ */
/* \ */
/* \ */
/* P = / M V */
/* 1 /_____ i i */
/* i=1 */
/* */
/* */
/* On peut donc definir a partir de cette */
/* formule definir la vitesse moyenne de la */
/* famille par : */
/* */
/* */
/* i=N */
/* ______ */
/* \ */
/* \ */
/* / M V */
/* P /_____ i i */
/* 1 i=1 */
/* V = ------------- = ------------- */
/* M i=N i=N */
/* ______ ______ */
/* \ \ */
/* \ \ */
/* / M / M */
/* /_____ i /_____ i */
/* i=1 i=1 */
/* */
/* */
/* On peut alors modifier la famille {M ,V } */
/* i i */
/* en la famille {M ,V }. On notera qu'evidemment */
/* i M */
/* la nouvelle quantite de mouvement totale vaut : */
/* */
/* */
/* i=N */
/* ______ */
/* \ */
/* \ */
/* P = / M V */
/* 2 /_____ i M */
/* i=1 */
/* */
/* */
/* et est egale, par definition, a : */
/* */
/* P = P */
/* 2 1 */
/* */
/* L'interet de cette methode est qu'elle */
/* donne a toutes les particules d'une famille */
/* la meme vitesse, tout en conservant la */
/* quantite de mouvement. Ainsi, la "forme" */
/* initiale de la famille est conservee au */
/* cours du temps, puisque toutes les particules */
/* d'une telle famille se deplacent de la meme */
/* facon... */
/* */
/*************************************************************************************************************************************/
#define MOYENNER_LES_VITESSES_PAR_FAMILLE \
FAUX
DEFV(Local,DEFV(Logical,INIT(moyenner_les_vitesses_par_famille,MOYENNER_LES_VITESSES_PAR_FAMILLE)));
/* Indique s'il faut moyenner les vitesses des particules a l'interieur de chaque famille */
/* (un famille etant definie grace a l'IDENTITE). */
/* */
/* On notera qu'actuellement (le 19991112155016), 'ACCES_IDENTITES(...)' n'etant utilise */
/* que pour cette operation de moyennage des vitesses, on pourrait considere qu'elle ne */
/* sert a rien et la valeur : */
/* */
/* ACCES_IDENTITES(i) = i \-/ i */
/* */
/* amene aux memes fonctionnalites. C'est vrai, mais c'est pour prevoir de nouvelles */
/* fonctionnalites utilisant elles-aussi 'ACCES_IDENTITES(...)'... */
DEFV(Local,DEFV(Int,INIT(premiere_famille,INFINI)));
DEFV(Local,DEFV(Int,INIT(derniere_famille,MOINS_L_INFINI)));
/* Definition (calculee) de la premiere et de la derniere famille. */
#define GERER_DYNAMIQUEMENT_LES_FAMILLES \
FAUX
DEFV(Local,DEFV(Logical,INIT(gerer_dynamiquement_les_familles,GERER_DYNAMIQUEMENT_LES_FAMILLES)));
/* Indique s'il faut gerer dynamiquement les familles lors des collisions. */
dfTRANSFORMAT_31(liste_initiale_des_COLLAGE,fichier_LISTE_COLLAGE,COLLAGE_IMPLICITE,VRAI)
#define gACCES_COLLAGES(corps) \
IdTb1(liste_initiale_des_COLLAGE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_COLLAGES(corps) \
LOGI(gACCES_COLLAGES(corps))
/* Definition des fichiers de la liste des collages (introduit le 20000705085414). */
dfTRANSFORMAT_31(liste_initiale_des_CLEFS_DE_COLLAGE,fichier_LISTE_CLEFS_DE_COLLAGE,CLEFS_DE_COLLAGE_IMPLICITE,UN)
#define gACCES_CLEFS_DE_COLLAGE(corps) \
IdTb1(liste_initiale_des_CLEFS_DE_COLLAGE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_CLEFS_DE_COLLAGE(corps) \
INTE(gACCES_CLEFS_DE_COLLAGE(corps))
/* Definition des fichiers de la liste des clefs de collage (introduit le 20011029100429). */
#define AGGREGATION_EVENTUELLE_PAR_COLLAGE_LORS_DES_COLLISIONS \
Bblock \
Test(IL_FAUT(gerer_dynamiquement_les_familles)) \
Bblock \
Test(I3ET(EST_VRAI(ACCES_COLLAGES(corpsI)) \
,EST_VRAI(ACCES_COLLAGES(corpsJ)) \
,IFEQ(ACCES_CLEFS_DE_COLLAGE(corpsI),ACCES_CLEFS_DE_COLLAGE(corpsJ)) \
) \
) \
/* Cas ou les deux corps sont "collables" et possedent la meme clef de collage : */ \
Bblock \
DEFV(Int,INIT(identite_du_corpsI,ACCES_IDENTITES(corpsI))); \
DEFV(Int,INIT(identite_du_corpsJ,ACCES_IDENTITES(corpsJ))); \
/* Identites des deux corps {corpsI,corpsJ} en collision... */ \
\
Komp(corps,nombre_de_corps) \
Bblock \
Test(LE_CORPS_EST_VIVANT(corps)) \
/* Test introduit le 20160610152047... */ \
Bblock \
Test(IFEQ(ACCES_IDENTITES(corps),identite_du_corpsJ)) \
Bblock \
EGAL(gACCES_IDENTITES(corps),FLOT(identite_du_corpsI)); \
/* Tous les corps deja colles a 'corpsJ' sont colles a 'corpsI'. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EKom \
Eblock \
ATes \
Bblock \
/* Cas ou au moins l'un des deux corps n'est pas "collables"... */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Collage des particules en collision (introduit le 20000502091124). */
#define MOYENNAGE_DES_VITESSES_PAR_FAMILLE \
Bblock \
Test(IL_FAUT(moyenner_les_vitesses_par_famille)) \
Bblock \
DEFV(Int,INIT(famille,UNDEF)); \
/* Index de la famille courante. */ \
\
DoIn(famille,premiere_famille,derniere_famille,I) \
Bblock \
DEFV(Float,INIT(masse_de_la_famille,FZERO)); \
/* Masse cumulee de la famille courante. */ \
DEFV(deltaF_3D,quantite_de_mouvement_cumulee_de_la_famille); \
INITIALISATION_ACCROISSEMENT_3D(quantite_de_mouvement_cumulee_de_la_famille,FZERO,FZERO,FZERO); \
/* Quantite de mouvement cumulee de la famille courante. ATTENTION, il ne faut surtout pas */ \
/* ecrire : */ \
/* */ \
/* DEFV(Local,DEFV(deltaF_3D,INIS(quantite_de_mouvement_cumulee_de_la_famille */ \
/* ,IstructL03(FZERO,FZERO,FZERO) */ \
/* ) */ \
/* ) */ \
/* ); */ \
/* */ \
/* car, en effet, alors la remise a zero n'a jamais lieu (sauf la premiere fois, a l'instant */ \
/* initial et pour la premiere famille...). Cela a ete vu le 19991116105451. */ \
\
Komp(corps,nombre_de_corps) \
Bblock \
Test(LE_CORPS_EST_VIVANT(corps)) \
/* Test introduit le 20160610152047... */ \
Bblock \
Test(IFEQ(ACCES_IDENTITES(corps),famille)) \
Bblock \
INCR(ASD1(quantite_de_mouvement_cumulee_de_la_famille,dx) \
,MUL2(ACCES_MASSES(corps),ASD1(ACCES_VITESSE_COURANTE(corps),dx)) \
); \
INCR(ASD1(quantite_de_mouvement_cumulee_de_la_famille,dy) \
,MUL2(ACCES_MASSES(corps),ASD1(ACCES_VITESSE_COURANTE(corps),dy)) \
); \
INCR(ASD1(quantite_de_mouvement_cumulee_de_la_famille,dz) \
,MUL2(ACCES_MASSES(corps),ASD1(ACCES_VITESSE_COURANTE(corps),dz)) \
); \
/* Cumul des quantites de mouvement des particules de la famille. */ \
\
INCR(masse_de_la_famille,ACCES_MASSES(corps)); \
/* Cumul de la masse de la famille courante. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EKom \
\
Test(IZNE(masse_de_la_famille)) \
Bblock \
DEFV(deltaF_3D,vitesse_moyenne_de_la_famille); \
/* Vitesse moyenne des particules de la famille courante. */ \
\
INITIALISATION_ACCROISSEMENT_3D(vitesse_moyenne_de_la_famille \
,DIVI(ASD1(quantite_de_mouvement_cumulee_de_la_famille,dx) \
,masse_de_la_famille \
) \
,DIVI(ASD1(quantite_de_mouvement_cumulee_de_la_famille,dy) \
,masse_de_la_famille \
) \
,DIVI(ASD1(quantite_de_mouvement_cumulee_de_la_famille,dz) \
,masse_de_la_famille \
) \
); \
/* Vitesse moyenne des particules de la famille. */ \
\
Komp(corps,nombre_de_corps) \
Bblock \
Test(LE_CORPS_EST_VIVANT(corps)) \
/* Test introduit le 20160610152047... */ \
Bblock \
Test(IFEQ(ACCES_IDENTITES(corps),famille)) \
Bblock \
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps) \
,ASD1(vitesse_moyenne_de_la_famille,dx) \
,ASD1(vitesse_moyenne_de_la_famille,dy) \
,ASD1(vitesse_moyenne_de_la_famille,dz) \
); \
/* Enfin, chaque particule de la famille "adopte" la vitesse moyenne de la famille. */ \
\
INITIALISATION_POINT_3D(ACCES_COORDONNEES_COURANTES(corps) \
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dx) \
,DCT_EFFECTIF \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x) \
) \
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dy) \
,DCT_EFFECTIF \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y) \
) \
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dz) \
,DCT_EFFECTIF \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z) \
) \
); \
/* Et on refait le deplacement de la particule courante qui avait deja ete fait dans */ \
/* 'v $xrk/rdn_walk.53.I ACCES_COORDONNEES_COURANTES'. On notera qu'evidemment les */ \
/* 'ACCES_COORDONNEES_PRECEDENTES(...)' sont encore valides... ATTENTION, jusqu'a la */ \
/* date du 20000529105344, il y avait ici, par erreur, 'dct' et non pas 'DCT_EFFECTIF'. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EKom \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Moyennage des vitesses des particules a l'interieur de chaque famille... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A P R O P A G A T I O N D E S C O U L E U R S : */
/* */
/*************************************************************************************************************************************/
#define PROPAGER_LES_COULEURS \
FAUX
DEFV(Local,DEFV(Logical,INIT(propager_les_couleurs,PROPAGER_LES_COULEURS)));
/* Indique s'il faut propager les couleurs lors des collisions. */
dfTRANSFORMAT_31(liste_initiale_des_PROPAGATION_COULEURS,fichier_LISTE_PROPAGATION_COULEURS,PROPAGATION_COULEURS_IMPLICITE,FAUX)
#define gACCES_PROPAGATION_COULEURS(corps) \
IdTb1(liste_initiale_des_PROPAGATION_COULEURS \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_PROPAGATION_COULEURS(corps) \
LOGI(gACCES_PROPAGATION_COULEURS(corps))
/* Definition des fichiers de la liste des propagations des couleurs (introduit */
/* le 20000705085414). */
dfTRANSFORMAT_31(liste_initiale_des_AUTORISATION_DE_MODIFICATION_COULEURS
,fichier_LISTE_AUTORISATION_DE_MODIFICATION_COULEURS
,AUTORISATION_DE_MODIFICATION_COULEURS_IMPLICITE
,VRAI
)
/* La valeur 'VRAI' par defaut garantit la compatibilite anterieure au 20200316093448... */
#define gACCES_AUTORISATION_DE_MODIFICATION_COULEURS(corps) \
IdTb1(liste_initiale_des_AUTORISATION_DE_MODIFICATION_COULEURS \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_AUTORISATION_DE_MODIFICATION_COULEURS(corps) \
LOGI(gACCES_AUTORISATION_DE_MODIFICATION_COULEURS(corps))
/* Definition des fichiers de la liste des autorisations de modification des couleurs */
/* (introduit le 20200316093448). */
#define PROPAGATION_EVENTUELLE_DES_COULEURS_LORS_DES_COLLISIONS \
Bblock \
Test(IL_FAUT(propager_les_couleurs)) \
Bblock \
Test(IFOU(IFET(EST_VRAI(ACCES_PROPAGATION_COULEURS(corpsI)) \
,EST_VRAI(ACCES_PROPAGATION_COULEURS(corpsJ)) \
) \
,IFET(EST_FAUX(ACCES_PROPAGATION_COULEURS(corpsI)) \
,EST_FAUX(ACCES_PROPAGATION_COULEURS(corpsJ)) \
) \
) \
) \
Bblock \
/* Cas ou 'corpsI' et 'corpsJ' ont le meme comportement vis a vis de la couleur (ou bien */ \
/* ils la propagent tous les deux ou bien aucun ne la propage...) : on ne fait rien... */ \
/* */ \
/* On notera au passage qu'il serait possible de simplifier ce 'Test(...)' en testant */ \
/* tout simplement : */ \
/* */ \
/* Test(IFEQ(ACCES_PROPAGATION_COULEURS(corpsI) */ \
/* ,ACCES_PROPAGATION_COULEURS(corpsJ) */ \
/* ) */ \
/* ) */ \
/* */ \
/* mais que l'ecriture choisie permet plus facilement des evolutions... */ \
Eblock \
ATes \
Bblock \
/* On notera le 20200315175912 qu'il n'est pas possible d'interdire, dans l'etat actuel */ \
/* des choses, au corps "Recepteur" d'etre recepteur de la couleur du corps "Emetteur". */ \
/* Il faudrait pour ce faire introduire une nouvelle liste qui autorisarit cela par */ \
/* defaut pour tous les corps (afin d'introduire la compatibilite anterieure...). */ \
DEFV(Int,INIT(corpsE,PREMIER_POINT_DES_LISTES)); \
DEFV(Int,INIT(corpsR,PREMIER_POINT_DES_LISTES)); \
/* Definition des corps "Emetteur" et "Recepteur" de la couleur... */ \
/* */ \
/* On notera l'initialisation avec 'PREMIER_POINT_DES_LISTES' (et non 'UNDEF') pour */ \
/* eviter des problemes ci-apres si tous les 'Test(...)' sont FAUX (c'est dans ce cas */ \
/* qu'a lieu le 'PRINT_ERREUR(...)' ci-apres...). */ \
\
Test(IFET(EST_VRAI(ACCES_PROPAGATION_COULEURS(corpsI)) \
,EST_FAUX(ACCES_PROPAGATION_COULEURS(corpsJ)) \
) \
) \
Bblock \
EGAL(corpsE,corpsI); \
EGAL(corpsR,corpsJ); \
/* Cas ou 'corpsI' propage la couleur contrairement a 'corpsJ'... */ \
Eblock \
ATes \
Bblock \
Test(IFET(EST_FAUX(ACCES_PROPAGATION_COULEURS(corpsI)) \
,EST_VRAI(ACCES_PROPAGATION_COULEURS(corpsJ)) \
) \
) \
Bblock \
EGAL(corpsE,corpsJ); \
EGAL(corpsR,corpsI); \
/* Cas ou 'corpsJ' propage la couleur contrairement a 'corpsI'... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("le transfert de couleurs est impossible"); \
CAL1(Prer2("(cela concerne les corps %d et %d)\n",corpsI,corpsJ)); \
Eblock \
ETes \
Eblock \
ETes \
\
Test(EST_VRAI(ACCES_AUTORISATION_DE_MODIFICATION_COULEURS(corpsR))) \
/* Le corps 'corpsR' ne change de couleur que si cela est autorise (introduit le */ \
/* 20200316093448). */ \
Bblock \
EGAL(ACCES_LISTE(liste_initiale_des_ROUGE,corpsR),ACCES_LISTE(liste_initiale_des_ROUGE,corpsE)); \
EGAL(ACCES_LISTE(liste_initiale_des_VERTE,corpsR),ACCES_LISTE(liste_initiale_des_VERTE,corpsE)); \
EGAL(ACCES_LISTE(liste_initiale_des_BLEUE,corpsR),ACCES_LISTE(liste_initiale_des_BLEUE,corpsE)); \
/* La couleur de 'corpsE' est attribuee a 'corpsR', */ \
EGAL(gACCES_PROPAGATION_COULEURS(corpsR),ACCES_PROPAGATION_COULEURS(corpsE)); \
/* Et a partir de maintenant, 'corpsR' peut lui-aussi propager la couleur... */ \
/* */ \
/* On notera le 'gACCES_PROPAGATION_COULEURS(...)' introduit le 20050511103435 afin */ \
/* d'eviter le "cast" 'LOGI(...)' a gauche d'un signe "="... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Propagation des couleurs des particules en collision (introduit le 20050510090457). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A " S Y N C H R O N I S A T I O N " D E S V I T E S S E S : */
/* */
/*************************************************************************************************************************************/
#define SYNCHRONISER_LES_VITESSES \
FAUX
DEFV(Local,DEFV(Logical,INIT(synchroniser_les_vitesses,SYNCHRONISER_LES_VITESSES)));
/* Indique s'il faut synchroniser les vitesses lors des frolages (ceci fut introduit le */
/* 20060705114014). */
#define SYNCHRONISATION_EVENTUELLE_DES_VITESSES_LORS_DES_FROLAGES \
Bblock \
Test(IL_FAUT(synchroniser_les_vitesses)) \
Bblock \
INITIALISATION_ACCROISSEMENT_3D(cumul_vitesses_si_frolages \
,ADD2(ASD1(cumul_vitesses_si_frolages,dx) \
,ASD1(ACCES_VITESSE_COURANTE(corpsJ),dx) \
) \
,ADD2(ASD1(cumul_vitesses_si_frolages,dy) \
,ASD1(ACCES_VITESSE_COURANTE(corpsJ),dy) \
) \
,ADD2(ASD1(cumul_vitesses_si_frolages,dz) \
,ASD1(ACCES_VITESSE_COURANTE(corpsJ),dz) \
) \
); \
INCR(nombre_de_vitesses_cumulees_si_frolages,I); \
/* Le corps 'J' (qui est en train de froler le corps 'I') est ajoute au cumul... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Calculs utiles a la synchronisation des vitesses lors des frolages (ceci fut introduit */ \
/* le 20060705114014). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S I N T E R A C T I O N S D E S P A R T I C U L E S A V E C L E M I L I E U : */
/* */
/*************************************************************************************************************************************/
#define UTILISER_UN_CHAMP_DE_PROBABILITE \
FAUX
DEFV(Local,DEFV(Logical,INIT(utiliser_un_champ_de_probabilite,UTILISER_UN_CHAMP_DE_PROBABILITE)));
/* Indique s'il faut contraindre les interactions par un champ de probabilite defini par */
/* un album d'images ('VRAI') ou pas ('FAUX'). */
DEFV(Local,DEFV(Int,INIT(P_premiere_coupe,PREMIERE_IMAGE)));
/* Numero de la premiere coupe du champ de probabilite. */
DEFV(Local,DEFV(Int,INIT(P_pas_des_coupes,PAS_DES_IMAGES)));
/* Pas de passage d'un numero de coupe a une autre. */
DEFV(Local,DEFV(Int,INIT(P_nombre_de_chiffres_pour_le_champ,NOMBRE_DE_CHIFFRES)));
/* Nombre de chiffres codant le numero des coupes de la serie... */
#define P_ATTENDRE_LES_IMAGES_INEXISTANTES \
VRAI
DEFV(Local,DEFV(Logical,INIT(P_attendre_les_images_inexistantes,P_ATTENDRE_LES_IMAGES_INEXISTANTES)));
/* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien s'il faut */
/* attendre qu'elles aient ete calculees ('VRAI'). */
#define P_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_ACCES_ALBUM \
NE_PAS_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_UN_ALBUM
DEFV(Local,DEFV(Logical,INIT(P_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,P_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_ACCES_ALBUM
)
)
);
/* Indique si les images inexistantes constituent une erreur ('FAUX'), ou bien s'il faut */
/* accepter leur inexistence ('VRAI') ; cela permet d'avoir moins d'images dans un album */
/* que necessaire vis a vis de la definition de {Zmin,Zmax}. */
#define P_PERIODISER_X \
FAUX
#define P_PERIODISER_Y \
FAUX
#define P_PERIODISER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(P_periodiser_X,P_PERIODISER_X)));
DEFV(Local,DEFV(Logical,INIT(P_periodiser_Y,P_PERIODISER_Y)));
DEFV(Local,DEFV(Logical,INIT(P_periodiser_Z,P_PERIODISER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] est periodique ('VRAI') ou pas */
/* ('FAUX'). */
#define P_SYMETRISER_X \
FAUX
#define P_SYMETRISER_Y \
FAUX
#define P_SYMETRISER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(P_symetriser_X,P_SYMETRISER_X)));
DEFV(Local,DEFV(Logical,INIT(P_symetriser_Y,P_SYMETRISER_Y)));
DEFV(Local,DEFV(Logical,INIT(P_symetriser_Z,P_SYMETRISER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] est symetrique ('VRAI') ou pas */
/* ('FAUX'). Ceci a ete introduit le 20050721095823... */
#define P_PROLONGER_X \
FAUX
#define P_PROLONGER_Y \
FAUX
#define P_PROLONGER_Z \
FAUX
DEFV(Local,DEFV(Logical,INIT(P_prolonger_X,P_PROLONGER_X)));
DEFV(Local,DEFV(Logical,INIT(P_prolonger_Y,P_PROLONGER_Y)));
DEFV(Local,DEFV(Logical,INIT(P_prolonger_Z,P_PROLONGER_Z)));
/* Indique si l'espace [Xmin,Xmax]x[Ymin,Ymax]x[Zmin,Zmax] doit etre prolonge a l'exterieur */
/* comme il est au bord ('VRAI') ou pas ('FAUX'). */
#define P_NIVEAU_HORS_DU_CHAMP_DE_PROBABILITE \
NIVEAU_HORS_ECRAN
DEFV(Local,DEFV(genere_p,INIT(P_niveau_hors_du_champ_de_probabilite,P_NIVEAU_HORS_DU_CHAMP_DE_PROBABILITE)));
/* Valeur a forcer a l'exterieur du champ de probabilite, lorsqu'il ne faut ni periodiser, */
/* ni prolonger... */
#define P_NIVEAU_INITIAL_DU_CHAMP_DE_PROBABILITE \
BLANC
DEFV(Local,DEFV(genere_p,INIT(P_niveau_initial_du_champ_de_probabilite,P_NIVEAU_INITIAL_DU_CHAMP_DE_PROBABILITE)));
/* Valeur pour initialiser eventuellement le champ de probabilite dans 'ACCES_ALBUM(...)'. */
#define P_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM \
NE_PAS_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM
DEFV(Local,DEFV(Logical,INIT(P_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM,P_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM)));
/* Indique si l'ordre des coupes doit etre inverses ('VRAI') ou pas ('FAUX') dans la */
/* procedure 'ACCES_ALBUM(...)' pour les Probabilites. */
#define TENTER_DE_SYNCHRONISER_LES_IMMOBILISATIONS_SUR_LES_NAISSANCES \
FAUX
DEFV(Local,DEFV(Logical,INIT(tenter_de_synchroniser_les_immobilisations_sur_les_naissances
,TENTER_DE_SYNCHRONISER_LES_IMMOBILISATIONS_SUR_LES_NAISSANCES
)
)
);
#define FACTEUR_SYNCHRONISATION_DES_IMMOBILISATIONS_SUR_LES_NAISSANCES \
FU
DEFV(Local,DEFV(Float,INIT(facteur_synchronisation_des_immobilisations_sur_les_naissances
,FACTEUR_SYNCHRONISATION_DES_IMMOBILISATIONS_SUR_LES_NAISSANCES
)
)
);
/* Les immobilisations doivent-elles etres synchronisees sur les naissances ('VRAI') ou */
/* bien immobilisations et naissances doivent-elle etre completement independantes ('FAUX'). */
/* Ce dispositif a ete introduit le 20020227092012. On notera que cela n'est active que dans */
/* le cas ou le test d'immobilisation est probabiliste ('IZLT(ACCES_IMMOBILISABLES(...))'). */
/* D'autre part, il ne s'agit que d'une tentative destinee a faire qu'il ne meure pas plus */
/* de particules qu'il n'en nait ; le controle porte donc sur la mort des particules et */
/* non point sur leur naissance qui, elle, est controlee de facon inflexible par la liste */
/* 'fichier_LISTE_DATE_DE_NAISSANCE'... */
#define FAIRE_MOURIR_LES_PARTICULES_IMMOBILISABLES \
FAUX
DEFV(Local,DEFV(Logical,INIT(faire_mourir_les_particules_immobilisables,FAIRE_MOURIR_LES_PARTICULES_IMMOBILISABLES)));
/* Que faire des particules immobilisees : les faire mourir ('VRAI'), ce qui signifie */
/* qu'elles n'apparaitront plus, ou bien leur donner une vitesse nulle et une masse */
/* infinie ('FAUX') afin qu'elles ne puissent plus bouger tout en etant visibles ? */
#define MASSE_D_UN_CORPS_APRES_IMMOBILISATION \
F_PETIT_INFINI \
/* Masse a donner a un corps apres son eventuelle immobilisation ; cette valeur "infinie" */ \
/* permet de traiter correctement les chocs ulterieurs de cette particule avec d'autres... */
dfTRANSFORMAT_31(liste_initiale_des_IMMOBILISABLE,fichier_LISTE_IMMOBILISABLE,IMMOBILISABLE_IMPLICITE,INFINI)
#define ACCES_IMMOBILISABLES(corps) \
IdTb1(liste_initiale_des_IMMOBILISABLE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
) \
/* Definition des fichiers de la liste des immobilisables (introduit le 20010906164754 */ \
/* et converti de 'LOGI(...)' a 'INTE(...)' le 20010910092922). Cette liste donne donc */ \
/* dorenavant le nombre de reflexions sur le milieu avant immobilisation. ATTENTION, le */ \
/* 20010912100702, suite a une compilation sur '$LACT29', il est apparu qu'il etait */ \
/* impossible de "typer" ci-dessus par un 'INTE(...)' (d'ou sa suppression...) ; ceci */ \
/* est du aux intructions 'v $xrk/rdn_walk.52$I DECR.ACCES_IMMOBILISABLES'. */ \
/* Le 20020219142536 a ete introduit la possibilite d'un test probabiliste suivant les */ \
/* conventions suivantes : */ \
/* */ \
/* ACCES_IMMOBILISABLES(corps) >= 0 : donne un decompteur de */ \
/* reflexions avant immobilisation, */ \
/* */ \
/* ACCES_IMMOBILISABLES(corps) < 0 : la valeur absolue donne une */ \
/* probabilite d'immobilisation a */ \
/* chaque reflexion. */ \
/* */ \
/* On notera le 20160504143710 qu'alors, pour communiquer une probabilite d'immobilisation */ \
/* nulle, la solution sera en fait de donner une valeur negative, mais tres tres faible en */ \
/* valeur absolue (de facon a ce que 'GENERATION_D_UNE_VALEUR(...,0,1)' ne l'atteigne */ \
/* pratiquement jamais). Ainsi, par exemple : */ \
/* */ \
/* ACCES_IMMOBILISABLES(corps) = NEGA(D_EPSILON) */ \
/* */ \
/* conviendra... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U C H A M P D E G R A V I T A T I O N A M B I A N T : */
/* */
/* */
/* Nota : */
/* */
/* Grace a ce dispositif, il est possible de */
/* donner a toutes les particules une vitesse */
/* initiale nulle. Grace a la gravite, elles */
/* accelereront progressivement... */
/* */
/* */
/* ATTENTION : */
/* */
/* il est important de bien noter que le module */
/* du vecteur 'G' est constant et ne depend pas de */
/* la distance au centre du champ de gravitation ; */
/* ce n'est donc pas un "vrai" champ de gravitation ! */
/* */
/*************************************************************************************************************************************/
#define LE_CHAMP_DE_GRAVITATION_EST_CENTRAL \
FAUX
DEFV(Local,DEFV(Logical,INIT(le_champ_de_gravitation_est_central,LE_CHAMP_DE_GRAVITATION_EST_CENTRAL)));
/* Indique si le champ de gravitation est central ('VRAI') ou pas ('FAUX'), c'est-a-dire */
/* "parallele" (introduit le 20000606133353). */
#define CENTRE_DU_CHAMP_DE_GRAVITATION_CENTRAL_X \
Xcentre_ESPACE
#define CENTRE_DU_CHAMP_DE_GRAVITATION_CENTRAL_Y \
Ycentre_ESPACE
#define CENTRE_DU_CHAMP_DE_GRAVITATION_CENTRAL_Z \
hZmin_ESPACE
DEFV(Local,DEFV(Float,INIT(centre_du_champ_de_gravitation_central_X,CENTRE_DU_CHAMP_DE_GRAVITATION_CENTRAL_X)));
DEFV(Local,DEFV(Float,INIT(centre_du_champ_de_gravitation_central_Y,CENTRE_DU_CHAMP_DE_GRAVITATION_CENTRAL_Y)));
DEFV(Local,DEFV(Float,INIT(centre_du_champ_de_gravitation_central_Z,CENTRE_DU_CHAMP_DE_GRAVITATION_CENTRAL_Z)));
/* Centre du champ de gravitation si 'EST_VRAI(le_champ_de_gravitation_est_central)'. */
#define LE_CHAMP_DE_GRAVITATION_EST_CENTRAL_ET_DYNAMIQUE \
FAUX
DEFV(Local,DEFV(Logical,INIT(le_champ_de_gravitation_est_central_et_dynamique,LE_CHAMP_DE_GRAVITATION_EST_CENTRAL_ET_DYNAMIQUE)));
/* Indique, lorsque 'EST_VRAI(le_champ_de_gravitation_est_central)', si le champ est de */
/* plus statique ('FAUX') ou dynamique ('VRAI'), c'est-a-dire dont la source est l'un des */
/* corps defini par 'corps_centre_de_gravitation_dynamique' (introduit le 20010521090650). */
#define CORPS_CENTRE_DE_GRAVITATION_DYNAMIQUE \
PREMIER_POINT_DES_LISTES
DEFV(Local,DEFV(Int,INIT(corps_centre_de_gravitation_dynamique,CORPS_CENTRE_DE_GRAVITATION_DYNAMIQUE)));
/* Indique, si 'EST_VRAI(le_champ_de_gravitation_est_central_et_dynamique)' le numero du */
/* corps source du champ de gravitation... */
#define INTENSITE_DU_CHAMP_DE_GRAVITATION_CENTRAL \
FZERO
DEFV(Local,DEFV(Float,INIT(intensite_du_champ_de_gravitation_central,INTENSITE_DU_CHAMP_DE_GRAVITATION_CENTRAL)));
/* Module du vecteur 'G' si 'EST_VRAI(le_champ_de_gravitation_est_central)'. On notera */
/* l'etat {0} par defaut ce qui place alors le systeme dans un espace sans gravitation... */
/* */
/* On notera qu'il s'agit d'un module de vecteur, c'est-a-dire d'une quantite qui est a */
/* priori positive. Mais lors de l'entree de ce parametre, rien n'empeche de fournir une */
/* valeur negative, ce qui va donner de l'anti-gravitation, comme cela est fait avec la */
/* sequence : */
/* */
/* xivPdf 10 2 / 001025_001536 */
/* */
/* En ce qui concerne la vitesse de liberation, elle est definie comme celle qui permet */
/* de disposer d'une energie cinetique suffisante pour vaincre l'energie gravitationnelle, */
/* soit : */
/* */
/* 1 2 Mm */
/* ---.mV = G.---- */
/* 2 z */
/* */
/* ou 'Z' designe l'altitude courante, 'M' la masse du corps creant le champ gravitationnel */
/* et 'm' la masse du corps qui veut se liberer. La vitesse de liberation 'V' vaut donc : */
/* */
/* ______ */
/* / M */
/* V = \/ 2G.--- */
/* z */
/* */
/* Pour la Terre (M=59.750e23, z=6371000 au niveau de la mer) avec G=6.6720e-11, on trouve */
/* pour V la valeur 11186.859 metres/seconde. */
#define ACCELERATION_DU_CHAMP_DE_GRAVITATION_X \
FZERO
#define ACCELERATION_DU_CHAMP_DE_GRAVITATION_Y \
FZERO
#define ACCELERATION_DU_CHAMP_DE_GRAVITATION_Z \
FZERO
DEFV(Local,DEFV(Float,INIT(acceleration_du_champ_de_gravitation_X,ACCELERATION_DU_CHAMP_DE_GRAVITATION_X)));
DEFV(Local,DEFV(Float,INIT(acceleration_du_champ_de_gravitation_Y,ACCELERATION_DU_CHAMP_DE_GRAVITATION_Y)));
DEFV(Local,DEFV(Float,INIT(acceleration_du_champ_de_gravitation_Z,ACCELERATION_DU_CHAMP_DE_GRAVITATION_Z)));
/* Definition du vecteur 'G'. On notera l'etat {0,0,0} par defaut ce qui place alors le */
/* systeme dans un espace sans gravitation... */
dfTRANSFORMAT_31(liste_initiale_des_PONDERATION_DE_G,fichier_LISTE_PONDERATION_DE_G,PONDERATION_DE_G_IMPLICITE,FU)
#define ACCES_PONDERATIONS_DE_G(corps) \
IdTb1(liste_initiale_des_PONDERATION_DE_G \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition du fichier de liste des ponderation de 'G' et de son acces (introduit */
/* le 20000529105344). Cette ponderation permet, lorsqu'elle est nulle, de rendre les */
/* particules correspondantes insensibles a la gravite. Cela serait, par exemple, utile */
/* pour un obstacle, tel celui de la sequence : */
/* */
/* xivPdf 9 2 / 034975_035486 */
/* */
/* qui doit evidemment rester parfaitement immobile... */
dfTRANSFORMAT_31(liste_EVOLUTION_DE_G,fichier_EVOLUTION_DE_G,EVOLUTION_DE_G_IMPLICITE,FU)
#define sEVOLUTION_DE_G(numero_de_la_periode) \
FLOT(sTRANSFORMAT_31(numero_de_la_periode \
,liste_EVOLUTION_DE_G \
) \
) \
/* Formule generale definissant la modulation de 'G' au cours du temps. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' I N T E R A C T I O N G R A V I T A T I O N N E L L E G E N E R A L I S E E */
/* ( F I N ) : */
/* */
/*************************************************************************************************************************************/
#include xrr/N_corps.13.I"
#define GERER_LES_COLLISIONS_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
FAUX
DEFV(Local,DEFV(Logical,INIT(gerer_les_collisions_interaction_gravitationnelle_generalisee
,GERER_LES_COLLISIONS_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* Indique si l'interaction gravitationnelle (generalisee...) doit prendre en compte les */
/* collisions ('VRAI') ou pas ('FAUX'), sachant que de toute facon cela sera aussi traite */
/* dans 'v $xrk/rdn_walk.51$I'... */
/* */
/* ATTENTION, la valeur par defaut est passee de 'VRAI' a 'FAUX' le 19981030160852. */
#define CONSTANTE_DE_LA_GRAVITATION_GENERALISEE \
PARE(1.0e-10)
DEFV(Local,DEFV(Float,INIT(constante_de_la_gravitation_generalisee,CONSTANTE_DE_LA_GRAVITATION_GENERALISEE)));
/* Constante de l'interaction gravitationnelle (generalisee...). On notera au passage que */
/* la constante 'CONSTANTE_DE_LA_GRAVITATION' est beaucoup trop petite ici... */
#define FACTEUR_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
NEUT(FRA1(FRA1(FU)))
DEFV(Local,DEFV(Float,INIT(facteur_A_distance_interaction_gravitationnelle_generalisee
,FACTEUR_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
#define TRANSLATION_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
FZERO
DEFV(Local,DEFV(Float,INIT(translation_A_distance_interaction_gravitationnelle_generalisee
,TRANSLATION_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
#define EXPOSANT_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
SE12(TROIS,QUATRE)
DEFV(Local,DEFV(Float,INIT(exposant_A_distance_interaction_gravitationnelle_generalisee
,EXPOSANT_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* ATTENTION, le 20000202170921, un 'QUATRE' a remplace un 'SIX'. */
#define FACTEUR_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
SE12(FZERO,NEGA(FRA10(FRA10(FRA10(FRA10(FU))))))
DEFV(Local,DEFV(Float,INIT(facteur_R_distance_interaction_gravitationnelle_generalisee
,FACTEUR_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
#define TRANSLATION_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
FZERO
DEFV(Local,DEFV(Float,INIT(translation_R_distance_interaction_gravitationnelle_generalisee
,TRANSLATION_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
#define EXPOSANT_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
SE12(ZERO,SEPT)
DEFV(Local,DEFV(Float,INIT(exposant_R_distance_interaction_gravitationnelle_generalisee
,EXPOSANT_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* ATTENTION, le 20000202170921, un 'SEPT' a remplace un 'DOUZE'... */
/* Exposants de la distance lors de l'evaluation de l'interaction gravitationnelle qui est */
/* donc qualifiee de 'generalisee' puisque d'une part la constante de gravitation et ces */
/* exposants sont parametrables. Il y a deux exposants differents, l'un appele "Attractif" */
/* et l'autre "Repulsif" lorsque les ponderations associees sont la premiere positive ("A") */
/* et la seconde negative ("R"). */
/* */
/* On notera les initialisations par defaut : */
/* */
/* facteur_A = +1.0 */
/* exposant_A = 3 */
/* */
/* facteur_R = 0 */
/* exposant_R = 0 (en fait cette valeur est indifferente...) */
/* */
/* qui correspondent a de la gravitation newtonienne, et initialisations "alternatives" : */
/* */
/* facteur_A = +1.0 */
/* exposant_A = 4 */
/* */
/* facteur_R = -1.0e-4 */
/* exposant_R = 7 */
/* */
/* qui correspondent a une interaction "Attractive" a longue distante et "Repulsive" a */
/* courte distance.. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S T R O I S F O N C T I O N S ' F ' : */
/* ? */
/* */
/* */
/* Definition : */
/* */
/* Soit la famille {P ,P ,...,P } de 'N' */
/* 1 2 N */
/* particules en interaction (attractive et/ou repulsive). */
/* Pour l'un d'entre-eux, la loi fondamentale de */
/* la dynamique s'ecrit : */
/* */
/* ---> -------> */
/* F = M . Gamma */
/* i i i */
/* */
/* dans le cas present, la force 'F' est la */
/* resultante de l'interaction attractive et/ou repulsive */
/* (suivant le signe de la charge de l'interaction) */
/* des 'N-1' autres corps. On aura donc : */
/* */
/* -------> ---> */
/* M .Gamma = F */
/* i i i */
/* */
/* ou encore ('C' designant la charge de */
/* l'interaction) : */
/* */
/* ----> ______ */
/* dV \ C C */
/* i \ i k -----> */
/* M .------ = G / ------------- A A */
/* i /_____ |----->|n+1 i k */
/* dt k#i | A A | */
/* | i k | */
/* */
/* (avec n=2 pour la "vraie" gravitation) ou */
/* encore : */
/* */
/* ----> ______ */
/* dV C \ C */
/* i i \ k -----> */
/* ------ = G ---- / ------------- A A */
/* M /_____ |----->|n+1 i k */
/* dt i k#i | A A | */
/* | i k | */
/* */
/* On aboutit ainsi a un systeme d'equations */
/* differentielles non lineaires du premier */
/* ordre utilisant les fonctions suivantes : */
/* */
/* ______ */
/* C \ C */
/* i \ k */
/* F = -G ---- / -------------------------------------------(X - X ) */
/* X M /_____ | | n+1 k i */
/* i i k#i | |----- */
/* | 2 2 2| 2 */
/* |(X - X ) + (Y - Y ) + (Z - Z )| */
/* | k i k i k i | */
/* */
/* avec bien entendu des formules equivalentes */
/* pour les coordonnees 'Y' et 'Z'... */
/* */
/* */
/* En fait, la situation est legerement plus */
/* complexe car l'interaction est en fait composee */
/* de deux interactions dites 'A' (en general pour */
/* 'Attractive') et 'R' (en general pour 'Repulsive'). */
/* Cela est defini ci-apres... */
/* */
/*************************************************************************************************************************************/
#define F(fonction,coordonnees) \
DEFV(Local,DEFV(FonctionF,fonction(corpsI))) \
DEFV(Argument,DEFV(Int,corpsI)); \
/* Numero du corps par rapport auquel on calcule l'inverse pondere de la somme des */ \
/* distances. ATTENTION, 'corpsI' a lors des appels a ces trois fonctions 'FX(...)', */ \
/* 'FY(...)' et 'FZ(...)' la valeur de la variable 'corps'... */ \
/*-----------------------------------------------------------------------------------------------------------------------------------*/ \
Bblock \
DEFV(Float,INIT(cumul_courant_A,FZERO)); \
DEFV(Float,INIT(cumul_courant_R,FZERO)); \
/* Composantes de la valeur de la fonction. */ \
DEFV(Int,INIT(corpsK,UNDEF)); \
/* Index des corps... */ \
/*..............................................................................................................................*/ \
\
Komp(corpsK,nombre_de_corps) \
Bblock \
Test(LE_CORPS_EST_VIVANT(corpsK)) \
/* Test introduit le 20160610152047... */ \
Bblock \
Test(IFNE(corpsK,corpsI)) \
Bblock \
Test(IFOU(IFET(EST_VRAI(toutes_les_interactions_2_a_2_sont_prises_en_compte) \
,EST_VRAI(ACCES_SOURCES_DU_POTENTIEL(corpsK)) \
) \
/* Cas ou toutes les interactions 2 a 2 sont calculees, et ou de plus, le corps courant */ \
/* 'corpsK' intervient dans ce calcul... */ \
,IFET(EST_FAUX(toutes_les_interactions_2_a_2_sont_prises_en_compte) \
,IFEQ(corpsK,corps_source_du_potentiel) \
) \
/* Cas ou un seul corps ('corps_source_du_potentiel') genere le potentiel gravitationnel. */ \
) \
) \
Bblock \
DEFV(Float,INIT(distance_I_K_precedente,ACCES_DISTANCES_PRECEDENTES(corpsI,corpsK))); \
/* Distance entre 'corpsI' et 'corpsK' a l'instant precedent... */ \
\
Test(I3ET(IL_FAUT(gerer_les_collisions_interaction_gravitationnelle_generalisee) \
,IFLT(distance_I_K_precedente \
,seuil_d_interaction \
) \
,IFLT(distance_I_K_precedente \
,MUL2(facteur_des_rayon_d_interaction \
,ADD2(ACCES_LISTE(liste_initiale_des_RAYON_D_INTERACTION,corpsI) \
,ACCES_LISTE(liste_initiale_des_RAYON_D_INTERACTION,corpsK) \
) \
) \
) \
) \
) \
Bblock \
Test(IL_FAUT(gerer_les_collisions)) \
Bblock \
Test(IFLT(corpsI,corpsK)) \
/* Ce test a ete ajoute le 19990430160515 car il semblait manquer. On pourra consulter */ \
/* l'etude des collisions dans 'v $xrk/rdn_walk.51$I IFLT.corpsI.corpsJ.' pour plus */ \
/* d'informations ; ce test est destine a traiter la collision {corpsI,corpsK} et */ \
/* et ne pas la traiter une deuxieme fois sous le nom {corpsK,corpsI}. */ \
Bblock \
COLLISION_ENTRE_DEUX_CORPS(corpsI,corpsK); \
/* Gestion de la collision entre 'corpsI' et 'corpsK'... */ \
\
MODIFICATION_D_UNE_VITESSE_APRES_COLLISION(corpsI); \
MODIFICATION_D_UNE_VITESSE_APRES_COLLISION(corpsK); \
/* Modification eventuelle des composantes des vitesses apres une collision (ceci a ete */ \
/* ajoute le 19991110082506 dans le but de permettre de garder le plus longtemps possible */ \
/* la "cohesion" d'un ensemble de particules -tel un "piston"-). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("deux corps sont rentres en collision"); \
CAL1(Prer2("(%d et %d)\n",corpsI,corpsK)); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
DEFV(Float,INIT(inverse_de_la_distance_I_K_precedente,INVZ(distance_I_K_precedente))); \
/* Inverse de la distance entre 'corpsI' et 'corpsK' a l'instant precedent... */ \
\
INCR(cumul_courant_A \
,MUL2(MUL2(ACCES_CHARGES_A(corpsK) \
,LIN1(facteur_A_distance_interaction_gravitationnelle_generalisee \
,PUIX(inverse_de_la_distance_I_K_precedente \
,exposant_A_distance_interaction_gravitationnelle_generalisee \
) \
,translation_A_distance_interaction_gravitationnelle_generalisee \
) \
) \
,SOUS(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsK),coordonnees) \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),coordonnees) \
) \
) \
); \
INCR(cumul_courant_R \
,MUL2(MUL2(ACCES_CHARGES_R(corpsK) \
,LIN1(facteur_R_distance_interaction_gravitationnelle_generalisee \
,PUIX(inverse_de_la_distance_I_K_precedente \
,exposant_R_distance_interaction_gravitationnelle_generalisee \
) \
,translation_R_distance_interaction_gravitationnelle_generalisee \
) \
) \
,SOUS(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsK),coordonnees) \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),coordonnees) \
) \
) \
); \
/* Ainsi, la fonction habituelle de la gravitation : */ \
/* */ \
/* 1 */ \
/* --------- */ \
/* 3 */ \
/* d(i,k) */ \
/* */ \
/* est generalisee en : */ \
/* */ \
/* F F */ \
/* A R */ \
/* ---------- + T + ---------- + T */ \
/* E A E R */ \
/* A R */ \
/* d(i,k) d(i,k) */ \
/* */ \
/* */ \
/* ou 'd(i,k)' represente la distance entre les corps 'corpsI' et 'corpsK' et ou les */ \
/* indices 'A' et 'R' sont la pour rappeler que souvent ils correspondront respectivement */ \
/* a une force "Attractive" (F>0) et a une force "Repulsive" (F<0). */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EKom \
\
RETU(MUL2(NEGA(constante_de_la_gravitation_generalisee) \
,DIVI(LIZ2(ACCES_CHARGES_A(corpsI) \
,cumul_courant_A \
,ACCES_CHARGES_R(corpsI) \
,cumul_courant_R \
) \
,ACCES_MASSES(corpsI) \
) \
) \
); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A F O N C T I O N ' F ' : */
/* x */
/* */
/*************************************************************************************************************************************/
BFonctionF
F(FX,x)
EFonctionF
#define Fx(cx,cy,cz,t) \
FX(corps)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A F O N C T I O N ' F ' : */
/* y */
/* */
/*************************************************************************************************************************************/
BFonctionF
F(FY,y)
EFonctionF
#define Fy(cx,cy,cz,t) \
FY(corps)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A F O N C T I O N ' F ' : */
/* z */
/* */
/*************************************************************************************************************************************/
BFonctionF
F(FZ,z)
EFonctionF
#define Fz(cx,cy,cz,t) \
FZ(corps)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' I N T E G R A T I O N D U S Y S T E M E */
/* D ' E Q U A T I O N S D I F F E R E N T I E L L E S : */
/* */
/*************************************************************************************************************************************/
#define ORDRE_DE_LA_METHODE_D_INTEGRATION \
METHODE_DE_RUNGE_KUTTA_D_ORDRE_4
/* Mis avant 'xrk/integr.1B$vv$I' le 20070814111110... */
#include xrk/integr.1B.vv.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A M O D U L A T I O N */
/* D E S P A R A M E T R E S D E V I S U A L I S A T I O N : */
/* */
/*************************************************************************************************************************************/
#define FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_ROUGE \
FZERO
#define FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_VERTE \
FZERO
#define FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_BLEUE \
FZERO
DEFV(Local,DEFV(Float,INIT(facteur_du_module_de_la_vitesse_pour_le_ROUGE,FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_ROUGE)));
DEFV(Local,DEFV(Float,INIT(facteur_du_module_de_la_vitesse_pour_le_VERTE,FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_VERTE)));
DEFV(Local,DEFV(Float,INIT(facteur_du_module_de_la_vitesse_pour_le_BLEUE,FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_BLEUE)));
/* Modulation de la couleur {ROUGE,VERTE,BLEUE} par le module de la vitesse (ce dispositif */
/* a ete introduit le 20050530094748). */
#define FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_RAYON \
FZERO
DEFV(Local,DEFV(Float,INIT(facteur_du_module_de_la_vitesse_pour_le_RAYON,FACTEUR_DU_MODULE_DE_LA_VITESSE_POUR_LE_RAYON)));
/* Modulation du rayon de visualisation par le module de la vitesse (ce dispositif */
/* a ete introduit le 20050530094748). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' E D I T I O N D E S E V E N E M E N T S : */
/* */
/*************************************************************************************************************************************/
#define EDITER_LES_EVENEMENTS \
FAUX
DEFV(Local,DEFV(Logical,INIT(editer_les_evenements,EDITER_LES_EVENEMENTS)));
/* Indique s'il faut editer les evenements ('VRAI') ou pas ('FAUX'). */
#define EDITION_E(action) \
Bblock \
Test(IL_FAUT(editer_les_evenements)) \
Bblock \
BLOC(action;); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Procedure d'edition conditionnelle... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S I N I T I A L I S A T I O N S : */
/* */
/*************************************************************************************************************************************/
/* Jusqu'au 20030313151603, '__VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND' etait defini */
/* ici, mais cela est contraire aux tests dont il est l'objet dans */
/* 'v $xrv/champs_5.12$I __VERSION__PERMETTRE_L_UTILISATION_D_UN_FOND' via */
/* 'v $xrk/attractor.17$I champs_5.12', d'ou son deplacement a cette date... */
#include xrk/attractor.18.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H R O N O M E T R A G E D E L A S I M U L A T I O N : */
/* */
/*************************************************************************************************************************************/
#include xrk/rdn_walk.54.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A R C H E A L E A T O I R E D A N S L ' E S P A C E T R I D I M E N S I O N N E L */
/* A V E C I N T E R A C T I O N E N T R E L E S P A R T I C U L E S */
/* L E T O U T E T A N T D A N S U N M I L I E U D E P R O P A G A T I O N : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_du_champ_de_forceA),NOM_PIPE));
/* Nom de la sequence definissant le champ de force. */
DEFV(CHAR,INIC(POINTERc(F_nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_du_champ_de_forceA><numero> (par */
/* exemple '$ROUGE'). */
DEFV(CHAR,INIC(POINTERc(nom_du_milieu_de_propagationA),NOM_PIPE));
/* Nom de la sequence definissant le milieu de propagation. */
DEFV(CHAR,INIC(POINTERc(M_nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_du_milieu_de_propagationA><numero> (par */
/* exemple '$ROUGE'). */
DEFV(CHAR,INIC(POINTERc(nom_de_la_geometrie_du_milieu_de_propagation),NOM_PIPE_Local));
/* Nom de l'image contenant au retour la geometrie du milieu de propagation. */
DEFV(CHAR,INIC(POINTERc(nom_du_champ_de_probabiliteA),NOM_PIPE));
/* Nom de la sequence definissant le champ de probabilite. */
DEFV(CHAR,INIC(POINTERc(P_nom_postfixe),NOM_UNDEF_VIDE));
/* Nom d'un eventuel postfixe a placer derriere <nom_du_champ_de_probabiliteA><numero> (par */
/* exemple '$ROUGE'). */
DONNEES_NECESSAIRES_A_L_UTILISATION_D_UN_FOND;
DEFV(Int,INIT(corpsI,UNDEF));
DEFV(Int,INIT(corpsJ,UNDEF));
DEFV(Int,INIT(corps,UNDEF));
/* Pour manipuler les listes... */
/*..............................................................................................................................*/
EGAL(Zmin,k___Zmin);
EGAL(Zmax,SUCZ(Zmin));
/* Cette precaution essentielle est due a la declaration : */
/* */
/* BDEFV(album,champ_de_force); */
/* */
/* faite plus loin, et qui sinon, provoque sur 'SYSTEME_SG...' (par exemple) le message : */
/* */
/* unix: ALERT: ... - out of logical swap space during brk/sbrk ... */
/* */
/* dans '$Ferreurs'. Bien evidemment, le 'GET_ARGUMENTSv(...)' qui suit peut changer cela, */
/* et doit le faire lorsqu'un champ de force defini par plus d'une image est declare... */
/* Enfin, le 'SUCZ(...)' est destine a ce que l'axe 'OZ' ne soit pas reduit a une point... */
INITIALISATIONS_GENERALES;
/* Initialisations generales faites au tout debut... */
iTRANSFORMAT_31(liste_EVOLUTION_DE_G,EVOLUTION_DE_G_IMPLICITE);
/* Initialisation du fichier de modulation de 'G'. */
iTRANSFORMAT_31(liste_initiale_des_IDENTITE,vIDENTITE_IMPLICITE);
/* Initialisation des fichiers des identites avec une valeur "dynamique" (voir la */
/* definition speciale de 'vIDENTITE_IMPLICITE'). */
iTRANSFORMAT_31(liste_initiale_des_DATE_DE_NAISSANCE,DATE_DE_NAISSANCE_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_DATE_DE_MORT,DATE_DE_MORT_IMPLICITE);
/* Initialisation des fichiers de dates de naissance et de mort. */
iTRANSFORMAT_31(liste_initiale_des_X,X_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_Y,Y_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_Z,Z_IMPLICITE);
/* Initialisation des fichiers de listes de coordonnees. */
iTRANSFORMAT_31(liste_initiale_des_VX,VX_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_VY,VY_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_VZ,VZ_IMPLICITE);
/* Initialisation des fichiers de listes de vitesses implicites. */
iTRANSFORMAT_31(liste_initiale_des_MOBILITE,MOBILITE_IMPLICITE);
/* Initialisation du fichier de l'indicateur de mobilite des corps. */
iTRANSFORMAT_31(liste_initiale_des_COLLISIONNABLE,COLLISIONNABLE_IMPLICITE);
/* Initialisation du fichier de l'indicateur de collisionnabilite des corps. */
iTRANSFORMAT_31(liste_initiale_des_IMMOBILISABLE,IMMOBILISABLE_IMPLICITE);
/* Initialisation du fichier de l'indicateur d'immobilisabilite des corps. */
iTRANSFORMAT_31(liste_initiale_des_MINIMUM_DELTA_RHO,MINIMUM_DELTA_RHO_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_MAXIMUM_DELTA_RHO,MAXIMUM_DELTA_RHO_IMPLICITE);
/* Initialisation des fichiers de listes de variations des 'rho's. */
iTRANSFORMAT_31(liste_initiale_des_MINIMUM_N_PHI,MINIMUM_N_PHI_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_MAXIMUM_N_PHI,MAXIMUM_N_PHI_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_DELTA_PHI,DELTA_PHI_IMPLICITE);
/* Initialisation des fichiers de listes de variations des 'phi's (ou "longitude"). */
iTRANSFORMAT_31(liste_initiale_des_MINIMUM_N_THETA,MINIMUM_N_THETA_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_MAXIMUM_N_THETA,MAXIMUM_N_THETA_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_DELTA_THETA,DELTA_THETA_IMPLICITE);
/* Initialisation des fichiers de listes de variations des 'theta's (ou "distance polaire"). */
iTRANSFORMAT_31(liste_initiale_des_BORNE_INFERIEURE_DE_L_OUVERTURE,BORNE_INFERIEURE_DE_L_OUVERTURE_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_BORNE_SUPERIEURE_DE_L_OUVERTURE,BORNE_SUPERIEURE_DE_L_OUVERTURE_IMPLICITE);
/* Initialisation des fichiers des bornes inferieures et superieures des angles entre le */
/* vecteur vitesse perturbee et le gradient du champ de force. */
iTRANSFORMAT_31(liste_initiale_des_DISTANCE_MAXIMALE,DISTANCE_MAXIMALE_IMPLICITE);
/* Initialisation des fichiers de liste de distances maximales. */
iTRANSFORMAT_31(liste_initiale_des_STABILITE,STABILITE_IMPLICITE);
/* Initialisation des fichiers de liste de stabilite. */
iTRANSFORMAT_31(liste_initiale_des_RAYON,RAYON_IMPLICITE);
/* Initialisation du fichier de liste des rayons. */
iTRANSFORMAT_31(liste_initiale_des_RAYON_D_INTERACTION,RAYON_D_INTERACTION_IMPLICITE);
/* Initialisation du fichier de liste de rayon d'interaction (introduit le 19980115090818). */
iTRANSFORMAT_31(liste_initiale_des_ROUGE,ROUGE_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_VERTE,VERTE_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_BLEUE,BLEUE_IMPLICITE);
/* Initialisation des fichiers de listes de couleurs. */
iTRANSFORMAT_31(liste_initiale_des_MASSE,MASSE_IMPLICITE);
/* Initialisation du fichier de liste des masses. */
iTRANSFORMAT_31(liste_initiale_des_PONDERATION_DE_G,PONDERATION_DE_G_IMPLICITE);
/* Initialisation du fichier des ponderations de 'G'. */
iTRANSFORMAT_31(liste_initiale_des_CHARGE_A,CHARGE_A_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_CHARGE_R,CHARGE_R_IMPLICITE);
/* Initialisation des fichiers de liste des charges. */
iTRANSFORMAT_31(liste_initiale_des_COEFFICIENT_DE_RESTITUTION,COEFFICIENT_DE_RESTITUTION_IMPLICITE);
/* Initialisation du fichier de liste de taux de restitution. */
iTRANSFORMAT_31(liste_initiale_des_COALESCENCE,COALESCENCE_IMPLICITE);
/* Initialisation du fichier de liste de coalescence (introduit le 20211116115514). */
iTRANSFORMAT_31(liste_initiale_des_COLLAGE,COLLAGE_IMPLICITE);
/* Initialisation du fichier de liste de collage. */
iTRANSFORMAT_31(liste_initiale_des_CLEFS_DE_COLLAGE,CLEFS_DE_COLLAGE_IMPLICITE);
/* Initialisation du fichier de liste des clefs de collage. */
iTRANSFORMAT_31(liste_initiale_des_PROPAGATION_COULEURS,PROPAGATION_COULEURS_IMPLICITE);
/* Initialisation du fichier de propagation de couleurs. */
iTRANSFORMAT_31(liste_initiale_des_AUTORISATION_DE_MODIFICATION_COULEURS,AUTORISATION_DE_MODIFICATION_COULEURS_IMPLICITE);
/* Initialisation du fichier d'autorisation de modification des couleurs (introduit */
/* le 20200316093448). */
iTRANSFORMAT_31(liste_initiale_des_SOURCE_DU_POTENTIEL,SOURCE_DU_POTENTIEL_IMPLICITE);
/* Initialisation du fichier de liste des indicateurs de source gravitationnelle possible. */
iTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION,FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
,TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION_IMPLICITE
);
iTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION,FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
,TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION_IMPLICITE
);
/* Initialisation des facteurs et translations des vitesses "normales" et "tangentielles" */
/* apres refraction ou reflexion... */
iTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OX2_COLLISION,FACTEUR_VITESSE_OX2_COLLISION_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OX2_COLLISION
,TRANSLATION_VITESSE_OX2_COLLISION_IMPLICITE
);
iTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OY2_COLLISION,FACTEUR_VITESSE_OY2_COLLISION_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OY2_COLLISION
,TRANSLATION_VITESSE_OY2_COLLISION_IMPLICITE
);
iTRANSFORMAT_31(liste_initiale_des_FACTEUR_VITESSE_OZ2_COLLISION,FACTEUR_VITESSE_OZ2_COLLISION_IMPLICITE);
iTRANSFORMAT_31(liste_initiale_des_TRANSLATION_VITESSE_OZ2_COLLISION
,TRANSLATION_VITESSE_OZ2_COLLISION_IMPLICITE
);
/* Initialisation des facteurs et translations des vitesses apres une collision (ceci a */
/* ete ajoute le 19991110082506). */
iTRANSFORMAT_31(liste_initiale_des_PAS_DE_TEMPS,PAS_DE_TEMPS_IMPLICITE);
/* Initialisation du pas de temps variable (introduit le 20011022110739). */
iTRANSFORMAT_31(liste_initiale_des_NOMBRES,NOMBRES_IMPLICITE);
/* Initialisation du nombre variable (introduit le 20011022180148). Ceci a ete ajoute apres */
/* 'liste_initiale_des_PAS_DE_TEMPS' car, en effet, au debut de chaque nouvelle periode, il */
/* y a 'CALS(memorisation_d_un_point_grave(...))' qui prepare la prochaine image en generant */
/* la liste des points. Or, dans cette liste, c'est 'ACCES_COORDONNEES_CUMULEES(...)' qui */
/* est memorise ; or cela correspond en fait a 'ACCES_COORDONNEES_PRECEDENTES(...)', ce qui */
/* donne donc les coordonnees des points a la fin de la periode precedente, apres les */
/* 'nombre_de_pas_de_temps_par_periode' iterations. Dans le cas ou, par exemple, on choisit */
/* un pas de temps nul (dct=0), il faut alors faire 'nombre=0' afin de pas generer pour */
/* l'image suivante un "leger saut" correspondant au fait qu'ensuite les coordonnees ne */
/* vont plus evoluer. Ainsi, avec le fichier 'DCT' suivant : */
/* */
/* 0.10 */
/* 0.10 */
/* 0.10 */
/* 0.00 */
/* 0.00 */
/* 0.00 */
/* */
/* et la commande : */
/* */
/* $xrk/rdn_walk.52$X corps=1 np=16 nombre=5 \ */
/* dct_variable=VRAI DCT=... \ */
/* history=VRAI lister_les_points=VRAI \ */
/* */
/* on obtient le fichier de coordonnees suivants : */
/* */
/* periode=1 X=+0 Y=+0 Z=-1 */
/* periode=1 t=0.000000 corps=1 coordonnees={+0.000000,+0.000000,-1.000000} */
/* periode=1 t=0.100000 corps=1 coordonnees={+0.100000,+0.000000,-1.000000} */
/* periode=1 t=0.200000 corps=1 coordonnees={+0.200000,+0.000000,-1.000000} */
/* periode=1 t=0.300000 corps=1 coordonnees={+0.300000,+0.000000,-1.000000} */
/* periode=1 t=0.400000 corps=1 coordonnees={+0.400000,+0.000000,-1.000000} */
/* periode=1 t=0.500000 corps=1 coordonnees={+0.500000,+0.000000,-1.000000} */
/* */
/* periode=2 X=+0.5 Y=+0 Z=-1 */
/* periode=2 t=0.600000 corps=1 coordonnees={+0.600000,+0.000000,-1.000000} */
/* periode=2 t=0.700000 corps=1 coordonnees={+0.700000,+0.000000,-1.000000} */
/* periode=2 t=0.800000 corps=1 coordonnees={+0.800000,+0.000000,-1.000000} */
/* periode=2 t=0.900000 corps=1 coordonnees={+0.900000,+0.000000,-1.000000} */
/* periode=2 t=1.000000 corps=1 coordonnees={+1.000000,+0.000000,-1.000000} */
/* */
/* periode=3 X=+1.0 Y=+0 Z=-1 */
/* periode=3 t=1.100000 corps=1 coordonnees={+1.100000,+0.000000,-1.000000} */
/* periode=3 t=1.200000 corps=1 coordonnees={+1.200000,+0.000000,-1.000000} */
/* periode=3 t=1.300000 corps=1 coordonnees={+1.300000,+0.000000,-1.000000} */
/* periode=3 t=1.400000 corps=1 coordonnees={+1.400000,+0.000000,-1.000000} */
/* periode=3 t=1.500000 corps=1 coordonnees={+1.500000,+0.000000,-1.000000} */
/* */
/* (1) periode=4 X=+1.5 Y=+0 Z=-1 */
/* periode=4 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=4 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=4 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=4 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=4 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* */
/* (2) periode=5 X=+1.6 Y=+0 Z=-1 */
/* periode=5 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=5 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=5 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=5 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=5 t=1.600000 corps=1 coordonnees={+1.600000,+0.000000,-1.000000} */
/* periode=6 X=+1.6 Y=+0 Z=-1 */
/* (...) */
/* */
/* Ainsi, on voit que (1) a la periode 4, on a 'X=+1.5', et que (2) a la periode 5, on a */
/* 'X=+1.6' (alors que l'on s'attendrait a trouver 1.5) parce que la coordonnee precedente */
/* a progresse a 1.6 lors de la derniere iteration de la periode precedente... */
#include xrv/champs_5.1A.I"
GET_ARGUMENTSv(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20160610=",compatibilite_20160610);
/* Introduit le 20160610151209... */
PROCESS_ARGUMENT_I("nombre_points=""npoints=""iterations=""corps=",nombre_de_corps
/* Le 20111211100043, les parametres "nombre_points=""npoints=""iterations=" ont ete */
/* introduits par symetrie avec 'v $xrv/particule.10$K nombre_points= (par exemple...). */
,BLOC(VIDE;)
,BLOC(
Bblock
PRINT_AVERTISSEMENT("'corps=' doit etre defini avant tout fichier");
Test(IFGT(nombre_de_corps,NOMBRE_MAXIMAL_DE_POINTS_GERABLES))
Bblock
PRINT_ERREUR("le nombre de points a gerer est trop important");
PRINT_ERREUR("il va donc etre seuille");
CAL1(Prer2("Il vaut %d alors que le maximum est de %d\n"
,nombre_de_corps
,NOMBRE_MAXIMAL_DE_POINTS_GERABLES
)
);
EGAL(nombre_de_corps,NOMBRE_MAXIMAL_DE_POINTS_GERABLES);
/* Et on seuille le nombre de points... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
)
);
/* ATTENTION : la recuperation de 'nombre_de_corps' doit preceder les */
/* 'PROCESS_ARGUMENT_C(...)' qui suivent car ils l'utilisent. */
PROCESS_ARGUMENTS_GEOMETRIQUES;
PROCESS_ARGUMENT_FICHIER("LISTE_EVOLUTION_G="
,fichier_EVOLUTION_DE_G
,liste_EVOLUTION_DE_G
,EVOLUTION_DE_G_IMPLICITE
,gTRANSFORMAT_31
);
PROCESS_ARGUMENT_C("LISTE_IDENTITE=",fichier_LISTE_IDENTITE
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_IDENTITE
,liste_initiale_des_IDENTITE
,IDENTITE_IMPLICITE
);
/* ATTENTION : ici on ne peut utiliser 'vIDENTITE_IMPLICITE' (ce qui serait plus logique) */
/* a cause de 'Fload_fichier_formatte_Float(...)' qui recoit 'IDENTITE_IMPLICITE' comme */
/* argument a un moment ou evidemment 'vIDENTITE_IMPLICITE' (c'est-a-dire 'index') n'est */
/* pas defini... */
)
);
PROCESS_ARGUMENT_FICHIER("LISTE_DATE_DE_NAISSANCE="
,fichier_LISTE_DATE_DE_NAISSANCE
,liste_initiale_des_DATE_DE_NAISSANCE
,DATE_DE_NAISSANCE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_DATE_DE_MORT="
,fichier_LISTE_DATE_DE_MORT
,liste_initiale_des_DATE_DE_MORT
,DATE_DE_MORT_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_X="
,fichier_LISTE_X
,liste_initiale_des_X
,X_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_Y="
,fichier_LISTE_Y
,liste_initiale_des_Y
,Y_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_Z="
,fichier_LISTE_Z
,liste_initiale_des_Z
,Z_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_VX="
,fichier_LISTE_VX
,liste_initiale_des_VX
,VX_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_VY="
,fichier_LISTE_VY
,liste_initiale_des_VY
,VY_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_VZ="
,fichier_LISTE_VZ
,liste_initiale_des_VZ
,VZ_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MOBILITE="
,fichier_LISTE_MOBILITE
,liste_initiale_des_MOBILITE
,MOBILITE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_COLLISIONNABLE="
,fichier_LISTE_COLLISIONNABLE
,liste_initiale_des_COLLISIONNABLE
,COLLISIONNABLE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_IMMOBILISABLE="
,fichier_LISTE_IMMOBILISABLE
,liste_initiale_des_IMMOBILISABLE
,IMMOBILISABLE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MINIMUM_DELTA_RHO="
,fichier_LISTE_MINIMUM_DELTA_RHO
,liste_initiale_des_MINIMUM_DELTA_RHO
,MINIMUM_DELTA_RHO_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MAXIMUM_DELTA_RHO="
,fichier_LISTE_MAXIMUM_DELTA_RHO
,liste_initiale_des_MAXIMUM_DELTA_RHO
,MAXIMUM_DELTA_RHO_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MINIMUM_N_PHI="
,fichier_LISTE_MINIMUM_N_PHI
,liste_initiale_des_MINIMUM_N_PHI
,MINIMUM_N_PHI_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MAXIMUM_N_PHI="
,fichier_LISTE_MAXIMUM_N_PHI
,liste_initiale_des_MAXIMUM_N_PHI
,MAXIMUM_N_PHI_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_DELTA_PHI="
,fichier_LISTE_DELTA_PHI
,liste_initiale_des_DELTA_PHI
,DELTA_PHI_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MINIMUM_N_THETA="
,fichier_LISTE_MINIMUM_N_THETA
,liste_initiale_des_MINIMUM_N_THETA
,MINIMUM_N_THETA_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MAXIMUM_N_THETA="
,fichier_LISTE_MAXIMUM_N_THETA
,liste_initiale_des_MAXIMUM_N_THETA
,MAXIMUM_N_THETA_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_DELTA_THETA="
,fichier_LISTE_DELTA_THETA
,liste_initiale_des_DELTA_THETA
,DELTA_THETA_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_BORNE_INFERIEURE_DE_L_OUVERTURE="
,fichier_LISTE_BORNE_INFERIEURE_DE_L_OUVERTURE
,liste_initiale_des_BORNE_INFERIEURE_DE_L_OUVERTURE
,BORNE_INFERIEURE_DE_L_OUVERTURE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_BORNE_SUPERIEURE_DE_L_OUVERTURE="
,fichier_LISTE_BORNE_SUPERIEURE_DE_L_OUVERTURE
,liste_initiale_des_BORNE_SUPERIEURE_DE_L_OUVERTURE
,BORNE_SUPERIEURE_DE_L_OUVERTURE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_DISTANCE_MAXIMALE="
,fichier_LISTE_DISTANCE_MAXIMALE
,liste_initiale_des_DISTANCE_MAXIMALE
,DISTANCE_MAXIMALE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_STABILITE="
,fichier_LISTE_STABILITE
,liste_initiale_des_STABILITE
,STABILITE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_RAYON="
,fichier_LISTE_RAYON
,liste_initiale_des_RAYON
,RAYON_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_RAYON_D_INTERACTION="
,fichier_LISTE_RAYON_D_INTERACTION
,liste_initiale_des_RAYON_D_INTERACTION
,RAYON_D_INTERACTION_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_ROUGE="
,fichier_LISTE_ROUGE
,liste_initiale_des_ROUGE
,ROUGE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_VERTE="
,fichier_LISTE_VERTE
,liste_initiale_des_VERTE
,VERTE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_BLEUE="
,fichier_LISTE_BLEUE
,liste_initiale_des_BLEUE
,BLEUE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_MASSE="
,fichier_LISTE_MASSE
,liste_initiale_des_MASSE
,MASSE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_COEFFICIENT_DE_RESTITUTION="
,fichier_LISTE_COEFFICIENT_DE_RESTITUTION
,liste_initiale_des_COEFFICIENT_DE_RESTITUTION
,COEFFICIENT_DE_RESTITUTION_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_COALESCENCE="
,fichier_LISTE_COALESCENCE
,liste_initiale_des_COALESCENCE
,COALESCENCE_IMPLICITE
,lTRANSFORMAT_11
);
/* Argument introduit le 20211116115514... */
PROCESS_ARGUMENT_FICHIER("LISTE_COLLAGE="
,fichier_LISTE_COLLAGE
,liste_initiale_des_COLLAGE
,COLLAGE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_CLEFS_DE_COLLAGE="
,fichier_LISTE_CLEFS_DE_COLLAGE
,liste_initiale_des_CLEFS_DE_COLLAGE
,CLEFS_DE_COLLAGE_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_PROPAGATION_COULEURS="
,fichier_LISTE_PROPAGATION_COULEURS
,liste_initiale_des_PROPAGATION_COULEURS
,PROPAGATION_COULEURS_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_AUTORISATION_DE_MODIFICATION_COULEURS="
,fichier_LISTE_AUTORISATION_DE_MODIFICATION_COULEURS
,liste_initiale_des_AUTORISATION_DE_MODIFICATION_COULEURS
,AUTORISATION_DE_MODIFICATION_COULEURS_IMPLICITE
,lTRANSFORMAT_11
);
/* Argument introduit le 20200316093448... */
PROCESS_ARGUMENT_FICHIER("LISTE_PONDERATION_G="
,fichier_LISTE_PONDERATION_DE_G
,liste_initiale_des_PONDERATION_DE_G
,PONDERATION_DE_G_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_CHARGE_A="
,fichier_LISTE_CHARGE_A
,liste_initiale_des_CHARGE_A
,CHARGE_A_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_CHARGE_R="
,fichier_LISTE_CHARGE_R
,liste_initiale_des_CHARGE_R
,CHARGE_R_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_FICHIER("LISTE_SOURCE="
,fichier_LISTE_SOURCE_DU_POTENTIEL
,liste_initiale_des_SOURCE_DU_POTENTIEL
,SOURCE_DU_POTENTIEL_IMPLICITE
,lTRANSFORMAT_11
);
PROCESS_ARGUMENT_C("LISTE_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION="
,fichier_LISTE_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION
,liste_initiale_des_FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION
,FACTEUR_VITESSE_OX2_REFRACTION_REFLEXION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION="
,fichier_LISTE_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
,liste_initiale_des_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION
,TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION="
,fichier_LISTE_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION
,liste_initiale_des_FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION
,FACTEUR_VITESSE_OZ2_REFRACTION_REFLEXION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION="
,fichier_LISTE_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
,liste_initiale_des_TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION
,TRANSLATION_VITESSE_OZ2_REFRACTION_REFLEXION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_FACTEUR_VITESSE_OX2_COLLISION="
,fichier_LISTE_FACTEUR_VITESSE_OX2_COLLISION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_FACTEUR_VITESSE_OX2_COLLISION
,liste_initiale_des_FACTEUR_VITESSE_OX2_COLLISION
,FACTEUR_VITESSE_OX2_COLLISION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_TRANSLATION_VITESSE_OX2_COLLISION="
,fichier_LISTE_TRANSLATION_VITESSE_OX2_COLLISION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_TRANSLATION_VITESSE_OX2_COLLISION
,liste_initiale_des_TRANSLATION_VITESSE_OX2_COLLISION
,TRANSLATION_VITESSE_OX2_COLLISION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_FACTEUR_VITESSE_OY2_COLLISION="
,fichier_LISTE_FACTEUR_VITESSE_OY2_COLLISION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_FACTEUR_VITESSE_OY2_COLLISION
,liste_initiale_des_FACTEUR_VITESSE_OY2_COLLISION
,FACTEUR_VITESSE_OY2_COLLISION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_TRANSLATION_VITESSE_OY2_COLLISION="
,fichier_LISTE_TRANSLATION_VITESSE_OY2_COLLISION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_TRANSLATION_VITESSE_OY2_COLLISION
,liste_initiale_des_TRANSLATION_VITESSE_OY2_COLLISION
,TRANSLATION_VITESSE_OY2_COLLISION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_FACTEUR_VITESSE_OZ2_COLLISION="
,fichier_LISTE_FACTEUR_VITESSE_OZ2_COLLISION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_FACTEUR_VITESSE_OZ2_COLLISION
,liste_initiale_des_FACTEUR_VITESSE_OZ2_COLLISION
,FACTEUR_VITESSE_OZ2_COLLISION_IMPLICITE
);
)
);
PROCESS_ARGUMENT_C("LISTE_TRANSLATION_VITESSE_OZ2_COLLISION="
,fichier_LISTE_TRANSLATION_VITESSE_OZ2_COLLISION
,BLOC(VIDE;)
,BLOC(lTRANSFORMAT_11(fichier_LISTE_TRANSLATION_VITESSE_OZ2_COLLISION
,liste_initiale_des_TRANSLATION_VITESSE_OZ2_COLLISION
,TRANSLATION_VITESSE_OZ2_COLLISION_IMPLICITE
);
)
);
GET_ARGUMENT_L("inverser=",inverser_le_processus);
GET_ARGUMENT_I("periode_d_inversion=",periode_d_inversion_du_processus);
GET_ARGUMENT_I("graine=""g=",graine_du_generateur_d_evenements);
GET_ARGUMENT_L("affiner_rdn=",rdnIFnD_____affiner_la_generation);
GET_ARGUMENT_L("iterer_rdn=",rdnIFnD_____iterer_la_generation);
GET_ARGUMENT_L("automatique=",limiter_automatiquement_tentatives_recherche_bonne_perturbation);
GET_ARGUMENT_I("tentatives=",nombre_maximal_de_tentatives_de_recherche_d_une_bonne_perturbation);
GET_ARGUMENT_L("chronometrer=",chronometrer_la_simulation);
GET_ARGUMENT_L("history=""editer_evenements=",editer_les_evenements);
GET_ARGUMENT_L("editer_collisions=",editer_les_compteurs_de_collisions);
GET_ARGUMENT_L("periodiser_X=",periodiser_l_univers_X);
GET_ARGUMENT_L("periodiser_Y=",periodiser_l_univers_Y);
GET_ARGUMENT_L("periodiser_Z=",periodiser_l_univers_Z);
GET_ARGUMENT_L("symetrie_centrale=",periodiser_l_univers_par_symetrie_centrale);
GET_ARGUMENT_L("force=",utiliser_un_champ_de_force);
GET_ARGUMENT_L("adapter_F_nPAS=",adapter_les_F_nPAS);
GET_ARGUMENT_I("FNpasX=",F_NpasX);
GET_ARGUMENT_I("FNpasY=",F_NpasY);
GET_ARGUMENT_I("FNpasZ=",F_NpasZ);
GET_ARGUMENT_L("Fattendre=",F_attendre_les_images_inexistantes);
GET_ARGUMENT_L("Fincomplet=",F_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM);
GET_ARGUMENT_C("imageFC=""FC=",nom_du_champ_de_forceA);
GET_ARGUMENT_C("Fpostfixe=",F_nom_postfixe);
GET_ARGUMENT_I("Fpremiere=",F_premiere_coupe);
GET_ARGUMENT_I("Fpas=",F_pas_des_coupes);
GET_ARGUMENT_I("FChiffres=",F_nombre_de_chiffres_pour_le_champ);
GET_ARGUMENT_L("Fperiodiser_X=",F_periodiser_X);
GET_ARGUMENT_L("Fperiodiser_Y=",F_periodiser_Y);
GET_ARGUMENT_L("Fperiodiser_Z=",F_periodiser_Z);
GET_ARGUMENT_L("Fsymetriser_X=",F_symetriser_X);
GET_ARGUMENT_L("Fsymetriser_Y=",F_symetriser_Y);
GET_ARGUMENT_L("Fsymetriser_Z=",F_symetriser_Z);
GET_ARGUMENT_L("Fprolonger_X=",F_prolonger_X);
GET_ARGUMENT_L("Fprolonger_Y=",F_prolonger_Y);
GET_ARGUMENT_L("Fprolonger_Z=",F_prolonger_Z);
GET_ARGUMENT_P("Fniveau_hors_du_champ_de_force=""Fhors=",F_niveau_hors_du_champ_de_force);
GET_ARGUMENT_P("Fniveau_initial_du_champ_de_force=""Finitial=",F_niveau_initial_du_champ_de_force);
GET_ARGUMENT_L("FCinverser=",F_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM);
/* Le 20050623102248 "Finverser=" a ete remplace par "FCinverser=" a cause de sa double */
/* definition ('v $xrv/champs_5.1A$I "Finverser="'). */
GET_ARGUMENT_L("premiere_direction=",prendre_la_premiere_direction_trouvee);
GET_ARGUMENT_I("selecteur=",nombre_d_iterations_si_on_ne_prend_pas_la_premiere_direction_trouvee);
GET_ARGUMENT_L("propagation=""milieu=",utiliser_un_milieu_de_propagation);
GET_ARGUMENT_L("milieu_dynamique=",utiliser_un_milieu_de_propagation_dynamique);
GET_ARGUMENT_L("details_fins=",tester_les_details_fins);
GET_ARGUMENT_L("reflexion=",il_peut_y_avoir_reflexion);
GET_ARGUMENT_L("refraction=",il_peut_y_avoir_refraction);
GET_ARGUMENT_F("angle_inferieur_de_reflexion=",angle_inferieur_du_cone_de_reflexion);
GET_ARGUMENT_F("angle_superieur_de_reflexion=",angle_superieur_du_cone_de_reflexion);
GET_ARGUMENT_L("moduler_vitesse=",moduler_la_vitesse_lors_d_une_refraction);
GET_ARGUMENT_F("AvitesseN=",facteur_vitesse_OX2_refraction_reflexion);
GET_ARGUMENT_F("BvitesseN=",translation_vitesse_OX2_refraction_reflexion);
GET_ARGUMENT_F("AvitesseT=",facteur_vitesse_OZ2_refraction_reflexion);
GET_ARGUMENT_F("BvitesseT=",translation_vitesse_OZ2_refraction_reflexion);
GET_ARGUMENT_L("moyenne_gradient=",calculer_la_moyenne_des_Mgradient_3x3x3_tri_dimensionnel);
GET_ARGUMENT_F("seuil_gradientX=",seuil_de_Mgradient_local_tri_dimensionnel_X);
GET_ARGUMENT_F("seuil_gradientY=",seuil_de_Mgradient_local_tri_dimensionnel_Y);
GET_ARGUMENT_F("seuil_gradientZ=",seuil_de_Mgradient_local_tri_dimensionnel_Z);
GET_ARGUMENT_L("M_gradient_par_defaut=",arrondir_par_defaut_les_coordonnees_du_M_gradient);
GET_ARGUMENT_L("affiner_M_maillage=",affiner_le_maillage_de_calcul_du_M_gradient);
GET_ARGUMENT_L("Msimplifier=",calculer_un_M_gradient_tridimensionnel_simplifie);
GET_ARGUMENT_L("Mfiltrer=",M_gradient_tridimensionnel_non_simplifie_filtrer);
/* Le 20220621132616, je note que cet indicateur qui est 'VRAI' par defaut (voir a ce */
/* propos 'use $xrk/rdn_walk.52$X Mfiltrer') cree des problemes lorsque le milieu de */
/* propagation n'est pas fait qu'avec des horizontales et des verticales (cas en fait */
/* le plus frequent). Cela s'est vu avec 'v $xiak/$Fnota Debut_listG_REFN_D5' or par */
/* defaut cet indicateur n'etait pas repositionne : il etait donc VRAI et les limites du */
/* milieu etant principalement circulaires, cela provoquait le depart a l'infini de */
/* quelques particules... */
GIT_ARGUMENT_F("Mtolerance="
,M_gradient_tridimensionnel_non_simplifie_tolerance
,M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_TOLERANCE
);
/* Le 20091023085850, le 'GET_ARGUMENT_F(...)' a ete remplace par 'GIT_ARGUMENT_F(...)' */
/* a cause de 'v $xrk/rdn_walk.52$K 20091023085850'. ATTENTION : l'usage eventuel de */
/* l'argument "AXE_NIVEAUX_OUVERT_FERME_____compatibilite_19951221=" doit donc alors */
/* PRECEDER un eventuel "Mtolerance="... */
GET_ARGUMENT_L("Mspherique=",M_gradient_tridimensionnel_non_simplifie_spherique);
GET_ARGUMENT_L("Mponderer=",ponderer_un_M_gradient_tridimensionnel_non_simplifie);
GET_ARGUMENT_L("adapter_M_nPAS=",adapter_les_M_nPAS);
GET_ARGUMENT_F("MNpasX=",fM_NpasX);
GET_ARGUMENT_F("MNpasY=",fM_NpasY);
GET_ARGUMENT_F("MNpasZ=",fM_NpasZ);
GET_ARGUMENT_L("M_encombrement=",prendre_en_compte_M_l_encombrement_des_particules);
GET_ARGUMENT_L("messages_erreur_gradient=""meg=",editer_les_messages_d_erreur_du_calcul_du_gradient);
/* Introduit le 20150208081236... */
GET_ARGUMENT_L("Mattendre=",M_attendre_les_images_inexistantes);
GET_ARGUMENT_L("Mincomplet=",M_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM);
GET_ARGUMENT_C("imageMC=""MC=",nom_du_milieu_de_propagationA);
GET_ARGUMENT_C("Mpostfixe=",M_nom_postfixe);
GET_ARGUMENT_I("Mpremiere=",M_premiere_coupe);
GET_ARGUMENT_I("Mpas=",M_pas_des_coupes);
GET_ARGUMENT_I("MChiffres=",M_nombre_de_chiffres_pour_le_milieu);
GET_ARGUMENT_I("MDChiffres=",M_nombre_de_chiffres_pour_le_milieu_dynamique);
GET_ARGUMENT_L("Mperiodiser_X=",M_periodiser_X);
GET_ARGUMENT_L("Mperiodiser_Y=",M_periodiser_Y);
GET_ARGUMENT_L("Mperiodiser_Z=",M_periodiser_Z);
GET_ARGUMENT_L("Msymetriser_X=",M_symetriser_X);
GET_ARGUMENT_L("Msymetriser_Y=",M_symetriser_Y);
GET_ARGUMENT_L("Msymetriser_Z=",M_symetriser_Z);
GET_ARGUMENT_L("Mprolonger_X=",M_prolonger_X);
GET_ARGUMENT_L("Mprolonger_Y=",M_prolonger_Y);
GET_ARGUMENT_L("Mprolonger_Z=",M_prolonger_Z);
GET_ARGUMENT_P("Mniveau_hors_du_milieu_de_propagation=""Mhors=",M_niveau_hors_du_milieu_de_propagation);
GET_ARGUMENT_P("Mniveau_initial_du_milieu_de_propagation=""Minitial="
,M_niveau_initial_du_milieu_de_propagation
);
GET_ARGUMENT_L("Minverser=",M_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM);
GET_ARGUMENT_L("synchroniser_immobilisations_naissances=""sin="
,tenter_de_synchroniser_les_immobilisations_sur_les_naissances
);
GET_ARGUMENT_F("Fsynchronisation_immobilisations_naissances=""Fsin="
,facteur_synchronisation_des_immobilisations_sur_les_naissances
);
GET_ARGUMENT_L("tuer=""mort_immobilisable=",faire_mourir_les_particules_immobilisables);
GET_ARGUMENT_L("geometrie=",generer_la_geometrie_du_milieu_de_propagation);
GET_ARGUMENT_C("imageGM=""GM=",nom_de_la_geometrie_du_milieu_de_propagation);
GET_ARGUMENT_F("interaction=",seuil_d_interaction);
GET_ARGUMENT_L("collisions=",gerer_les_collisions);
GET_ARGUMENT_L("pseudo_collisions=",les_collisions_sont_en_fait_des_pseudo_collisions);
/* Introduit le 20220812142408... */
GET_ARGUMENT_L("collisions_N_au_carre=",detecter_les_collisions_VERSION_N_AU_CARRE);
GET_ARGUMENT_L("collision_deux_corps=""collision2=",une_collision_necessite_deux_corps_collisionnables);
GET_ARGUMENT_L("ponctuels=""chocs_ponctuels=",considerer_les_chocs_ponctuels);
GET_ARGUMENT_F("facteur_d_interaction=",facteur_des_rayon_d_interaction);
GET_ARGUMENT_F("restitution=""elasticite=",coefficient_de_restitution);
GET_ARGUMENT_F("restitution_MIN3=",ponderation_MIN3_coefficient_de_restitution);
GET_ARGUMENT_F("restitution_MOY3=",ponderation_MOY3_coefficient_de_restitution);
GET_ARGUMENT_F("restitution_MAX3=",ponderation_MAX3_coefficient_de_restitution);
GET_ARGUMENT_L("DLA=",generer_des_DiffusionLimitedAggregation);
GET_ARGUMENT_L("probabilite=",utiliser_un_champ_de_probabilite);
GET_ARGUMENT_L("Pattendre=",P_attendre_les_images_inexistantes);
GET_ARGUMENT_L("Pincomplet=",P_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM);
GET_ARGUMENT_C("imagePC=""PC=",nom_du_champ_de_probabiliteA);
GET_ARGUMENT_C("Ppostfixe=",P_nom_postfixe);
GET_ARGUMENT_I("Ppremiere=",P_premiere_coupe);
GET_ARGUMENT_I("Ppas=",P_pas_des_coupes);
GET_ARGUMENT_I("PChiffres=",P_nombre_de_chiffres_pour_le_champ);
GET_ARGUMENT_L("Pperiodiser_X=",P_periodiser_X);
GET_ARGUMENT_L("Pperiodiser_Y=",P_periodiser_Y);
GET_ARGUMENT_L("Pperiodiser_Z=",P_periodiser_Z);
GET_ARGUMENT_L("Psymetriser_X=",P_symetriser_X);
GET_ARGUMENT_L("Psymetriser_Y=",P_symetriser_Y);
GET_ARGUMENT_L("Psymetriser_Z=",P_symetriser_Z);
GET_ARGUMENT_L("Pprolonger_X=",P_prolonger_X);
GET_ARGUMENT_L("Pprolonger_Y=",P_prolonger_Y);
GET_ARGUMENT_L("Pprolonger_Z=",P_prolonger_Z);
GET_ARGUMENT_P("Pniveau_hors_du_champ_de_probabilite=""Phors=",P_niveau_hors_du_champ_de_probabilite);
GET_ARGUMENT_P("Pniveau_initial_du_champ_de_probabilite=""Pinitial="
,P_niveau_initial_du_champ_de_probabilite
);
GET_ARGUMENT_L("Pinverser=",P_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM);
GET_ARGUMENT_L("gravitation_centrale=""GC=",le_champ_de_gravitation_est_central);
GET_ARGUMENT_F("IGC=",intensite_du_champ_de_gravitation_central);
GET_ARGUMENT_L("gravitation_centrale_dynamique=""GCD=",le_champ_de_gravitation_est_central_et_dynamique);
GET_ARGUMENT_F("CGCX=",centre_du_champ_de_gravitation_central_X);
GET_ARGUMENT_F("CGCY=",centre_du_champ_de_gravitation_central_Y);
GET_ARGUMENT_F("CGCZ=",centre_du_champ_de_gravitation_central_Z);
GET_ARGUMENT_I("CGCD=",corps_centre_de_gravitation_dynamique);
GET_ARGUMENT_F("GX=",acceleration_du_champ_de_gravitation_X);
GET_ARGUMENT_F("GY=",acceleration_du_champ_de_gravitation_Y);
GET_ARGUMENT_F("GZ=",acceleration_du_champ_de_gravitation_Z);
GET_ARGUMENT_L("gravitation=""forces_A_R=",faire_de_l_interaction_gravitationnelle_generalisee);
GET_ARGUMENT_L("collisions_gravitation=""collisions_forces_A_R="
,gerer_les_collisions_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_F("constante_gravitation=""constante_forces_A_R=""G="
,constante_de_la_gravitation_generalisee
);
GET_ARGUMENT_F("Afacteur_gravitation=""Afacteur_forces_A_R="
,facteur_A_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_F("Aexposant_gravitation=""Aexposant_forces_A_R="
,exposant_A_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_F("Rfacteur_gravitation=""Rfacteur_forces_A_R="
,facteur_R_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_F("Rexposant_gravitation=""Rexposant_forces_A_R="
,exposant_R_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_F("Atranslation_gravitation=""Atranslation_forces_A_R="
,translation_A_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_F("Rtranslation_gravitation=""Rtranslation_forces_A_R="
,translation_R_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_L("2_a_2=",toutes_les_interactions_2_a_2_sont_prises_en_compte);
GET_ARGUMENT_I("source=",corps_source_du_potentiel);
GET_ARGUMENT_L("coalescence=",proceder_a_la_coalescence_des_corps_lors_des_collisions);
/* Introduit le 20211116120738... */
GET_ARGUMENT_L("moyenner_vitesses=",moyenner_les_vitesses_par_famille);
GET_ARGUMENT_L("familles_dynamiques=",gerer_dynamiquement_les_familles);
GET_ARGUMENT_L("propager_couleurs=",propager_les_couleurs);
GET_ARGUMENT_L("synchroniser_vitesses=",synchroniser_les_vitesses);
/* Introduit le 20060705114014... */
GET_ARGUMENT_L("dct_variable=",utiliser_un_pas_de_temps_variable);
PROCESS_ARGUMENT_FICHIER("DCT="
,fichier_LISTE_PAS_DE_TEMPS
,liste_initiale_des_PAS_DE_TEMPS
,PAS_DE_TEMPS_IMPLICITE
,gTRANSFORMAT_31
);
GET_ARGUMENT_F("dt=""dct=",dct);
PROCESS_ARGUMENT_FICHIER("NOMBRE="
,fichier_LISTE_NOMBRES
,liste_initiale_des_NOMBRES
,NOMBRES_IMPLICITE
,gTRANSFORMAT_31
);
GET_ARGUMENT_I("periodes=",nombre_de_periodes_par_image);
GET_ARGUMENT_I("nombre=",nombre_de_pas_de_temps_par_periode);
GET_ARGUMENT_I("ordre=""methode=""integration=",ordre_de_la_methode_d_integration);
/* Les synonymes de "ordre=", ont ete introduits le 20060608151541... */
PROCESS_ARGUMENTS_DE_VISUALISATION;
GET_ARGUMENT_F("mv_ROUGE=""module_vitesse_ROUGE=",facteur_du_module_de_la_vitesse_pour_le_ROUGE);
GET_ARGUMENT_F("mv_VERTE=""module_vitesse_VERTE=",facteur_du_module_de_la_vitesse_pour_le_VERTE);
GET_ARGUMENT_F("mv_BLEUE=""module_vitesse_BLEUE=",facteur_du_module_de_la_vitesse_pour_le_BLEUE);
GET_ARGUMENT_F("mv_RAYON=""module_vitesse_RAYON=",facteur_du_module_de_la_vitesse_pour_le_RAYON);
PROCESS_ARGUMENTS_DE_VISUALISATION_DES_AXES_DE_COORDONNEES;
GET_ARGUMENT_L("ensemble=",visualiser_l_ensemble_des_instants);
GET_ARGUMENT_L("centrer=",definir_la_scene_par_rapport_au_centre_de_l_espace);
GET_ARGUMENT_F("Xcentre=",X_centre_de_l_espace_pour_la_visualisation);
GET_ARGUMENT_F("Ycentre=",Y_centre_de_l_espace_pour_la_visualisation);
GET_ARGUMENT_F("Zcentre=",Z_centre_de_l_espace_pour_la_visualisation);
GET_ARGUMENT_I("reference=",corps_de_reference);
GET_ARGUMENT_L("derniere_position=",se_referer_a_la_derniere_position_du_corps_de_reference);
GET_ARGUMENT_L("trainees=",generer_les_trainees);
GET_ARGUMENT_L("renormaliser=",renormaliser_les_trainees);
GET_ARGUMENT_I("mode_des_trainees=""mode=",mode_de_generation_des_trainees);
GET_ARGUMENT_F("attenuation_des_trainees=",facteur_d_attenuation_des_trainees);
GET_ARGUMENT_F("attenuation_des_images=",facteur_d_attenuation_des_images);
)
);
#include xrv/champs_5.19.I"
/* Pour eviter le message : */
/* */
/* Static function is not referenced. */
/* */
/* sur 'SYSTEME_ES9000_AIX_CC'... */
#include xrk/attractor.19.I"
/* Validations et definition de l'espace physique. */
INITIALISATION_DE_LA_SYNTHESE_D_IMAGE;
/* Initialisation eventuelle du calcul des trainees... */
Test(IL_FAUT(moyenner_les_vitesses_par_famille))
Bblock
Komp(corps,nombre_de_corps)
Bblock
EGAL(premiere_famille,MIN2(premiere_famille,ACCES_IDENTITES(corps)));
EGAL(derniere_famille,MAX2(derniere_famille,ACCES_IDENTITES(corps)));
/* Recherche de la premiere et de la derniere famille. */
Eblock
EKom
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(I3OU(IL_FAUT(periodiser_l_univers_X)
,IL_FAUT(periodiser_l_univers_Y)
,IL_FAUT(periodiser_l_univers_Z)
)
,I3OU(IFNE(ABSO(ASD2(espace_physique,origine,x)),ABSO(ASD2(espace_physique,extremite,x)))
,IFNE(ABSO(ASD2(espace_physique,origine,y)),ABSO(ASD2(espace_physique,extremite,y)))
,IFNE(ABSO(ASD2(espace_physique,origine,z)),ABSO(ASD2(espace_physique,extremite,z)))
)
)
)
Bblock
PRINT_ATTENTION("la periodisation de l'univers est incorrecte car le centre de l'univers n'est pas reellement au centre");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(utiliser_un_milieu_de_propagation)
,IFET(EST_VRAI(il_peut_y_avoir_reflexion)
,EST_VRAI(il_peut_y_avoir_refraction)
)
)
)
Bblock
PRINT_ATTENTION("dans l'etat actuel, il est peu sage d'utiliser l'option 'refraction' avec l'option 'reflexion'");
/* En effet, lorsqu'une particule se deplace, une configuration de points situes devant */
/* celle-ci qui correspondrait a une reflexion, donnerait une refraction une fois qu'elle */
/* aurait ete depassee par la particule (et donc situee derriere elle). On peut ainsi */
/* provoquer de fausses refractions... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(gerer_les_collisions)
,IL_FAUT(generer_des_DiffusionLimitedAggregation)
)
)
Bblock
PRINT_ATTENTION("les options 'collisions' et 'DLA' sont relativement incompatibles");
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(synchroniser_les_vitesses)
,IL_NE_FAUT_PAS(detecter_les_collisions_VERSION_N_AU_CARRE)
)
)
Bblock
PRINT_ATTENTION("les options 'synchroniser_vitesses=' et 'collisions_N_au_carre=' ne sont pas utilisees correctement");
CAL1(Prer2("(l'utilisation de 'synchroniser_vitesses=%s' necessite 'collisions_N_au_carre=%s')\n"
,C_VRAI____
,C_VRAI____
)
);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_NE_FAUT_PAS(definir_la_scene_par_rapport_au_centre_de_l_espace)
,NINCff(corps_de_reference,PREMIER_POINT_DES_LISTES,nombre_de_corps)
)
)
Bblock
PRINT_ATTENTION("le corps de reference demande n'existe pas, on lui substitue la valeur par defaut");
EGAL(corps_de_reference,CORPS_DE_REFERENCE);
Eblock
ATes
Bblock
Eblock
ETes
Test(I3ET(EST_VRAI(le_champ_de_gravitation_est_central)
,EST_VRAI(le_champ_de_gravitation_est_central_et_dynamique)
,NINCff(corps_centre_de_gravitation_dynamique,PREMIER_POINT_DES_LISTES,nombre_de_corps)
)
)
Bblock
PRINT_ATTENTION("le corps 'centre de gravitation' demande n'existe pas, on lui substitue la valeur par defaut");
EGAL(corps_centre_de_gravitation_dynamique,CORPS_CENTRE_DE_GRAVITATION_DYNAMIQUE);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(affiner_le_maillage_de_calcul_du_M_gradient)
,IL_FAUT(adapter_les_M_nPAS)
)
)
Bblock
PRINT_ATTENTION("les options 'affiner_M_maillage' et 'adapter_M_nPAS' sont relativement incompatibles");
/* En effet, lorsque 'IL_FAUT(adapter_les_M_nPAS)' les 'delta_?_anticipe' sont apres */
/* calcul divises par 2. Si ensuite 'IL_FAUT(affiner_le_maillage_de_calcul_du_M_gradient)' */
/* le balayage de calcul du gradient est alors 2 fois trop petit... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(affiner_le_maillage_de_calcul_du_M_gradient)
,IL_NE_FAUT_PAS(calculer_un_M_gradient_tridimensionnel_simplifie)
)
)
Bblock
PRINT_ATTENTION("les options 'affiner_M_maillage' et 'Msimplifier' sont incompatibles");
Eblock
ATes
Bblock
Eblock
ETes
MdTb1(liste_des_dates_de_naissance
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_dates_de_mort
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_coordonnees_a_l_instant_initial
,nombre_de_corps
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_vitesses_a_l_instant_initial
,nombre_de_corps
,deltaF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Definition de l'instant initial. */
MdTb1(liste_des_coordonnees_a_l_instant_precedent
,nombre_de_corps
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
Test(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
/* Cette optimisation a ete introduite le 20010904102731 car, en effet, lorsque le */
/* parametre 'nombre_de_corps' est un peu grand, l'espace memoire necessaire a cette */
/* matrice ('matrice_des_distances_a_l_instant_precedent') peut depasser les limites */
/* physiques de la MACHINE utilisee. Or cette matrice n'est que rarement utile... De */
/* plus on notera que lorsqu'elle est necessaire, le parametre 'nombre_de_corps' ne */
/* doit pas etre trop important car sinon, le temps de calcul peut etre redhibitoire */
/* (a cause du calcul des interactions gravitationnelles deux a deux...). */
Bblock
MdTb2(matrice_des_distances_a_l_instant_precedent
,nombre_de_corps
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
Eblock
ATes
Bblock
Eblock
ETes
/* Definition de l'instant precedent. */
MdTb1(liste_des_coordonnees_a_l_instant_courant
,nombre_de_corps
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_vitesses_a_l_instant_courant
,nombre_de_corps
,deltaF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_stabilites_a_l_instant_courant
,nombre_de_corps
,Int
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_blocages_a_l_instant_courant
,nombre_de_corps
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_reflexions_a_l_instant_courant
,nombre_de_corps
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_refractions_a_l_instant_courant
,nombre_de_corps
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_niveaux_locaux_a_l_instant_courant
,nombre_de_corps
,genere_Float
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_compteurs_de_collisions_a_l_instant_courant
,nombre_de_corps
,Positive
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_compteurs_de_reflexions_a_l_instant_courant
,nombre_de_corps
,Positive
,ADRESSE_NON_ENCORE_DEFINIE
);
MdTb1(liste_des_compteurs_de_refractions_a_l_instant_courant
,nombre_de_corps
,Positive
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Definition de l'instant courant. */
MdTb2(liste_des_coordonnees_cumule_sur_toute_la_duree
,nombre_de_corps
,NOMBRE_EFFECTIF_DE_PERIODES_DE_LA_SIMULATION
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Definition de l'ensemble des instants cumules. */
Test(IZGT(nombre_de_periodes_de_la_simulation))
Bblock
/* Cas ou il y a au moins une periode a generer ; ce test a ete ajoute le 19980706122905 */
/* car il manquait et provoquait des anomalies sur '$LACT27' pour "np=0"... */
DEFV(Float,INIT(minimum_de_LISTE_X,F_INFINI));
DEFV(Float,INIT(maximum_de_LISTE_X,F_MOINS_L_INFINI));
DEFV(Float,INIT(minimum_de_LISTE_Y,F_INFINI));
DEFV(Float,INIT(maximum_de_LISTE_Y,F_MOINS_L_INFINI));
DEFV(Float,INIT(minimum_de_LISTE_Z,F_INFINI));
DEFV(Float,INIT(maximum_de_LISTE_Z,F_MOINS_L_INFINI));
/* Pour extraire les extrema de {LISTE_X,LISTE_Y,LISTE_Z}. */
DEFV(Float,INIT(minimum_de_LISTE_VX,F_INFINI));
DEFV(Float,INIT(maximum_de_LISTE_VX,F_MOINS_L_INFINI));
DEFV(Float,INIT(minimum_de_LISTE_VY,F_INFINI));
DEFV(Float,INIT(maximum_de_LISTE_VY,F_MOINS_L_INFINI));
DEFV(Float,INIT(minimum_de_LISTE_VZ,F_INFINI));
DEFV(Float,INIT(maximum_de_LISTE_VZ,F_MOINS_L_INFINI));
/* Pour extraire les extrema de {LISTE_VX,LISTE_VY,LISTE_VZ}. */
Komp(corps,nombre_de_corps)
Bblock
/* Initialisation des listes relatives aux differents corps arguments meme celles pour */
/* lesquelles cela n'a pas de sens... */
EGAL(ACCES_DATES_DE_NAISSANCE(corps),ACCES_LISTE(liste_initiale_des_DATE_DE_NAISSANCE,corps));
EGAL(ACCES_DATES_DE_MORT(corps),ACCES_LISTE(liste_initiale_des_DATE_DE_MORT,corps));
INITIALISATION_POINT_3D(ACCES_COORDONNEES_INITIALES(corps)
,ACCES_LISTE(liste_initiale_des_X,corps)
,ACCES_LISTE(liste_initiale_des_Y,corps)
,ACCES_LISTE(liste_initiale_des_Z,corps)
);
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_INITIALE(corps)
,ACCES_LISTE(liste_initiale_des_VX,corps)
,ACCES_LISTE(liste_initiale_des_VY,corps)
,ACCES_LISTE(liste_initiale_des_VZ,corps)
);
TRANSFERT_POINT_3D(ACCES_COORDONNEES_PRECEDENTES(corps)
,ACCES_COORDONNEES_INITIALES(corps)
);
TRANSFERT_POINT_3D(ACCES_COORDONNEES_CUMULEES(corps,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION)
,ACCES_COORDONNEES_INITIALES(corps)
);
TRANSFERT_POINT_3D(ACCES_COORDONNEES_COURANTES(corps)
,ACCES_COORDONNEES_INITIALES(corps)
);
TRANSFERT_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps)
,ACCES_VITESSE_INITIALE(corps)
);
Test(IFET(IFNE(ACCES_IMMOBILISABLES(corps),IMMOBILISABLE_IMPLICITE)
,I3OU(IFET(IZGT(ACCES_IMMOBILISABLES(corps))
,N_EST_PAS_ENTIER(ACCES_IMMOBILISABLES(corps))
)
,IZEQ(ACCES_IMMOBILISABLES(corps))
,IFET(IZLT(ACCES_IMMOBILISABLES(corps))
,IFEXff(ABSO(ACCES_IMMOBILISABLES(corps)),PROBABILITE_NULLE,PROBABILITE_UNITE)
)
)
)
)
/* Le test de 'IMMOBILISABLE_IMPLICITE' a ete introduit le 20150207082130 car, en effet, il */
/* manquait... */
Bblock
PRINT_ATTENTION("l''immobilisabilite' d'un corps est incorrecte");
PRINT_ATTENTION("elle n'est ni un nombre entier strictement positif, ni une probabilite en valeur absolue");
CAL1(Prer2("immobilisabilite(%d)=%f\n",corps,ACCES_IMMOBILISABLES(corps)));
EGAL(ACCES_IMMOBILISABLES(corps),IMMOBILISABLE_IMPLICITE);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(N_EST_PAS_ENTIER(ACCES_LISTE(liste_initiale_des_STABILITE,corps))
,IZLE(ACCES_LISTE(liste_initiale_des_STABILITE,corps))
)
)
Bblock
PRINT_ATTENTION("la 'stabilite' d'un corps n'est pas un nombre entier, ou est negative ou nulle");
CAL1(Prer1("corps=%d\n",corps));
EGAL(ACCES_STABILITES_COURANTES(corps),STABILITE_IMPLICITE);
Eblock
ATes
Bblock
EGAL(ACCES_STABILITES_COURANTES(corps),INTE(ACCES_LISTE(liste_initiale_des_STABILITE,corps)));
Eblock
ETes
Test(N_EST_PAS_ENTIER(gACCES_IDENTITES(corps)))
Bblock
PRINT_ATTENTION("l'identite d'un corps n'est pas un nombre entier");
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_LOGIQUE(gACCES_SOURCES_DU_POTENTIEL(corps)))
Bblock
PRINT_ATTENTION("un element de 'SOURCES_DU_POTENTIEL' n'a pas une valeur logique correcte");
CAL1(Prer2("(il ne vaut ni '%s' ni '%s')\n",C_FAUX____,C_VRAI____));
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_LOGIQUE(gACCES_COLLISIONNABLES(corps)))
Bblock
PRINT_ATTENTION("un element de 'COLLISIONNABLES' n'a pas une valeur logique correcte");
CAL1(Prer2("(il ne vaut ni '%s' ni '%s')\n",C_FAUX____,C_VRAI____));
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_LOGIQUE(gACCES_COALESCENCES(corps)))
/* Test introduit le 20211116115514... */
Bblock
PRINT_ATTENTION("un element de 'COALESCENCES' n'a pas une valeur logique correcte");
CAL1(Prer2("(il ne vaut ni '%s' ni '%s')\n",C_FAUX____,C_VRAI____));
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_LOGIQUE(gACCES_COLLAGES(corps)))
Bblock
PRINT_ATTENTION("un element de 'COLLAGES' n'a pas une valeur logique correcte");
CAL1(Prer2("(il ne vaut ni '%s' ni '%s')\n",C_FAUX____,C_VRAI____));
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_ENTIER(gACCES_CLEFS_DE_COLLAGE(corps)))
Bblock
PRINT_ATTENTION("une 'CLEFS_DE_COLLAGE' n'est pas un nombre entier");
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_LOGIQUE(gACCES_PROPAGATION_COULEURS(corps)))
Bblock
PRINT_ATTENTION("un element de 'PROPAGATION_COULEURS' n'a pas une valeur logique correcte");
CAL1(Prer2("(il ne vaut ni '%s' ni '%s')\n",C_FAUX____,C_VRAI____));
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
Test(N_EST_PAS_LOGIQUE(gACCES_AUTORISATION_DE_MODIFICATION_COULEURS(corps)))
/* Test introduit le 20200316093448... */
Bblock
PRINT_ATTENTION("un element de 'AUTORISATION_DE_MODIFICATION_COULEURS' n'a pas une valeur logique correcte");
CAL1(Prer2("(il ne vaut ni '%s' ni '%s')\n",C_FAUX____,C_VRAI____));
CAL1(Prer1("corps=%d\n",corps));
Eblock
ATes
Bblock
Eblock
ETes
#define UN_TOUR_DE_PLUS \
UN
EGAL(ACCES_STABILITES_COURANTES(corps),ADD2(ACCES_STABILITES_COURANTES(corps),UN_TOUR_DE_PLUS));
/* Et ce a cause du probleme lie a la visualisation des conditions initiales... */
EGAL(ACCES_REFLEXIONS_COURANTS(corps),FAUX);
EGAL(ACCES_REFRACTIONS_COURANTS(corps),FAUX);
EGAL(ACCES_NIVEAUX_LOCAUX_COURANTS(corps),NIVEAU_LOCAL_COURANT_INITIAL);
/* Et ce afin d'eviter que, par exemple, juste apres une reflexion, on considere lors du */
/* calcul du gradient qu'il y a refraction ; ceci est tout a fait possible puisqu'apres */
/* une reflexion la situation est inversee et que l'on risque donc de trouver un gradient */
/* inverse de celui qui a cause la reflexion et qui donc implique une refraction... */
CLIR(ACCES_COMPTEURS_COLLISIONS_COURANTS(corps));
CLIR(ACCES_COMPTEURS_REFLEXIONS_COURANTS(corps));
CLIR(ACCES_COMPTEURS_REFRACTIONS_COURANTS(corps));
/* Afin de compter les collisions dont 'corps' sera la victime. Ce nombre de collisions */
/* pourra etre uniquement 'ACCES_COMPTEURS_COLLISIONS_COURANTS(corps)' si l'on souhaite */
/* ne connaitre que les collisions entre les particules deux a deux ; mais cela pourra etre */
/* 'ACCES_COMPTEURS_COLLISIONS_COURANTS(corps)+ACCES_COMPTEURS_REFLEXIONS_COURANTS(corps)' */
/* si l'on compte comme "collision" celles qui ont lieu avec les discontinuites du milieu */
/* (ce qui est appele donc en fait "reflexion"). */
EGAL(ACCES_BLOCAGES_COURANTS(corps),FAUX);
/* Les corps ne sont actuellement pas bloques... */
Eblock
EKom
#define X_POSITION_COURANTE \
ASD1(ACCES_COORDONNEES_COURANTES(corps),x)
#define Y_POSITION_COURANTE \
ASD1(ACCES_COORDONNEES_COURANTES(corps),y)
#define Z_POSITION_COURANTE \
ASD1(ACCES_COORDONNEES_COURANTES(corps),z)
#define X_VITESSE \
ASD1(ACCES_VITESSE_COURANTE(corps),dx)
#define Y_VITESSE \
ASD1(ACCES_VITESSE_COURANTE(corps),dy)
#define Z_VITESSE \
ASD1(ACCES_VITESSE_COURANTE(corps),dz)
Komp(corps,nombre_de_corps)
Bblock
EGAL(minimum_de_LISTE_X,MIN2(minimum_de_LISTE_X,X_POSITION_COURANTE));
EGAL(maximum_de_LISTE_X,MAX2(maximum_de_LISTE_X,X_POSITION_COURANTE));
EGAL(minimum_de_LISTE_Y,MIN2(minimum_de_LISTE_Y,Y_POSITION_COURANTE));
EGAL(maximum_de_LISTE_Y,MAX2(maximum_de_LISTE_Y,Y_POSITION_COURANTE));
EGAL(minimum_de_LISTE_Z,MIN2(minimum_de_LISTE_Z,Z_POSITION_COURANTE));
EGAL(maximum_de_LISTE_Z,MAX2(maximum_de_LISTE_Z,Z_POSITION_COURANTE));
/* Extraction des extrema de {LISTE_X,LISTE_Y,LISTE_Z}. */
EGAL(minimum_de_LISTE_VX,MIN2(minimum_de_LISTE_VX,X_VITESSE));
EGAL(maximum_de_LISTE_VX,MAX2(maximum_de_LISTE_VX,X_VITESSE));
EGAL(minimum_de_LISTE_VY,MIN2(minimum_de_LISTE_VY,Y_VITESSE));
EGAL(maximum_de_LISTE_VY,MAX2(maximum_de_LISTE_VY,Y_VITESSE));
EGAL(minimum_de_LISTE_VZ,MIN2(minimum_de_LISTE_VZ,Z_VITESSE));
EGAL(maximum_de_LISTE_VZ,MAX2(maximum_de_LISTE_VZ,Z_VITESSE));
/* Extraction des extrema de {LISTE_VX,LISTE_VY,LISTE_VZ}. */
Eblock
EKom
EGAL(dimension_du_milieu
,COND(IFEQ(minimum_de_LISTE_Z,maximum_de_LISTE_Z)
,SE22(BI_DIMENSIONNEL,TRI_DIMENSIONNEL)
,NEUT(TRI_DIMENSIONNEL)
)
);
/* Dimension du milieu evaluee heuristiquement (introduite le 20211116134817). On notera */
/* que l'on fait ici l'hypothese que si le probleme est bi-dimensionnel, alors tous les */
/* points {X,Y} sont dans un plan Z=constante... */
/* */
/* Le 20211116144028, la dimension du milieu est passee systematiquement en mode */
/* 'TRI_DIMENSIONNEL' car, en effet, en 'BI_DIMENSIONNEL' les RAYON's variaient trop vite... */
Test(IFET(IL_NE_FAUT_PAS(calculer_la_moyenne_des_Mgradient_3x3x3_tri_dimensionnel)
,I3ET(IFEQ(minimum_de_LISTE_X,maximum_de_LISTE_X)
,IFET(IZEQ(minimum_de_LISTE_VX),IZEQ(maximum_de_LISTE_VX))
,IFEQ(seuil_de_Mgradient_local_tri_dimensionnel_X,SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF)
)
)
)
Bblock
PRINT_ATTENTION("il peut s'agir d'une simulation a X=constante, il est donc conseille de faire :");
CAL1(Prer1("seuil_gradientX=%f\n",SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_ACTIF));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_NE_FAUT_PAS(calculer_la_moyenne_des_Mgradient_3x3x3_tri_dimensionnel)
,I3ET(IFEQ(minimum_de_LISTE_Y,maximum_de_LISTE_Y)
,IFET(IZEQ(minimum_de_LISTE_VY),IZEQ(maximum_de_LISTE_VY))
,IFEQ(seuil_de_Mgradient_local_tri_dimensionnel_Y,SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF)
)
)
)
Bblock
PRINT_ATTENTION("il peut s'agir d'une simulation a Y=constante, il est donc conseille de faire :");
CAL1(Prer1("seuil_gradientY=%f\n",SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_ACTIF));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_NE_FAUT_PAS(calculer_la_moyenne_des_Mgradient_3x3x3_tri_dimensionnel)
,I3ET(IFEQ(minimum_de_LISTE_Z,maximum_de_LISTE_Z)
,IFET(IZEQ(minimum_de_LISTE_VZ),IZEQ(maximum_de_LISTE_VZ))
,IFEQ(seuil_de_Mgradient_local_tri_dimensionnel_Z,SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_NON_ACTIF)
)
)
)
Bblock
PRINT_ATTENTION("il peut s'agir d'une simulation a Z=constante, il est donc conseille de faire :");
CAL1(Prer1("seuil_gradientZ=%f\n",SEUIL_DE_Mgradient_local_tri_dimensionnel_XYZ_ACTIF));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou il n'y a aucune periode a generer ; ce test a ete ajoute le 19980706122905 */
/* car il manquait et provoquait des anomalies sur '$LACT27' pour "np=0"... */
Eblock
ETes
begin_nouveau_block
Bblock
DEFV(Int,INIT(numero_effectif_periode_courante_simulation,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION));
/* Le 20020828095224, il a fallu introduire le numero de la periode courante depuis qu'une */
/* image peut representer plusieurs periodes... */
BDEFV(album,champ_de_force);
/* Definition de l'album d'images dans lequel ranger le champ de force... */
BDEFV(album,milieu_de_propagation);
/* Definition de l'album d'images dans lequel ranger le milieu de propagation... */
BDEFV(album,champ_de_probabilite);
/* Definition de l'album d'images dans lequel ranger le champ de probabilite... */
ACCES_ALBUM(utiliser_un_champ_de_force
,champ_de_force
,nom_du_champ_de_forceA,F_nom_postfixe,F_nombre_de_chiffres_pour_le_champ
,F_attendre_les_images_inexistantes
,F_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,F_premiere_coupe,F_pas_des_coupes
,F_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM
,F_niveau_initial_du_champ_de_force
);
Test(IL_NE_FAUT_PAS(utiliser_un_milieu_de_propagation_dynamique))
Bblock
ACCES_ALBUM(utiliser_un_milieu_de_propagation
,milieu_de_propagation
,nom_du_milieu_de_propagationA
,M_nom_postfixe
,M_nombre_de_chiffres_pour_le_milieu
,M_attendre_les_images_inexistantes
,M_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,M_premiere_coupe,M_pas_des_coupes
,M_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM
,M_niveau_initial_du_milieu_de_propagation
);
/* Cas d'un milieu "statique" : on le lit une fois pour toutes au debut de la simulation... */
Eblock
ATes
Bblock
Eblock
ETes
ACCES_ALBUM(utiliser_un_champ_de_probabilite
,champ_de_probabilite
,nom_du_champ_de_probabiliteA,P_nom_postfixe,P_nombre_de_chiffres_pour_le_champ
,P_attendre_les_images_inexistantes
,P_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,P_premiere_coupe,P_pas_des_coupes
,P_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM
,P_niveau_initial_du_champ_de_probabilite
);
Komp(numero_de_la_periode_courante_de_la_simulation,nombre_de_periodes_de_la_simulation)
Bblock
DEFV(Int,INIT(periode,UNDEF));
/* Periode de parcours de 'ACCES_COORDONNEES_PRECEDENTES(...)' pour la visualisation... */
DEFV(Logical,INIT(les_COORDONNEES_CUMULEES_ont_ete_mises_a_jour,FAUX));
/* Indicateur introduit le 20011023090311 afin de permettre des valeurs nulles pour le */
/* parametre 'nombre_de_pas_de_temps_par_periode' (via 'nombre=0' ou 'NOMBRE=...'). */
Test(IL_FAUT(utiliser_un_pas_de_temps_variable))
Bblock
EGAL(dct,ACCES_PAS_DE_TEMPS(numero_de_la_periode_courante_de_la_simulation));
Test(N_EST_PAS_ENTIER(ACCES_NOMBRES(numero_de_la_periode_courante_de_la_simulation)))
Bblock
PRINT_ATTENTION("un nombre de pas de temps n'est pas entier");
CAL1(Prer1("numero de la periode courante=%d\n",numero_de_la_periode_courante_de_la_simulation));
Eblock
ATes
Bblock
Eblock
ETes
EGAL(nombre_de_pas_de_temps_par_periode,ACCES_NOMBRES(numero_de_la_periode_courante_de_la_simulation));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(utiliser_un_milieu_de_propagation_dynamique))
Bblock
ACCES_ALBUM(utiliser_un_milieu_de_propagation
,milieu_de_propagation
,chain_Aconcaten2_sauf_nom_pipe(nom_du_milieu_de_propagationA
,chain_numero(numero_de_la_periode_courante_de_la_simulation
,M_nombre_de_chiffres_pour_le_milieu_dynamique
)
)
,M_nom_postfixe
,M_nombre_de_chiffres_pour_le_milieu
,M_attendre_les_images_inexistantes
,M_autoriser_les_sequences_incompletes_dans_ACCES_ALBUM
,M_premiere_coupe,M_pas_des_coupes
,M_inverser_l_ordre_des_coupes_dans_ACCES_ALBUM
,M_niveau_initial_du_milieu_de_propagation
);
/* Cas d'un milieu "dynamique" : il faut le lire au debut de chaque nouvelle periode... */
/* */
/* ATTENTION : cette facilite introduite le 20010228095632 est relativement simpliste. En */
/* particulier, si le milieu voit, par exemple, son "volume" diminuer, les particules qui */
/* se trouvent alors "hors-volume" continuent a etre traitees comme si de rien n'etait... */
Eblock
ATes
Bblock
Eblock
ETes
INITIALISATIONS_RELATIVES_A_CHAQUE_NOUVELLE_IMAGE(numero_de_la_periode_courante);
/* Initialisations necessaires avant le calcul et la generation de chaque nouvelle image. */
Repe(nombre_de_periodes_par_image)
Bblock
DoIn(periode
,COND(IL_FAUT(visualiser_l_ensemble_des_instants)
,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION
,numero_effectif_periode_courante_simulation
)
,numero_effectif_periode_courante_simulation
,I
)
Bblock
Komp(corps,nombre_de_corps)
Bblock
Test(IFET(IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant)
,IFGT(ACCES_DATES_DE_MORT(corps),temps_courant)
)
)
Bblock
DEFV(Float,INIT(module_de_la_vitesse,longF3D(ACCES_VITESSE_COURANTE(corps))));
/* Module de la vitesse du corps courant destine a "moduler" eventuellement les parametres */
/* de visualisation {{ROUGE,VERTE,BLEUE},{RAYON}} (ceci a ete introduit le 20050530094748). */
EGAL(rayon_de_visualisation
,LIZ2(FU
,ACCES_LISTE(liste_initiale_des_RAYON,corps)
,facteur_du_module_de_la_vitesse_pour_le_RAYON
,module_de_la_vitesse
)
);
/* Recuperation eventuelle du rayon du corps courant... */
EGAL(cx,ASD1(ACCES_COORDONNEES_CUMULEES(corps,periode),x));
EGAL(cy,ASD1(ACCES_COORDONNEES_CUMULEES(corps,periode),y));
EGAL(cz,ASD1(ACCES_COORDONNEES_CUMULEES(corps,periode),z));
/* A cause de 'RECHERCHE_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES', il est necessaire */
/* de passer par {cx,cy,cz}. */
EGAL(dcx
,LIZ2(FU
,ACCES_LISTE(liste_initiale_des_ROUGE,corps)
,facteur_du_module_de_la_vitesse_pour_le_ROUGE
,module_de_la_vitesse
)
);
EGAL(dcy
,LIZ2(FU
,ACCES_LISTE(liste_initiale_des_VERTE,corps)
,facteur_du_module_de_la_vitesse_pour_le_VERTE
,module_de_la_vitesse
)
);
EGAL(dcz
,LIZ2(FU
,ACCES_LISTE(liste_initiale_des_BLEUE,corps)
,facteur_du_module_de_la_vitesse_pour_le_BLEUE
,module_de_la_vitesse
)
);
CALS(memorisation_d_un_point_grave(DECENTRAGE_DES_COORDONNEES(cx,X,x)
,DECENTRAGE_DES_COORDONNEES(cy,Y,y)
,DECENTRAGE_DES_COORDONNEES(cz,Z,z)
,dcx
,dcy
,dcz
,ACCES_IDENTITES(corps)
,ACCES_MASSES(corps)
,ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
,periode
)
);
/* Memorisation du corps courant, la premiere image donnant les conditions initiales... */
/* ATTENTION, jusqu'au 19980213085333, on trouvait 'corps' a la place de 'periode' ; bien */
/* que ne servant a rien, j'ai corrige cette erreur... */
/* */
/* L'edition des vitesses {vx,vy,vz} du point courant a ete ajoute le 19980630135924 */
/* afin de permettre l'edition de l'etat final d'une simulation afin que celui-ci puisse */
/* servir de conditions initiales a une autre simulation, par exemple, en ayant modifie la */
/* geometrie du milieu. ATTENTION, lors d'une telle utilisation l'etat final d'une */
/* simulation 'N' est alors strictement identique a l'etat initial de la suivante 'N+1' */
/* (heureusement...) ce qui signifie que la derniere image de la simulation 'N' et la ' */
/* premiere image de la simulation 'N+1' sont identiques et donc, cette premiere image */
/* doit etre ignoree ('v _____xivPdf_11_2/$Fnota 018098_018609'). D'autre part, dans une */
/* telle utilisation, il est difficile d'assurer la continuite des trainees ; de petits */
/* defauts peuvent apparaitre comme dans 'v _____xivPdf_11_2/$Fnota 018098_018609'. */
/* De plus, en prenant l'exemple d'un milieu {NOIR,BLANC} (le 'BLANC' designant l'interieur */
/* et le 'BLANC' designant l'exterieur), il est necessaire que le volume interieur de la */
/* simulation 'N' soit inclus dans le volume interieur de la simulation 'N+1' ; en effet, */
/* dans le cas contraire, des particules proches de la frontiere pourraient etre "ejectees" */
/* artificiellement du milieu de propagation ('BLANC') et alors le cas de ces particules */
/* devrait etre traite avant de la lancer la simulation 'N+1' ; mais qu'en faire ? */
RECHERCHE_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES;
/* On notera que cette recherche n'est pas conditionnee par 'editer_les_extrema', car les */
/* extrema pourraient etre utilises pour la visualisation... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
EDoI
Test(IL_FAUT(inverser_le_processus))
Bblock
Test(IFEQ(numero_de_la_periode_courante_de_la_simulation,periode_d_inversion_du_processus))
Bblock
/* Cas ou il faut inverser arbitrairement toutes les vitesses. Il est evident que cela n'a */
/* reellement de sens que si il n'y a aucun processus aleatoires actifs... */
Komp(corps,nombre_de_corps)
Bblock
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps)
,NEGA(ASD1(ACCES_VITESSE_COURANTE(corps),dx))
,NEGA(ASD1(ACCES_VITESSE_COURANTE(corps),dy))
,NEGA(ASD1(ACCES_VITESSE_COURANTE(corps),dz))
);
/* On repart donc dans la direction inverse de la direction incidente... */
Eblock
EKom
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
MOYENNAGE_DES_VITESSES_PAR_FAMILLE;
/* Le 20000426151032, 'MOYENNAGE_DES_VITESSES_PAR_FAMILLE' a ete duplique ici afin de */
/* s'appliquer aussi aux conditions initiales... */
Repe(COND(IFEQ(numero_effectif_periode_courante_simulation,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION)
,ADD2(NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE_EFFECTIF,UN_TOUR_DE_PLUS)
,NEUT(NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE_EFFECTIF)
)
)
/* Cette precaution evitant de visualiser deux fois les conditions initiales (ce qui se */
/* voit lorsque 'nombre_de_pas_de_temps_par_periode' est egal a un...). */
Bblock
Test(I3OU(IL_FAUT(utiliser_un_champ_de_force)
,IL_FAUT(utiliser_un_milieu_de_propagation)
,IL_FAUT(utiliser_un_champ_de_probabilite)
)
)
Bblock
Komp(corps,nombre_de_corps)
Bblock
Test(I3ET(EST_FAUX(ACCES_BLOCAGES_COURANTS(corps))
,EST_VRAI(LOGI(ACCES_LISTE(liste_initiale_des_MOBILITE,corps)))
,IFET(IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant)
,IFGT(ACCES_DATES_DE_MORT(corps),temps_courant)
)
)
)
Bblock
/* Cas d'un corps non bloque, mobile et qui est vivant... */
DEFV(deltaF_3D,deplacement_elementaire_dans_les_champs_avec_les_positions);
DEFV(deltaF_3D,deplacement_elementaire_dans_les_champs_avec_la_vitesse);
Test(IFGT(temps_courant,instant_initial))
Bblock
Test(IFET(IFGT(ACCES_DATES_DE_NAISSANCE(corps),instant_initial)
,IFGT(ACCES_DATES_DE_NAISSANCE(corps),SOUS(temps_courant,DCT_EFFECTIF))
)
)
Bblock
INCR(compteur_des_particules_nees_apres_l_instant_initial,I);
/* Comptage des particules nees au cours du pas de temps courant (dispositif introduit le */
/* 20020227092012). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
#define X_POSITION_PRECEDENTE \
ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
#define Y_POSITION_PRECEDENTE \
ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
#define Z_POSITION_PRECEDENTE \
ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
INITIALISATION_ACCROISSEMENT_3D(deplacement_elementaire_dans_les_champs_avec_les_positions
,SOUS(X_PHYSIQUE_A_VISUALISATION(X_POSITION_COURANTE)
,X_PHYSIQUE_A_VISUALISATION(X_POSITION_PRECEDENTE)
)
,SOUS(Y_PHYSIQUE_A_VISUALISATION(Y_POSITION_COURANTE)
,Y_PHYSIQUE_A_VISUALISATION(Y_POSITION_PRECEDENTE)
)
,SOUS(Z_PHYSIQUE_A_VISUALISATION(Z_POSITION_COURANTE)
,Z_PHYSIQUE_A_VISUALISATION(Z_POSITION_PRECEDENTE)
)
);
INITIALISATION_ACCROISSEMENT_3D(deplacement_elementaire_dans_les_champs_avec_la_vitesse
,SOUS(X_PHYSIQUE_A_VISUALISATION(AXPB(X_VITESSE
,DCT_EFFECTIF
,X_POSITION_COURANTE
)
)
,X_PHYSIQUE_A_VISUALISATION(X_POSITION_COURANTE)
)
,SOUS(Y_PHYSIQUE_A_VISUALISATION(AXPB(Y_VITESSE
,DCT_EFFECTIF
,Y_POSITION_COURANTE
)
)
,Y_PHYSIQUE_A_VISUALISATION(Y_POSITION_COURANTE)
)
,SOUS(Z_PHYSIQUE_A_VISUALISATION(AXPB(Z_VITESSE
,DCT_EFFECTIF
,Z_POSITION_COURANTE
)
)
,Z_PHYSIQUE_A_VISUALISATION(Z_POSITION_COURANTE)
)
);
/* Deplacement a priori du corps courant au cours d'un pas de temps. On notera que ce */
/* calcul est fait via une difference entre la position future et la position courante */
/* car, en effet, les procedures '?_PHYSIQUE_A_VISUALISATION(...)' ne font pas qu'un simple */
/* changement d'echelle mais aussi (malheureusment...) une translation dans l'espace */
/* physique... */
/* */
/* On notera que jusqu'au 19980924174230 ce calcul de deplacement elementaire etait du */
/* type : */
/* */
/* [C(t) + (V.dt)] - C(t) */
/* */
/* mais qu'avec l'introduction de la gravitation generalisee qui deplace les corps sans */
/* mettre a jour leurs vitesses, il a ete necessaire de rajouter un deuxieme test du type : */
/* */
/* C(t) - C(t-dt) */
/* */
/* ou 'C' designe une coordonnee quelconque... */
#undef X_POSITION_PRECEDENTE
#undef Y_POSITION_PRECEDENTE
#undef Z_POSITION_PRECEDENTE
#undef Z_VITESSE
#undef Y_VITESSE
#undef X_VITESSE
#undef Z_POSITION_COURANTE
#undef Y_POSITION_COURANTE
#undef X_POSITION_COURANTE
Test(IFET(IL_FAUT(tester_les_details_fins)
,IFOU(IFGT(longF3D(deplacement_elementaire_dans_les_champs_avec_les_positions)
,FLOT(INTER_POINT)
)
,IFGT(longF3D(deplacement_elementaire_dans_les_champs_avec_la_vitesse)
,FLOT(INTER_POINT)
)
)
)
)
Bblock
PRINT_ATTENTION("pas de temps trop grand ==> des details des champs seront ignores");
PRINT_ATTENTION("diminuer 'dct=' et augmenter 'nombre='");
CAL1(Prer1("periode.......................................................=%d\n"
,numero_de_la_periode_courante_de_la_simulation
)
);
CAL1(Prer1("t.............................................................=%f\n"
,temps_courant
)
);
CAL1(Prer1("corps.........................................................=%d\n"
,corps
)
);
CAL1(Prer1("longueur du deplacement elementaire calcule avec les positions=%f\n"
,longF3D(deplacement_elementaire_dans_les_champs_avec_les_positions)
)
);
CAL1(Prer1("longueur du deplacement elementaire calcule avec les vitesses.=%f\n"
,longF3D(deplacement_elementaire_dans_les_champs_avec_la_vitesse)
)
);
CAL1(Prer1("pas de temps effectif.........................................=%f\n"
,DCT_EFFECTIF
)
);
CAL1(Prer1("nombre de pas de temps par periode effectif...................=%d\n"
,NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE_EFFECTIF
)
);
/* Un exemple de probleme est la situation suivante : */
/* */
/* */
/* +++++++++++++++++++++++++++++++++++++++++++++++ */
/* ++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++ */
/* -----------------------*----------- ++++++++ */
/* . t . /++++++++ */
/* . . /++++++++ */
/* . . /++++++++ */
/* . .++++++++ */
/* . /++.+++++ */
/* . /+++++.++ */
/* . /++++++++. */
/* t-dt * /++++++++ * t+dt */
/* . /++++++++ . */
/* */
/* */
/* il y a reflexion a 't'. La trajectoire prend une direction telle que dans l'intervalle */
/* de temps [t,t+dt] on franchisse une frontiere qui n'est pas vue. Comme les champs sont */
/* definis a l'aide d'image, il convient que pendant l'intervalle de temps [t,t+dt] chaque */
/* particule ne survole pas plus d'un point d'image... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
Bblock
Komp(corpsI,nombre_de_corps)
Bblock
Test(LE_CORPS_EST_VIVANT(corpsI))
/* Test introduit le 20160610152047... */
Bblock
Komp(corpsJ,nombre_de_corps)
Bblock
Test(LE_CORPS_EST_VIVANT(corpsJ))
/* Test introduit le 20160610152047... */
Bblock
Test(IFLE(corpsI,corpsJ))
/* Cas ou 'corpsI' est inferieur ou egal a 'corpsJ', le calcul doit etre fait : */
Bblock
EGAL(ACCES_DISTANCES_PRECEDENTES(corpsI,corpsJ)
,RpdisF3D(ACCES_COORDONNEES_PRECEDENTES(corpsI)
,ACCES_COORDONNEES_PRECEDENTES(corpsJ)
)
);
/* Initialisation de la matrice des distances de tous les corps 2 a 2... */
Eblock
ATes
Bblock
EGAL(ACCES_DISTANCES_PRECEDENTES(corpsI,corpsJ)
,ACCES_DISTANCES_PRECEDENTES(corpsJ,corpsI)
);
/* Cas ou 'corpsI' est superieur strictement a 'corpsJ', on peut utiliser le fait que : */
/* */
/* d(i,j) = d(j,i) */
/* */
/* et que 'd(j,i)' a deja ete calculee (optimisation introduite le 20000607085452). */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
ATes
Bblock
Eblock
ETes
#include xrk/rdn_walk.51.I"
/* Outils de gestion de l'aggregation et des collisions entre corps... */
#define CoordOptimise \
gSE13(x,y,z) \
/* Choix de la coordonnee sur laquelle va se faire l'eventuel tri d'optimisation. Jusqu'au */ \
/* 20011019162154, c'etait la coordonnee 'z' qui etait choisie ; or celle-ci privilegie les */ \
/* simulations tridimensionnelles. Or beaucoup sont en fait bidimensionnelles et situees */ \
/* dans le plan {x,y}. Il vaut donc mieux optimiser selon l'une de ces deux coordonnees. */ \
/* De plus, de par le format 'Pal' tres repandu, la dimension 'x' est en general plus */ \
/* peuplee que la dimension 'y' ; alors, il est preferable d'optimiser selon 'x' car, ainsi, */ \
/* les tests de collisions se feront dans des plans {y,z} qui seront moins peuples que les */ \
/* plans {x,z} : il y aura donc moins de tests 2 a 2. On notera au passage, que cette */ \
/* modification rend les sequences anterieures non regenerables tel quel a cause de la */ \
/* non commutativite de la gestion des collisions ('v $xrk/rdn_walk.52$K pas.commutative'). */
#define RAYON_corpsI \
ACCES_LISTE(liste_initiale_des_RAYON_D_INTERACTION,corpsI)
#define RAYON_corpsJ \
ACCES_LISTE(liste_initiale_des_RAYON_D_INTERACTION,corpsJ)
CHRONOMETRAGE_DE_LA_SIMULATION("GESTION DE L'AGGREGATION ET DES COLLISIONS"
,BLOC(
Bblock
DEFV(deltaF_3D,cumul_vitesses_si_frolages);
DEFV(Int,INIT(nombre_de_vitesses_cumulees_si_frolages,UNDEF));
/* Meme si 'IL_NE_FAUT_PAS(detecter_les_collisions_VERSION_N_AU_CARRE)', ces structures sont */
/* declarees car, en effet, 'GESTION_DES_AGGREGATIONS_ET_DES_COLLISIONS' est appelee dans */
/* les deux cas et les reference... */
Test(IL_FAUT(detecter_les_collisions_VERSION_N_AU_CARRE))
/* Cette possibilite d'optimisation a ete introduite le 20010920103622. */
Bblock
Komp(corpsI,nombre_de_corps)
Bblock
Test(LE_CORPS_EST_VIVANT(corpsI))
Bblock
/* Test introduit le 20160610152047... */
Test(IL_FAUT(synchroniser_les_vitesses))
Bblock
TRANSFERT_ACCROISSEMENT_3D
(cumul_vitesses_si_frolages
,ACCES_VITESSE_COURANTE(corpsI)
);
EGAL(nombre_de_vitesses_cumulees_si_frolages,UN);
/* Le corps 'I' fait partie du cumul... */
Eblock
ATes
Bblock
Eblock
ETes
Komp(corpsJ,nombre_de_corps)
Bblock
GESTION_DES_AGGREGATIONS_ET_DES_COLLISIONS;
/* Gestion de l'aggregation et des collisions entre corps. */
Eblock
EKom
Test(IL_FAUT(synchroniser_les_vitesses))
Bblock
INITIALISATION_ACCROISSEMENT_3D
(ACCES_VITESSE_COURANTE(corpsI)
,DIVI(ASD1(cumul_vitesses_si_frolages,dx)
,nombre_de_vitesses_cumulees_si_frolages
)
,DIVI(ASD1(cumul_vitesses_si_frolages,dy)
,nombre_de_vitesses_cumulees_si_frolages
)
,DIVI(ASD1(cumul_vitesses_si_frolages,dz)
,nombre_de_vitesses_cumulees_si_frolages
)
);
/* Le corps 'I' adopte la vitesse moyenne de ses voisins (introduit le 20060705114014...). */
/* */
/* On notera qu'en fait, pour faire un calcul correct, il faudrait disposer de deux listes */
/* pour les vitesses : d'une part la liste 'AVANT' a l'aide de laquelle seraient faits les */
/* calculs de cumul lors des frolages ; d'autre part, la liste 'APRES' dans laquelle */
/* seraient memorisees les vitesses moyennes ainsi calculees. La liste 'AVANT' devrait */
/* donc n'etre qu'une liste que l'on lit sans jamais la modifier au cours d'un pas de temps. */
/* Cette remarque porte d'ailleurs aussi sur le calcul des collisions... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
ATes
Bblock
Test(IFGT(nombre_de_corps,UN))
Bblock
gDEFINITION_LISTE(liste_des_corps
,NOMBRE_MAXIMAL_DE_POINTS_GERABLES
);
gDEFINITION_LISTE(liste_des_coordonnees_X_Y_ou_Z
,NOMBRE_MAXIMAL_DE_POINTS_GERABLES
);
/* Listes destinees a faire un tri en 'N*Log(N)' de l'une des coordonnees ('Z' par defaut). */
DEFV(Int,INIT(index_corpsI,UNDEF));
DEFV(Int,INIT(index_corpsJ,UNDEF));
/* Index d'acces aux corps 'corpsI' et 'corpsJ' respectivement, apres le tri. On notera */
/* qu'en general, les points compris entre 'corpsI' et 'corpsJ' (eux compris) sont proches */
/* les uns des autres (au sens de la coordonnee de tri et non pas au sens de la distance */
/* euclidienne) et sont donc susceptibles d'etre en etat de collision (ce qui devra etre */
/* ensuite verifie par le calcul de la distance euclidienne). Cela vient evidemment du fait */
/* que la liste 'liste_des_corps' donne la liste des corps triee suivant cette "fameuse" */
/* coordonnee de tri ('Z' par defaut). */
DEFV(Logical,INIT(tester_les_collisions,VRAI));
/* Afin de boucler sur le test de collision... */
Komp(corps,nombre_de_corps)
Bblock
Test(LE_CORPS_EST_VIVANT(corps))
/* Test introduit le 20160610152047... */
Bblock
EGAL(ACCES_LISTE(liste_des_corps,corps)
,FLOT(corps)
);
EGAL(ACCES_LISTE(liste_des_coordonnees_X_Y_ou_Z
,corps
)
,ASD1(ACCES_COORDONNEES_COURANTES(corps)
,CoordOptimise
)
);
/* Mise en place des deux listes. On notera qu'il suffit de remplacer le 'z' de l'acces */
/* 'ASD1(...,z)' par 'x' ou 'y' pour changer la coordonnee sur laquelle est fait le tri. */
/* En fait, les trois coordonnees {X,Y,Z} sont tout a fait symetriques dans cette operation */
/* et la coordonnee 'Z' a ete choisie par analogie avec le tri qui est fait ulterieurement */
/* lors de la generation de l'image courante... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
TRI_D_UNE_LISTE_QUELCONQUE_VERSION_N_LOG_N
(liste_des_coordonnees_X_Y_ou_Z
,liste_des_corps
,PREMIER_POINT_DES_LISTES
,NEUT(LSTX(PREMIER_POINT_DES_LISTES
,nombre_de_corps
)
)
,ACCES_LISTE
);
/* Tri en 'N*Log(N)' de l'une des coordonnees ('Z' par defaut). Le 20020828171416, j'ai */
/* fait en sorte que le dernier agument de type "index" pointe bien sur le dernier element */
/* de la liste et non point sur son successeur (d'ou le remplacement d'un 'SUCC(...)' par */
/* un 'NEUT(...)'. */
EGAL(index_corpsI,PREMIER_POINT_DES_LISTES);
EGAL(index_corpsJ,SUCC(index_corpsI));
/* Initialisation du parcours de la liste 'liste_des_corps'. Le point 'corpsI' est le */
/* premier et 'corpsJ' est situe juste apres... */
Tant(IL_FAUT(tester_les_collisions))
Bblock
DEFV(Int,INIT(corpsI_non_ordonne
,ACCES_LISTE(liste_des_corps,index_corpsI)
)
);
DEFV(Int,INIT(corpsI,UNDEF));
DEFV(Int,INIT(corpsJ_non_ordonne
,ACCES_LISTE(liste_des_corps,index_corpsJ)
)
);
DEFV(Int,INIT(corpsJ,UNDEF));
/* Corps 'corpsI' et 'corpsJ' et leurs versions avant leur "classement"... On notera que */
/* ceux-ci sont probablement relativement proches l'un de l'autre, mais uniquement en ce */
/* concerne leurs coordonnees de tri ('Z' par defaut). */
DEFV(Float,INIT(distance_I_J_courante,FLOT__UNDEF));
/* Distance courante entre 'I' et 'J' ; celle-ci n'est pas la distance euclidienne et ne */
/* prend en compte que la coordonnee grace a laquelle on vient donc de trier... */
EGAL(corpsI,MIN2(corpsI_non_ordonne,corpsJ_non_ordonne));
EGAL(corpsJ,MAX2(corpsI_non_ordonne,corpsJ_non_ordonne));
/* Definition des 'corpsI' et 'corpsJ' courants. La mise en place d'un ordre imperatif */
/* entre eux est du a 'v $xrk/rdn_walk.51$I Test.IFET.IFET.IFLT.corpsI,corpsJ.'. */
Test(IFET(LE_CORPS_EST_VIVANT(corpsI)
,LE_CORPS_EST_VIVANT(corpsJ)
)
)
/* Test introduit le 20160610152047... */
Bblock
EGAL(distance_I_J_courante
,SOUA(ACCES_LISTE(liste_des_coordonnees_X_Y_ou_Z
,corpsI
)
,ACCES_LISTE(liste_des_coordonnees_X_Y_ou_Z
,corpsJ
)
)
);
/* Distance courante non euclidienne entre 'I' et 'J'. */
Test(IFET(IFLT(distance_I_J_courante
,seuil_d_interaction
)
,IFLT(distance_I_J_courante
,MUL2(facteur_des_rayon_d_interaction
,ADD2(RAYON_corpsI,RAYON_corpsJ)
)
)
)
)
Bblock
/* Si les 'corpsI' et 'corpsJ' sont proches l'un de l'autre en ce qui concerne leurs */
/* coordonnees 'X', il peut y avoir collision. Pour la detecter d'une facon certaine, */
/* il faut etudier ensuite les trois coordonnees {X,Y,Z} (ce qui est donc fait dans */
/* 'v $xrk/rdn_walk.51$I GESTION_DES_AGGREGATIONS_ET_DES_COLLISIONS'). */
/* */
/* Le principe de cette optimisation repose (en prenant l'exemple de la coordonnee 'X') */
/* sur : */
/* */
/* DistanceEuclidienne(Pi,Pj) >= |X(Pj) - X(Pi)| */
/* */
/* cette relation etant toujours vraie... */
/* */
/* En consequence, si la valeur absolue des differences des coordonnees est SUPERIEURE */
/* a un certain seuil, il en est de meme de la distance euclidienne et on sait donc qu'il */
/* n'y a pas collision. La seule chose qui soit donc certaine dans cette optimisation, */
/* c'est lorsqu'IL N'Y A PAS COLLISION. */
GESTION_DES_AGGREGATIONS_ET_DES_COLLISIONS;
/* Gestion de l'aggregation et des collisions entre corps. */
INCR(index_corpsJ,I);
/* Progression de 'corpsJ' via son index. En effet, {corpsI,corpsJ} ayant ete trouve */
/* en collision possible, on peut tester {corpsI,corpsJ+1}, sauf evidemment si 'corpsJ' */
/* "deborde" (n'existe pas) : */
Test(IFGT(index_corpsJ
,LSTX(PREMIER_POINT_DES_LISTES
,nombre_de_corps
)
)
)
Bblock
INCR(index_corpsI,I);
/* Progression de 'corpsI' via son index... */
EGAL(index_corpsJ,SUCC(index_corpsI));
/* Et positionnement de 'corpsJ' juste apres 'corpsI'... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Si les 'corpsI' et 'corpsJ' sont eloignes l'un de l'autre en ce qui concerne leurs */
/* coordonnees 'X', ils ne peuvent etre proches en realite (via la distance euclidienne). */
/* Il est donc inutile d'examiner {corpsI,corpsJ+1}, on passe donc a {corpsI+1,corpsI+2} : */
INCR(index_corpsI,I);
/* Progression de 'corpsI' via son index... */
EGAL(index_corpsJ,SUCC(index_corpsI));
/* Et positionnement de 'corpsJ' juste apres 'corpsI'... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFGE(index_corpsI
,LSTX(PREMIER_POINT_DES_LISTES,nombre_de_corps)
)
)
Bblock
EGAL(tester_les_collisions,FAUX);
/* C'est fini... */
Eblock
ATes
Bblock
Test(IFGT(index_corpsJ
,LSTX(PREMIER_POINT_DES_LISTES
,nombre_de_corps
)
)
)
Bblock
PRINT_ERREUR("probleme optimisation collisions");
CAL1(Prer2("I=%d J=%d\n"
,index_corpsI
,index_corpsJ
)
);
CAL1(Prer1("nombre de corps=%d\n"
,nombre_de_corps
)
);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
ETan
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
)
);
#undef RAYON_corpsJ
#undef RAYON_corpsI
#undef CoordOptimise
Komp(corps,nombre_de_corps)
Bblock
Test(LE_CORPS_EST_VIVANT(corps))
/* Test introduit le 20160610152047... */
Bblock
EDITION_E(BLOC(CAL2(Prin4("periode=%d periode_effective=%d t=%f corps=%d\n"
,numero_de_la_periode_courante_de_la_simulation
,numero_effectif_periode_courante_simulation
,temps_courant
,corps
)
);
)
);
EDITION_E(BLOC(CAL2(Prin3(" coordonnees={%+f,%+f,%+f}"
,ASD1(ACCES_COORDONNEES_COURANTES(corps),x)
,ASD1(ACCES_COORDONNEES_COURANTES(corps),y)
,ASD1(ACCES_COORDONNEES_COURANTES(corps),z)
)
);
)
);
EDITION_E(BLOC(CAL2(Prin3(" vitesse={%+f,%+f,%+f}"
,ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
)
);
)
);
EDITION_E(BLOC(CAL2(Prin3(" couleur={%+f,%+f,%+f}"
,ACCES_LISTE(liste_initiale_des_ROUGE,corps)
,ACCES_LISTE(liste_initiale_des_VERTE,corps)
,ACCES_LISTE(liste_initiale_des_BLEUE,corps)
)
);
)
);
TRANSFERT_POINT_3D(ACCES_COORDONNEES_PRECEDENTES(corps)
,ACCES_COORDONNEES_COURANTES(corps)
);
Test(I3ET(EST_FAUX(ACCES_BLOCAGES_COURANTS(corps))
,EST_VRAI(LOGI(ACCES_LISTE(liste_initiale_des_MOBILITE,corps)))
,IFET(IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant)
,IFGT(ACCES_DATES_DE_MORT(corps),temps_courant)
)
)
)
Bblock
/* Cas d'un corps non bloque, mobile et qui est vivant... */
DEFV(Int,INIT(X,UNDEF));
DEFV(Float
,INIT(Xf
,gX_PHYSIQUE_A_VISUALISATION(ASD1(ACCES_COORDONNEES_COURANTES(corps),x),FZERO)
)
);
DEFV(Int,INIT(Y,UNDEF));
DEFV(Float
,INIT(Yf
,gY_PHYSIQUE_A_VISUALISATION(ASD1(ACCES_COORDONNEES_COURANTES(corps),y),FZERO)
)
);
DEFV(Int,INIT(Z,UNDEF));
DEFV(Float
,INIT(Zf
,gZ_PHYSIQUE_A_VISUALISATION(ASD1(ACCES_COORDONNEES_COURANTES(corps),z),FZERO)
)
);
/* Positionnement dans le milieu de propagation ou dans le champ de force. */
/* */
/* ATTENTION : les coordonnees {Xf,Yf,Zf} sont celles du centre de gravite de la particule. */
/* Cela implique un petit defaut : lorsqu'une particule est etendue, elle pourra donner */
/* l'illusion de franchir partiellement les discontinuites du milieu, au lieu, par exemple, */
/* de se reflechir proprement ; c'est donc le centre de gravite qui se reflechit, ainsi */
/* qu'il est possible de le voir avec la sequence : */
/* */
/* xivPdf 9 2 / 017055_017566 */
/* */
/* ou certaines grosses boules semblent penetrer partiellement dans les bords d'un billiard */
/* rectangulaire ; c'est pour cela qu'avant d'enregistrer j'ai regenere en trichant : j'ai */
/* reduit la taille des grosees boules et augmente leurs masses : */
/* */
/* set _____FactR=2 */
/* set _____FactM=20 */
/* */
/* alors qu'auparavant les valeurs etaient de 3 et de 9 (3 au carre) respectivement... */
DEFV(Int,INIT(X_anticipe,UNDEF));
DEFV(Float
,INIT(Xf_anticipe
,gX_PHYSIQUE_A_VISUALISATION(AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_COURANTES(corps),x)
)
,FZERO
)
)
);
DEFV(Int,INIT(Y_anticipe,UNDEF));
DEFV(Float
,INIT(Yf_anticipe
,gY_PHYSIQUE_A_VISUALISATION(AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_COURANTES(corps),y)
)
,FZERO
)
)
);
DEFV(Int,INIT(Z_anticipe,UNDEF));
DEFV(Float
,INIT(Zf_anticipe
,gZ_PHYSIQUE_A_VISUALISATION(AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dz)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_COURANTES(corps),z)
)
,FZERO
)
)
);
/* Anticipation de la position future du point courant afin d'evaluer les fonctions */
/* 'nPRE?(...)' et 'nSUC?(...)'. */
DEFV(Float,INIT(module_de_la_vitesse_incidente,longF3D(ACCES_VITESSE_COURANTE(corps))));
/* Module |V| du vecteur vitesse courant. */
Test(IFOU(IL_NE_FAUT_PAS(utiliser_un_milieu_de_propagation)
,IFET(IL_FAUT(utiliser_un_milieu_de_propagation)
,IL_FAUT(arrondir_par_defaut_les_coordonnees_du_M_gradient)
)
)
)
Bblock
EGAL(X,INTE(Xf));
EGAL(Y,INTE(Yf));
EGAL(Z,INTE(Zf));
EGAL(X_anticipe,INTE(Xf_anticipe));
EGAL(Y_anticipe,INTE(Yf_anticipe));
EGAL(Z_anticipe,INTE(Zf_anticipe));
/* Passage aux coordonnees "images". */
Eblock
ATes
Bblock
EGAL(X,ARRI(Xf));
EGAL(Y,ARRI(Yf));
EGAL(Z,ARRI(Zf));
EGAL(X_anticipe,ARRI(Xf_anticipe));
EGAL(Y_anticipe,ARRI(Yf_anticipe));
EGAL(Z_anticipe,ARRI(Zf_anticipe));
/* Passage aux coordonnees "images" (le 19971230124439). */
Eblock
ETes
Test(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
Bblock
#define gINT_EQUA_DIFF_O1(cx,cy,cz,t,h) \
gINTEGRATION_D_UN_SYSTEME_D_EQUATIONS_DIFFERENTIELLES_O1(cx,cy,cz,t,h)
CHRONOMETRAGE_DE_LA_SIMULATION("INTEGRATION DU SYSTEME D'EQUATIONS DIFFERENTIELLES"
,BLOC(gINT_EQUA_DIFF_O1(ASD1(ACCES_VITESSE_COURANTE(corps)
,dx
)
,ASD1(ACCES_VITESSE_COURANTE(corps)
,dy
)
,ASD1(ACCES_VITESSE_COURANTE(corps)
,dz
)
,temps_courant
,DCT_EFFECTIF
);
)
);
#undef gINT_EQUA_DIFF_O1
/* Integration du systeme d'equations differentielles suivant la methode choisie... */
/* ATTENTION, jusqu'a la date du 20000529105344, il y avait ici, par erreur, 'dct' et */
/* non pas 'DCT_EFFECTIF'. */
EDITION_E(BLOC(CAL2(Prin3(" vitesse apres interaction={%+f,%+f,%+f}"
,ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
)
);
)
);
Eblock
ATes
Bblock
Eblock
ETes
# include xrk/rdn_walk.52.I"
/* Gestion du milieu de propagation (reflexion et refraction). */
/* */
/* On notera que ce processus ne fait que modifier : */
/* */
/* ACCES_VITESSE_COURANTE(corps) */
/* */
/* suite a des processus eventuels de nature 'REFLEXION' ou 'REFRACTION'. */
# include xrk/rdn_walk.53.I"
/* Gestion de la marche aleatoire. */
/* */
/* On notera que ce processus modifie simultanement : */
/* */
/* ACCES_VITESSE_COURANTE(corps) */
/* */
/* et : */
/* */
/* ACCES_COORDONNEES_COURANTES(corps) */
/* */
/* suite a des processus eventuels de marche aleatoire. */
/* */
/* ATTENTION, depuis le 19991112155016, les valeurs de 'ACCES_VITESSE_COURANTE(corps) et */
/* donc de 'ACCES_COORDONNEES_COURANTES(corps)' peuvent etre remodifiees ci-apres dans le */
/* cas ou 'IL_FAUT(moyenner_les_vitesses_par_famille)'. */
Eblock
ATes
Bblock
/* Il ne faut pas perturber un corps bloque ou qui n'est pas encore vivant... */
Eblock
ETes
Test(IFLT(numero_effectif_periode_courante_simulation,NOMBRE_EFFECTIF_DE_PERIODES_DE_LA_SIMULATION))
/* ATTENTION : il ne faut surtout pas remplacer ce 'IFLT(...)' par un 'IFLE(...)' a cause */
/* du dimensionnement de 'liste_des_coordonnees_cumule_sur_toute_la_duree' acceder via la */
/* procedure 'ACCES_COORDONNEES_CUMULEES(...)'. */
Bblock
TRANSFERT_POINT_3D(ACCES_COORDONNEES_CUMULEES(corps
,SUCC(numero_effectif_periode_courante_simulation)
)
,ACCES_COORDONNEES_PRECEDENTES(corps)
);
Eblock
ATes
Bblock
Eblock
ETes
EGAL(les_COORDONNEES_CUMULEES_ont_ete_mises_a_jour,VRAI);
/* Ainsi on sait que les 'COORDONNEES_CUMULEES' ont ete mises a jour, sauf lors de la */
/* derniere periode (mais ce n'est pas grave puisqu'elles ne seront plus utilisees, donc */
/* on peut faire comme si elles l'avaient ete et ce afin d'optimiser le cas 'FAUX' qui va */
/* suivre...). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
MOYENNAGE_DES_VITESSES_PAR_FAMILLE;
/* Le 20000308090747, 'MOYENNAGE_DES_VITESSES_PAR_FAMILLE' avait ete mis en tete afin de */
/* s'appliquer aussi aux conditions initiales. En fait, le 20000426151032, il a ete remis */
/* ici (et duplique avant la premiere iteration) car il est plus logique qu'il precede */
/* exactement 'GENERATION_D_UNE_IMAGE_ET_PASSAGE_A_LA_SUIVANTE(...)'. */
PERIODISER_L_UNIVERS;
/* Le 20000426151032, j'ai remarque que 'PERIODISER_L_UNIVERS' devait etre juste derriere */
/* l'appel a 'MOYENNAGE_DES_VITESSES_PAR_FAMILLE' car cette derniere procedure, */
/* lorsqu'elle est utile, recalcule 'ACCES_COORDONNEES_COURANTES(...)'... */
INCREMENTATION_DE_L_HORLOGE(DCT_EFFECTIF);
/* Simulation du temps de la simulation... */
Eblock
ERep
Test(EST_FAUX(les_COORDONNEES_CUMULEES_ont_ete_mises_a_jour))
Bblock
Komp(corps,nombre_de_corps)
Bblock
Test(LE_CORPS_EST_VIVANT(corps))
/* Test introduit le 20160610152047... */
Bblock
TRANSFERT_POINT_3D(ACCES_COORDONNEES_CUMULEES(corps
,SUCC(numero_effectif_periode_courante_simulation)
)
,ACCES_COORDONNEES_CUMULEES(corps
,NEUT(numero_effectif_periode_courante_simulation)
)
);
/* Lorsque les 'COORDONNEES_CUMULEES' n'ont pas ete mises a jour, cela signifie que */
/* le parametre 'nombre_de_pas_de_temps_par_periode' a une valeur nulle. On recupere */
/* alors la valeur de la periode precedente, sauf lors de la derniere periode, ou l'on ne */
/* fait rien (mais ce n'est pas grave puisqu'elles ne seront plus utilisees, c'est fini...). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
ATes
Bblock
Eblock
ETes
INCR(numero_effectif_periode_courante_simulation,I);
/* Gestion du numero effectif de la periode courante... */
Eblock
ERep
#include xrk/attractor.1A.I"
/* Outils de generation des images... */
VISUALISATION_DES_AXES_DE_COORDONNEES;
/* Visualisation si necessaire des trois axes de coordonnees. */
GENERATION_D_UNE_IMAGE_ET_PASSAGE_A_LA_SUIVANTE(BLOC(VIDE;));
/* Generation de l'image courante... */
Eblock
EKom
Test(IL_FAUT(generer_la_geometrie_du_milieu_de_propagation))
Bblock
CALS(Ifloat_std_du_Z_Buffer_accumule(ImageR));
CALi(Iupdate_image(nom_de_la_geometrie_du_milieu_de_propagation,ImageR));
/* Sortie de la geometrie du milieu approximee a l'aide du 'Z Buffer accumule'. */
Eblock
ATes
Bblock
Eblock
ETes
EDEFV(album,champ_de_probabilite);
/* Definition de l'album d'images dans lequel ranger le champ de probabilite... */
EDEFV(album,milieu_de_propagation);
/* Definition de l'album d'images dans lequel ranger le milieu de propagation... */
EDEFV(album,champ_de_force);
/* Definition de l'album d'images dans lequel ranger le champ de force... */
Eblock
end_nouveau_block
FdTb2(liste_des_coordonnees_cumule_sur_toute_la_duree
,nombre_de_corps
,NOMBRE_EFFECTIF_DE_PERIODES_DE_LA_SIMULATION
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_compteurs_de_refractions_a_l_instant_courant
,nombre_de_corps
,Positive
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_compteurs_de_reflexions_a_l_instant_courant
,nombre_de_corps
,Positive
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_compteurs_de_collisions_a_l_instant_courant
,nombre_de_corps
,Positive
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_niveaux_locaux_a_l_instant_courant
,nombre_de_corps
,genere_Float
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_refractions_a_l_instant_courant
,nombre_de_corps
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_reflexions_a_l_instant_courant
,nombre_de_corps
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_blocages_a_l_instant_courant
,nombre_de_corps
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_stabilites_a_l_instant_courant
,nombre_de_corps
,Int
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_vitesses_a_l_instant_courant
,nombre_de_corps
,deltaF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_coordonnees_a_l_instant_courant
,nombre_de_corps
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
Test(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
/* Cette optimisation a ete introduite le 20010904102731 car, en effet, lorsque le */
/* parametre 'nombre_de_corps' est un peu grand, l'espace memoire necessaire a cette */
/* matrice ('matrice_des_distances_a_l_instant_precedent') peut depasser les limites */
/* physiques de la MACHINE utilisee. Or cette matrice n'est que rarement utile... De */
/* plus on notera que lorsqu'elle est necessaire, le parametre 'nombre_de_corps' ne */
/* doit pas etre trop important car sinon, le temps de calcul peut etre redhibitoire */
/* (a cause du calcul des interactions gravitationnelles deux a deux...). */
Bblock
FdTb2(matrice_des_distances_a_l_instant_precedent
,nombre_de_corps
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
Eblock
ATes
Bblock
Eblock
ETes
FdTb1(liste_des_coordonnees_a_l_instant_precedent
,nombre_de_corps
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_vitesses_a_l_instant_initial
,nombre_de_corps
,deltaF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_coordonnees_a_l_instant_initial
,nombre_de_corps
,pointF_3D
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_dates_de_mort
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
FdTb1(liste_des_dates_de_naissance
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Liberation des espaces alloues... */
/* */
/* Les 'ADRESSE_NON_ENCORE_DEFINIE's ont ete introduits le 20050221172504... */
EDITION_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES;
/* Edition facultative des extrema des coordonnees et des derivees. */
Test(IL_FAUT(editer_les_compteurs_de_collisions))
Bblock
CAL2(Prin1("nombre de particules............................................=%d\n"
,nombre_de_corps
)
);
CAL2(Prin1("nombre de particules 'nees' apres l'instant initial.............=%d\n"
,compteur_des_particules_nees_apres_l_instant_initial
)
);
CAL2(Prin1("nombre de collisions de type 'particules-particules'............=%d\n"
,compteur_des_collisions_particules_particules
)
);
CAL2(Prin1("nombre de collisions de type 'particules-milieu'................=%d\n"
,compteur_des_collisions_particules_milieu
)
);
CAL2(Prin1("nombre de particules 'tuees' lors d'une collision avec le milieu=%d\n"
,compteur_des_particules_immobilisees_lors_d_une_collision_avec_le_milieu
)
);
CAL2(Prin0("\n"));
Eblock
ATes
Bblock
Eblock
ETes
RETU_Commande;
Eblock
ECommande