/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/* */
/* Author of '$xrk/rdn_walk.51$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1998??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
#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 */ \
/* '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... */
#include xrk/attractor.14.I"
#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, 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,masse,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(Float,masse));
/* 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_LA_VITESSE_DE_LA_SPHERE_COURANTE(VXf,VYf,VZf);
/* Memorisation de la vitesse du point courant. */
DEFINITION_DE_LA_MASSE_DE_LA_SPHERE_COURANTE(masse);
/* Memorisation de la masse 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 20030313151447). 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'... */
/* */
#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,HUIT)
/* Definition des fichiers de listes de stabilite. La "stabilite" est le nombre de periodes */
/* pendant lequel un corps ne change pas de direction. */
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,fichier_LISTE_CHARGE,CHARGE_IMPLICITE,FU)
#define ACCES_CHARGES(corps) \
IdTb1(liste_initiale_des_CHARGE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition du fichier 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 ACCES_SOURCES_DU_POTENTIEL(corps) \
LOGI(IdTb1(liste_initiale_des_SOURCE_DU_POTENTIEL \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
) \
)
/* Definition du fichier de liste des indicateurs de source gravitationnelle possible. */
#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 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. */
DEFV(pointF_3D,DdTb2(POINTERs
,liste_des_coordonnees_cumule_sur_toute_la_duree
,nombre_de_corps
,nombre_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_de_periodes_de_la_simulation \
)
/* Definition de l'ensemble des instants cumules. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
#include xrk/integr.2B.vv.I"
/* Uniquement afin de definir {cx,cy,cz}. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 si cela est */
/* normal ('VRAI'), ce qui signifie qu'elles n'ont pas encore ete calculee... */
#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 20050722134358... */
#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 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. */
#define TESTER_LES_DETAILS_FINS \
VRAI
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. */
#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_X \
FZERO
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_Y \
FZERO
#define SEUIL_DE_Mgradient_local_tri_dimensionnel_Z \
tgEPSILON
/* 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 das [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... */
/* */
/* Le 20091023085844, '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 20150208081245). */
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... */
#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 si cela est */
/* normal ('VRAI'), ce qui signifie qu'elles n'ont pas encore ete calculee... */
#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 20050722134358... */
#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', ce qui permet de faire de la reflexion a l'interieur du milieu, */
/* lorsque des particules vont du centre vers l'exterieur, par exemple... */
#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', ce qui permet de faire de la reflexion a l'interieur du milieu, */
/* lorsque des particules vont du centre vers l'exterieur, par exemple... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 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 ACCES_COLLISIONNABLES(corps) \
LOGI(IdTb1(liste_initiale_des_COLLISIONNABLE \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_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 \
FDU
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... */
#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"-). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 si cela est */
/* normal ('VRAI'), ce qui signifie qu'elles n'ont pas encore ete calculee... */
#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 20050722134358... */
#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 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, mais inutilise ici mais uniquement dans */
/* 'v $xrk/rdn_walk.52$K tenter_de_synchroniser_les_immobilisations_sur_les_naissances'. */
#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'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 EXPOSANT_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
SE12(TROIS,SIX)
DEFV(Local,DEFV(Float,INIT(exposant_A_distance_interaction_gravitationnelle_generalisee
,EXPOSANT_A_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
#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 EXPOSANT_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
SE12(ZERO,DOUZE)
DEFV(Local,DEFV(Float,INIT(exposant_R_distance_interaction_gravitationnelle_generalisee
,EXPOSANT_R_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
#define TRANSLATION_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
FZERO
DEFV(Local,DEFV(Float,INIT(translation_distance_interaction_gravitationnelle_generalisee
,TRANSLATION_DISTANCE_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* 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 = 6 */
/* */
/* facteur_R = -1.0e-4 */
/* exposant_R = 12 */
/* */
/* qui correspondent a une interaction "Attractive" a longue distante et "Repulsive" a */
/* courte distance.. */
#define MODIFIER_LES_VITESSES_AVEC_L_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
VRAI
DEFV(Local,DEFV(Logical,INIT(modifier_les_vitesses_avec_l_interaction_gravitationnelle_generalisee
,MODIFIER_LES_VITESSES_AVEC_L_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* Indique si l'interaction gravitationnelle (generalisee...) doit modifier les vitesses */
/* ('VRAI') ou pas ('FAUX')... */
#define AJOUTER_LES_VITESSES_AVEC_L_INTERACTION_GRAVITATIONNELLE_GENERALISEE \
VRAI
DEFV(Local,DEFV(Logical,INIT(ajouter_les_vitesses_avec_l_interaction_gravitationnelle_generalisee
,AJOUTER_LES_VITESSES_AVEC_L_INTERACTION_GRAVITATIONNELLE_GENERALISEE
)
)
);
/* Si 'IL_FAUT(modifier_les_vitesses_avec_l_interaction_gravitationnelle_generalisee)', */
/* indique s'il faut cumuler la vitesse avant l'interaction gravitationnelle avec celle */
/* qui resulte de cette interaction ('VRAI') ou pas ('FAUX')... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S D O U Z E 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) : */
/* */
/* 2 ----> ______ */
/* d OA \ C C */
/* i \ i k -----> */
/* M .--------- = G / ------------- A A */
/* i 2 /_____ |----->|n+1 i k */
/* dt k#i | A A | */
/* | i k | */
/* */
/* (avec n=2 pour la "vraie" gravitation) ou */
/* encore : */
/* */
/* 2 ----> ______ */
/* d OA C \ C */
/* i i \ k -----> */
/* --------- = G ---- / ------------- A A */
/* 2 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 second */
/* ordre utilisant les fonctions suivantes : */
/* */
/* F = 1 */
/* 3X */
/* i */
/* */
/* F = 0 */
/* 2X */
/* i */
/* ______ */
/* C \ C X */
/* i \ k k */
/* F = -G ---- / -------------------------------------------(---- - 1) */
/* 1X M /_____ | | n+1 X */
/* i i k#i | |----- i */
/* | 2 2 2| 2 */
/* |(X - X ) + (Y - Y ) + (Z - Z )| */
/* | k i k i k i | */
/* */
/* F = 0 */
/* 0X */
/* i */
/* */
/* avec bien entendu des formules equivalentes */
/* pour les coordonnees 'Y' et 'Z'... */
/* */
/*************************************************************************************************************************************/
#define vitesse_courante_corps_avant_integration \
vitesse_courante_corpsI_avant_integration
DEFV(deltaF_3D,vitesse_courante_corpsI_avant_integration);
/* Afin de connaitre la vitesse de 'corpsI' (appele 'corps') a l'appel des trois fonctions */
/* 'F1X(...)', 'F1Y(...)' et 'F1Z(...)'. En effet, n'oublions pas qu'il y a des risques que */
/* 'ACCES_VITESSE_COURANTE(corpsI)' soit modifiee par 'COLLISION_ENTRE_DEUX_CORPS(...)' */
/* ci-apres ; il est donc essentiel que ces modifications soient reportees la ou la valeur */
/* de 'vitesse_courante_corps_avant_integration' est initialisee, puis exploitee en retour */
/* de l'integration du systeme d'equations differentielles... */
#define F3(coordonnees) \
FU
#define F2(coordonnees) \
FZERO
#define F1(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 'F1X(...)', */ \
/* 'F1Y(...)' et 'F1Z(...)' la valeur de la variable 'corps'... */ \
/*-----------------------------------------------------------------------------------------------------------------------------------*/ \
Bblock \
DEFV(Float,INIT(cumul_courant,FZERO)); \
/* Valeur de la fonction. */ \
DEFV(Int,INIT(corpsK,UNDEF)); \
/* Index des corps... */ \
/*..............................................................................................................................*/ \
\
Komp(corpsK,nombre_de_corps) \
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) \
) \
) \
) \
) \
) \
/* ATTENTION, jusqu'au 19980928170946, il y avait ici : */ \
/* */ \
/* Test(IZNE(ACCES_DISTANCES_PRECEDENTES(corpsI,corpsK))) */ \
/* */ \
/* mais il s'agit d'etre homogene avec ce qui est utilise dans 'v $xrk/rdn_walk.51$I' */ \
/* dans la gestion des collision, d'ou cette nouvelle version... */ \
/* */ \
/* ATTENTION, le 19981021101413 a ete introduit le 'TOUJOURS_FAUX' afin que la premiere */ \
/* altenative de ce 'Test(...)' ne soit jamais executee mais malgre tout conservee (on ne */ \
/* sait jamais...). Cette sequence a ete reprise dans 'v $xrr/N_corps.11$K F1' ; or la */ \
/* gestion des collisions est deja prise en compte dans 'v $xrk/rdn_walk.51$I'. Elle ne */ \
/* doit donc apparaitre qu'une seule fois... */ \
/* */ \
/* ATTENTION, le 19981026100641 ce 'TOUJOURS_FAUX' a ete remplace par une option car cela */ \
/* semble utile... */ \
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'... */ \
TRANSFERT_ACCROISSEMENT_3D(vitesse_courante_corpsI_avant_integration \
,ACCES_VITESSE_COURANTE(corpsI) \
); \
/* Et mise a jour de la vitesse de 'corpsI'. Il est logique de faire cela car, en effet, */ \
/* 'COLLISION_ENTRE_DEUX_CORPS(...)' a modifie 'ACCES_VITESSE_COURANTE(corpsK)', il faut */ \
/* que 'vitesse_courante_corpsI_avant_integration' qui contient donc effectivement */ \
/* 'ACCES_VITESSE_COURANTE(corpsI)' avant l'integration soit mise a jour... */ \
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 \
Test(IZNE(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),coordonnees))) \
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 \
,MUL2(MUL2(ACCES_CHARGES(corpsK) \
,LIN2(facteur_A_distance_interaction_gravitationnelle_generalisee \
,PUIX(inverse_de_la_distance_I_K_precedente \
,exposant_A_distance_interaction_gravitationnelle_generalisee \
) \
,facteur_R_distance_interaction_gravitationnelle_generalisee \
,PUIX(inverse_de_la_distance_I_K_precedente \
,exposant_R_distance_interaction_gravitationnelle_generalisee \
) \
,translation_distance_interaction_gravitationnelle_generalisee \
) \
) \
,SOUS(DIVI(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsK),coordonnees) \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),coordonnees) \
) \
,FU \
) \
) \
); \
/* Ainsi, la fonction habituelle de la gravitation : */ \
/* */ \
/* 1 */ \
/* --------- */ \
/* 3 */ \
/* d(i,k) */ \
/* */ \
/* est generalisee en : */ \
/* */ \
/* F F */ \
/* A R */ \
/* ---------- + ---------- + T */ \
/* E E */ \
/* 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 \
ATes \
Bblock \
PRINT_ATTENTION("un corps est sur un axe"); \
CAL1(Prer1("pour la coordonnee coordonnees du corps %d\n",corpsI)); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EKom \
\
RETU(MUL3(NEGA(constante_de_la_gravitation_generalisee) \
,DIVI(ACCES_CHARGES(corpsI),ACCES_MASSES(corpsI)) \
,cumul_courant \
) \
); \
Eblock
#define F0(coordonnees) \
FZERO
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S Q U A T R E F O N C T I O N S ' F ' : */
/* ?x */
/* */
/*************************************************************************************************************************************/
#define F3X(corpsI) \
F3(x)
#define F2X(corpsI) \
F2(x)
BFonctionF
F1(F1X,x)
EFonctionF
#define F0X(corpsI) \
F0(x)
#define F3x(cx,cy,cz,t) \
F3X(corps)
#define F2x(cx,cy,cz,t) \
F2X(corps)
#define F1x(cx,cy,cz,t) \
F1X(corps)
#define F0x(t) \
F0X(corps)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S Q U A T R E F O N C T I O N S ' F ' : */
/* ?y */
/* */
/*************************************************************************************************************************************/
#define F3Y(corpsI) \
F3(y)
#define F2Y(corpsI) \
F2(y)
BFonctionF
F1(F1Y,y)
EFonctionF
#define F0Y(corpsI) \
F0(y)
#define F3y(cx,cy,cz,t) \
F3Y(corps)
#define F2y(cx,cy,cz,t) \
F2Y(corps)
#define F1y(cx,cy,cz,t) \
F1Y(corps)
#define F0y(t) \
F0Y(corps)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S Q U A T R E F O N C T I O N S ' F ' : */
/* ?z */
/* */
/*************************************************************************************************************************************/
#define F3Z(corpsI) \
F3(z)
#define F2Z(corpsI) \
F2(z)
BFonctionF
F1(F1Z,z)
EFonctionF
#define F0Z(corpsI) \
F0(z)
#define F3z(cx,cy,cz,t) \
F3Z(corps)
#define F2z(cx,cy,cz,t) \
F2Z(corps)
#define F1z(cx,cy,cz,t) \
F1Z(corps)
#define F0z(t) \
F0Z(corps)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 20030313151447, '__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"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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_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_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_CHARGE,CHARGE_IMPLICITE);
/* Initialisation du fichier 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_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). */
#include xrv/champs_5.1A.I"
GET_ARGUMENTSv(nombre_d_arguments
,BLOC(PROCESS_ARGUMENT_I("nombre_points=""npoints=""iterations=""corps=",nombre_de_corps
/* Le 20111211100304, 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_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_CHARGE="
,fichier_LISTE_CHARGE
,liste_initiale_des_CHARGE
,CHARGE_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("history=""editer_evenements=",editer_les_evenements);
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_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("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("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);
GIT_ARGUMENT_F("Mtolerance="
,M_gradient_tridimensionnel_non_simplifie_tolerance
,M_GRADIENT_TRIDIMENSIONNEL_NON_SIMPLIFIE_TOLERANCE
);
/* Le 20091023085844, 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 20150208081245... */
GET_ARGUMENT_L("Mattendre=",M_attendre_les_images_inexistantes);
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_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("tuer=""mort_immobilisable=",faire_mourir_les_particules_immobilisables);
GET_ARGUMENT_F("interaction=",seuil_d_interaction);
GET_ARGUMENT_L("collisions=",gerer_les_collisions);
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_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_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("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("translation_gravitation=""translation_forces_A_R="
,translation_distance_interaction_gravitationnelle_generalisee
);
GET_ARGUMENT_L("modifier_vitesses=",modifier_les_vitesses_avec_l_interaction_gravitationnelle_generalisee);
GET_ARGUMENT_L("ajouter_vitesses=",ajouter_les_vitesses_avec_l_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_F("dt=""dct=",dct);
GET_ARGUMENT_I("nombre=",nombre_de_pas_de_temps_par_periode);
PROCESS_ARGUMENTS_DE_VISUALISATION;
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(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_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(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
);
MdTb2(matrice_des_distances_a_l_instant_precedent
,nombre_de_corps
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* 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_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"... */
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(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
Bblock
INITIALISATION_DE_L_INTEGRATION_D_UN_SYSTEME_D_EQUATIONS_DIFFERENTIELLES_O2;
/* Initialisations necessaires a discriminer les deux premiers pas de temps... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IFNE(ACCES_LISTE(liste_initiale_des_STABILITE,corps)
,INTE(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
#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
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
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
,NE_PAS_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_UN_ALBUM
,F_premiere_coupe,F_pas_des_coupes
,NE_PAS_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM
,F_niveau_initial_du_champ_de_force
);
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
,NE_PAS_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_UN_ALBUM
,M_premiere_coupe,M_pas_des_coupes
,NE_PAS_INVERSER_L_ORDRE_DES_COUPES_DANS_ACCES_ALBUM
,M_niveau_initial_du_milieu_de_propagation
);
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
,NE_PAS_AUTORISER_LES_SEQUENCES_INCOMPLETES_DANS_UN_ALBUM
,P_premiere_coupe,P_pas_des_coupes
,NE_PAS_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... */
INITIALISATIONS_RELATIVES_A_CHAQUE_NOUVELLE_IMAGE(numero_de_la_periode_courante);
/* Initialisations necessaires avant le calcul et la generation de chaque nouvelle image. */
DoIn(periode
,COND(IL_FAUT(visualiser_l_ensemble_des_instants)
,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION
,numero_de_la_periode_courante_de_la_simulation
)
,numero_de_la_periode_courante_de_la_simulation
,I
)
Bblock
Komp(corps,nombre_de_corps)
Bblock
Test(IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant))
Bblock
EGAL(rayon_de_visualisation,ACCES_LISTE(liste_initiale_des_RAYON,corps));
/* Recuperation eventuelle du rayon de chaque point... */
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,ACCES_LISTE(liste_initiale_des_ROUGE,corps));
EGAL(dcy,ACCES_LISTE(liste_initiale_des_VERTE,corps));
EGAL(dcz,ACCES_LISTE(liste_initiale_des_BLEUE,corps));
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_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
Repe(COND(IFGT(numero_de_la_periode_courante_de_la_simulation,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION)
,NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE_EFFECTIF
,ADD2(NOMBRE_DE_PAS_DE_TEMPS_PAR_PERIODE_EFFECTIF,UN_TOUR_DE_PLUS)
)
)
/* 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)))
,IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant)
)
)
Bblock
/* Cas d'un corps non bloque, mobile et qui est vivant... */
#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)
#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)
DEFV(deltaF_3D,deplacement_elementaire_dans_les_champs_avec_les_positions);
DEFV(deltaF_3D,deplacement_elementaire_dans_les_champs_avec_la_vitesse);
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 leux vitesses, il a ete necessaire de rajouter un deuxieme test du type : */
/* */
/* C(t) - C(t-dt) */
/* */
/* ou 'C' designe une coordonnee quelconque... */
#undef Z_VITESSE
#undef Y_VITESSE
#undef X_VITESSE
#undef Z_POSITION_COURANTE
#undef Y_POSITION_COURANTE
#undef X_POSITION_COURANTE
#undef X_POSITION_PRECEDENTE
#undef Y_POSITION_PRECEDENTE
#undef Z_POSITION_PRECEDENTE
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("le pas de temps est trop grand et 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
Komp(corpsI,nombre_de_corps)
Bblock
Komp(corpsJ,nombre_de_corps)
Bblock
Test(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
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
Eblock
ETes
#define AGGREGATION_EVENTUELLE_PAR_COLLAGE_LORS_DES_COLLISIONS \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Il ne peut y avoir aggregation par collage lors des collisions... */
#define PROPAGATION_EVENTUELLE_DES_COULEURS_LORS_DES_COLLISIONS \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Il ne peut y avoir propagation des couleurs lors des collisions... */
#include xrk/rdn_walk.51.I"
GESTION_DES_AGGREGATIONS_ET_DES_COLLISIONS;
/* Gestion de l'aggregation et des collisions entre corps. */
Eblock
EKom
Eblock
EKom
Komp(corps,nombre_de_corps)
Bblock
EDITION_E(BLOC(CAL2(Prin3("periode=%d t=%f corps=%d\n"
,numero_de_la_periode_courante_de_la_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)))
,IFLE(ACCES_DATES_DE_NAISSANCE(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. */
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
TRANSFERT_ACCROISSEMENT_3D(vitesse_courante_corps_avant_integration
,ACCES_VITESSE_COURANTE(corps)
);
/* Sauvegarde de la vitesse precedente avant l'integration, sachant que celle-ci peut etre */
/* modifiee par 'COLLISION_ENTRE_DEUX_CORPS(...)' dans le processus d'integration qui va */
/* suivre... */
# include xrr/N_corps.12.I"
/* Integration du systeme d'equations differentielles pour le corps courant 'corps'. */
/* On notera que ce processus modifie simultanement : */
/* */
/* ACCES_VITESSE_COURANTE(corps) */
/* */
/* et : */
/* */
/* ACCES_COORDONNEES_COURANTES(corps) */
/* */
/* suite a des processus eventuels d'interaction entre les differents corps. */
Test(IL_FAUT(modifier_les_vitesses_avec_l_interaction_gravitationnelle_generalisee))
Bblock
Test(IL_FAUT(ajouter_les_vitesses_avec_l_interaction_gravitationnelle_generalisee))
Bblock
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps)
,ADD2(ASD1(vitesse_courante_corps_avant_integration,dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dx)
)
,ADD2(ASD1(vitesse_courante_corps_avant_integration,dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
)
,ADD2(ASD1(vitesse_courante_corps_avant_integration,dz)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
)
);
/* Cas ou l'on fait la somme vectorielle entre la 'ACCES_VITESSE_COURANTE(corps)' resultant */
/* de l'integration et la vitesse tel qu'elle etait avant cette integration, sachant que */
/* celle-ci a pu etre modifiee par 'COLLISION_ENTRE_DEUX_CORPS(...)' dans le processus */
/* d'integration qui precede... */
Eblock
ATes
Bblock
/* Cas ou la 'ACCES_VITESSE_COURANTE(corps)' resultant de l'integration est conservee tel */
/* qu'elle a ete calculee... */
Eblock
ETes
Eblock
ATes
Bblock
TRANSFERT_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps)
,vitesse_courante_corps_avant_integration
);
/* Restauration de la vitesse telle qu'elle etait avant l'integration car, en effet, dans ce */
/* processus elle est approximee par une difference de position et fait perdre donc la trace */
/* du milieu de propagation. */
Eblock
ETes
TRANSFERT_POINT_3D(ACCES_COORDONNEES_PRECEDENTES(corps)
,ACCES_COORDONNEES_COURANTES(corps)
);
/* Pour les deux processus suivants... */
EDITION_E(BLOC(CAL2(Prin3(" coordonnees apres interaction={%+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 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. */
Eblock
ATes
Bblock
/* Il ne faut pas perturber un corps bloque ou qui n'est pas encore vivant... */
Eblock
ETes
Test(IFLT(numero_de_la_periode_courante_de_la_simulation,nombre_de_periodes_de_la_simulation))
Bblock
TRANSFERT_POINT_3D(ACCES_COORDONNEES_CUMULEES(corps
,SUCC(numero_de_la_periode_courante_de_la_simulation)
)
,ACCES_COORDONNEES_PRECEDENTES(corps)
);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
INCREMENTATION_DE_L_HORLOGE(DCT_EFFECTIF);
/* Simulation du temps de la simulation... */
Test(IL_FAUT(faire_de_l_interaction_gravitationnelle_generalisee))
Bblock
GESTION_DE_L_INTEGRATION_D_UN_SYSTEME_D_EQUATIONS_DIFFERENTIELLES_O2;
/* Gestion de la discrimination des deux premiers pas de temps... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ERep
#include xrk/attractor.1A.I"
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
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_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
);
FdTb2(matrice_des_distances_a_l_instant_precedent
,nombre_de_corps
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
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 20050221172247... */
EDITION_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES;
/* Edition facultative des extrema des coordonnees et des derivees. */
RETU_Commande;
Eblock
ECommande