/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/* */
/* Author of '$xrk/rdn_walk.31$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1996??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 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'. */
#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
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 20030313150807). 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 A M A R C H E A L E A T O I R E : */
/* */
/* */
/* Definition : */
/* */
/* Soit la famille {C ,C ,...,C } de 'N' */
/* 1 2 N */
/* corps. A chaque pas de temps, et en coordonnees */
/* spheriques, les coordonnees de ceux-ci sont */
/* translatees a l'aide de trois increments en */
/* 'theta', 'phi' et 'rho'. */
/* */
/* */
/*************************************************************************************************************************************/
#define LIMITER_AUTOMATIQUEMENT_TENTATIVES_RECHERCHE_BONNE_PERTURBATION \
VRAI
DEFV(Local,DEFV(Logical,INIT(limiter_automatiquement_tentatives_recherche_bonne_perturbation
,LIMITER_AUTOMATIQUEMENT_TENTATIVES_RECHERCHE_BONNE_PERTURBATION
)
)
);
#define NOMBRE_MAXIMAL_DE_TENTATIVES_DE_RECHERCHE_D_UNE_BONNE_PERTURBATION \
CENT
DEFV(Local,DEFV(Int,INIT(nombre_maximal_de_tentatives_de_recherche_d_une_bonne_perturbation
,NOMBRE_MAXIMAL_DE_TENTATIVES_DE_RECHERCHE_D_UNE_BONNE_PERTURBATION
)
)
);
/* Lors de la recherche d'une vitesse perturbee satisfaisant aux contraintes imposees (dues */
/* au champ de force et a la distance maximale par rapport a l'origine), lorsque celles-ci */
/* ne peuvent etre satisfaites, il faut imposer un nombre maximal de tentatives afin de ne */
/* pas boucler. Ce nombre peut etre calcule automatiquement a partir des parametres, ou bien */
/* etre impose arbitrairement (l'etat implicite est 'VRAI' afin d'assurer la compatibilite */
/* avec les anciennes sequences generees avant le 1995110200). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C O N S T A N T E S D U P R O B L E M E : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S L I S T E S D E S C R I P T I V E S I N I T I A L E S D E S C O R P S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, a ne pas confondre : */
/* */
/* 1-'nombre_de_periodes_de_la_simulation' qui definit finalement le nombre d'images que */
/* l'on va generer et qui conditionne toutes les listes (sans exception...) definies par */
/* 'fTRANSFORMAT_31(...)', et */
/* */
/* 2-'nombre_d_iterations' qui definit le nombre de particules visualisees dans chaque */
/* image ; les listes relatives aux particules sont definies elles-aussi a l'aide de la */
/* procedure 'dTRANSFORMAT_31(...)' ce qui signifie que 'nombre_d_iterations' est limite */
/* par 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION'... */
/* */
dfTRANSFORMAT_31(liste_initiale_des_DATE_DE_NAISSANCE,fichier_LISTE_DATE_DE_NAISSANCE,DATE_DE_NAISSANCE_IMPLICITE,INSTANT_INITIAL)
/* Definition des fichiers de listes de dates de naissance. */
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. */
/* Pour les 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_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 changera pas de direction). */
dfTRANSFORMAT_31(liste_initiale_des_RAYON,fichier_LISTE_RAYON,RAYON_IMPLICITE,RAYON_DE_VISUALISATION)
/* Definition du fichier de liste des rayons. */
/* */
/* ATTENTION, le rayon est en unite d'ecran [0,1]. */
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] */
/* */
#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). */
#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
)
);
DEFV(pointF_3D,DdTb1(POINTERs
,liste_des_coordonnees_a_l_instant_initial
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
DEFV(deltaF_3D,DdTb1(POINTERs
,liste_des_vitesses_a_l_instant_initial
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
/* Definition de l'instant initial. */
DEFV(pointF_3D,DdTb1(POINTERs
,liste_des_coordonnees_a_l_instant_precedent
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
/* Definition de l'instant precedent. */
DEFV(deltaF_3D,DdTb1(POINTERs
,liste_des_vitesses_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
DEFV(pointF_3D,DdTb1(POINTERs
,liste_des_coordonnees_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
DEFV(Int,DdTb1(POINTERi
,liste_des_stabilites_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
DEFV(Logical,DdTb1(POINTERl
,liste_des_blocages_a_l_instant_courant
,nombre_de_corps
,ADRESSE_NON_ENCORE_DEFINIE
)
);
/* 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
)
);
/* 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. */
#define ACCES_DATES_DE_NAISSANCE(corps) \
IdTb1(liste_des_dates_de_naissance \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_COORDONNEES_INITIALES(corps) \
IdTb1(liste_des_coordonnees_a_l_instant_initial \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_VITESSE_INITIALE(corps) \
IdTb1(liste_des_vitesses_a_l_instant_initial \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Acces aux caracteristiques du corps de numero donne 'corps' dans sa position initiale. */
#define ACCES_COORDONNEES_PRECEDENTES(corps) \
IdTb1(liste_des_coordonnees_a_l_instant_precedent \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Definition de l'instant precedent. */
#define ACCES_VITESSE_COURANTE(corps) \
IdTb1(liste_des_vitesses_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_COORDONNEES_COURANTES(corps) \
IdTb1(liste_des_coordonnees_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_STABILITES_COURANTES(corps) \
IdTb1(liste_des_stabilites_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
#define ACCES_BLOCAGES_COURANTS(corps) \
IdTb1(liste_des_blocages_a_l_instant_courant \
,INDX(corps,PREMIER_POINT_DES_LISTES) \
,nombre_de_corps \
)
/* Acces aux caracteristiques du corps de numero donne 'corps' dans sa position courante. */
#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 \
)
/* Acces aux coordonnees sur l'ensemble de la simulation. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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. */
#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 20050721094908... */
#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 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 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'). */
#define GENERER_DES_DiffusionLimitedAggregation \
VRAI
DEFV(Local,DEFV(Logical,INIT(generer_des_DiffusionLimitedAggregation,GENERER_DES_DiffusionLimitedAggregation)));
/* Indique s'il faut generer des 'DLA' ('VRAI') ou pas ('FAUX')... */
#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 20050721094908... */
#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(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 20030313150807, '__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 : */
/* */
/*************************************************************************************************************************************/
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_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);
/* Initialisation des fichiers de dates de naissance. */
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_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 listes de distances maximales. */
iTRANSFORMAT_31(liste_initiale_des_STABILITE,STABILITE_IMPLICITE);
/* Initialisation des fichiers de listes de stabilite. */
iTRANSFORMAT_31(liste_initiale_des_RAYON,RAYON_IMPLICITE);
/* Initialisation du fichier de liste des rayons. */
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. */
#include xrv/champs_5.1A.I"
GET_ARGUMENTSv(nombre_d_arguments
,BLOC(PROCESS_ARGUMENT_I("nombre_points=""npoints=""iterations=""corps=",nombre_de_corps
/* Le 20111211100120, 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_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_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_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
);
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("force=",utiliser_un_champ_de_force);
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_F("interaction=",seuil_d_interaction);
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_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_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
MdTb1(liste_des_dates_de_naissance
,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
);
/* 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
);
/* 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
);
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
);
/* Definition de l'ensemble des instants cumules. */
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));
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(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_BLOCAGES_COURANTS(corps),FAUX);
/* Les corps ne sont actuellement pas bloques... */
Eblock
EKom
begin_nouveau_block
Bblock
BDEFV(album,champ_de_force);
/* Definition de l'album d'images dans lequel ranger le champ de force... */
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_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_1_point_07(DECENTRAGE_DES_COORDONNEES(cx,X,x)
,DECENTRAGE_DES_COORDONNEES(cy,Y,y)
,DECENTRAGE_DES_COORDONNEES(cz,Z,z)
,dcx
,dcy
,dcz
,corps
)
);
/* Memorisation du corps courant, la premiere image donnant les conditions initiales... */
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
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
,ADD2(nombre_de_pas_de_temps_par_periode,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
Komp(corpsI,nombre_de_corps)
Bblock
Komp(corpsJ,nombre_de_corps)
Bblock
Test(IFET(IFNE(corpsI,corpsJ)
,IFET(IFLE(ACCES_DATES_DE_NAISSANCE(corpsI),temps_courant)
,IFLE(ACCES_DATES_DE_NAISSANCE(corpsJ),temps_courant)
)
)
)
Bblock
Test(IFLT(RpdisF3D(ACCES_COORDONNEES_PRECEDENTES(corpsI)
,ACCES_COORDONNEES_PRECEDENTES(corpsJ)
)
,seuil_d_interaction
)
)
Bblock
/* Cas ou les deux corps 'I' et 'J' sont proches l'un de l'autre : */
DEFV(Float,INIT(probabilite_d_interaction,PROBABILITE_UNITE));
DEFV(Float,INIT(seuil_de_la_probabilite_d_interaction,PROBABILITE_NULLE));
/* A priori, l'evenement est certain... */
Test(IL_FAUT(utiliser_un_champ_de_probabilite))
Bblock
DEFV(Int
,INIT(X
,gX_PHYSIQUE_A_VISUALISATION(MOYE(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),x)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsJ),x)
)
,FZERO
)
)
);
DEFV(Int
,INIT(Y
,gY_PHYSIQUE_A_VISUALISATION(MOYE(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),y)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsJ),y)
)
,FZERO
)
)
);
DEFV(Int
,INIT(Z
,gZ_PHYSIQUE_A_VISUALISATION(MOYE(ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsI),z)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corpsJ),z)
)
,FZERO
)
)
);
/* Positionnement dans le champ de probabilite. */
EGAL(probabilite_d_interaction
,______NORMALISE_NIVEAU(FAload_point(champ_de_probabilite
,X,Y,Z
,P_periodiser_X,P_periodiser_Y,P_periodiser_Z
,P_symetriser_X,P_symetriser_Y,P_symetriser_Z
,P_prolonger_X,P_prolonger_Y,P_prolonger_Z
,P_niveau_hors_du_champ_de_probabilite
)
)
);
GENERATION_D_UNE_VALEUR(seuil_de_la_probabilite_d_interaction
,PROBABILITE_NULLE
,PROBABILITE_UNITE
);
/* Calcul de la probabilite locale d'interaction a "mi-chemin" entre les corps 'I' et 'J'. */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFGT(probabilite_d_interaction,seuil_de_la_probabilite_d_interaction))
/* Cas ou il y a interaction... */
Bblock
Test(IL_FAUT(generer_des_DiffusionLimitedAggregation))
Bblock
/* Cas ou l'on genere des 'DLA' : */
EGAL(ACCES_BLOCAGES_COURANTS(corpsI),VRAI);
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corpsI)
,FZERO
,FZERO
,FZERO
);
EGAL(ACCES_BLOCAGES_COURANTS(corpsJ),VRAI);
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corpsJ)
,FZERO
,FZERO
,FZERO
);
/* Les deux corps 'I' et 'J' etant proches l'un de l'autre, ils sont bloques. */
Eblock
ATes
Bblock
/* Cas ou l'on ne genere pas des 'DLA' : pour le moment, on ne fait rien... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou il n'y a pas d'interaction... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou les deux corps 'I' et 'J' sont eloignes l'un de l'autre : rien a faire... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EKom
Eblock
EKom
Komp(corps,nombre_de_corps)
Bblock
TRANSFERT_POINT_3D(ACCES_COORDONNEES_PRECEDENTES(corps)
,ACCES_COORDONNEES_COURANTES(corps)
);
Test(IFET(EST_FAUX(ACCES_BLOCAGES_COURANTS(corps))
,IFLE(ACCES_DATES_DE_NAISSANCE(corps),temps_courant)
)
)
Bblock
/* Cas d'un corps non bloque et qui est vivant.. */
Test(IZEQ(ACCES_STABILITES_COURANTES(corps)))
Bblock
DEFV(Int,INIT(decompteur_de_recherche_d_une_bonne_perturbation
,COND(IL_FAUT(limiter_automatiquement_tentatives_recherche_bonne_perturbation)
,EXP2(MUL3(NBRE(ACCES_LISTE(liste_initiale_des_MINIMUM_DELTA_RHO,corps)
,ACCES_LISTE(liste_initiale_des_MAXIMUM_DELTA_RHO,corps)
)
,NBRE(ACCES_LISTE(liste_initiale_des_MINIMUM_N_PHI,corps)
,ACCES_LISTE(liste_initiale_des_MAXIMUM_N_PHI,corps)
)
,NBRE(ACCES_LISTE(liste_initiale_des_MINIMUM_N_THETA,corps)
,ACCES_LISTE(liste_initiale_des_MAXIMUM_N_THETA,corps)
)
)
)
,nombre_maximal_de_tentatives_de_recherche_d_une_bonne_perturbation
)
)
);
DEFV(Logical,INIT(chercher_une_bonne_perturbation,VRAI));
/* Afin de boucler tant que l'on n'a pas trouve une perturbation qui ne nous eloigne */
/* pas trop du centre de l'espace. La valeur du decompteur est relativement arbitraire */
/* et est destinee a eviter des bouclages sans fin... */
DEFV(Float,INIT(rho
,Rho_3D(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
)
)
);
DEFV(Float,INIT(phi
,Phi_3D(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
)
)
);
DEFV(Float,INIT(theta
,Theta_3D(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,ASD1(ACCES_VITESSE_COURANTE(corps),dz)
)
)
);
/* Passage des coordonnees cartesiennes aux coordonnees spheriques pour le vecteur vitesse */
/* du corps courant. */
DEFV(deltaF_3D,vitesse_perturbee);
/* Vitesse perturbee (et eventuellement provisoire) du corps courant en coordonnees */
/* cartesiennes. */
Test(IZLE(decompteur_de_recherche_d_une_bonne_perturbation))
Bblock
EGAL(decompteur_de_recherche_d_une_bonne_perturbation
,COND(IZGT(nombre_maximal_de_tentatives_de_recherche_d_une_bonne_perturbation)
,nombre_maximal_de_tentatives_de_recherche_d_une_bonne_perturbation
,NOMBRE_MAXIMAL_DE_TENTATIVES_DE_RECHERCHE_D_UNE_BONNE_PERTURBATION
)
);
Eblock
ATes
Bblock
Eblock
ETes
Tant(IL_FAUT(chercher_une_bonne_perturbation))
Bblock
DEFV(Float,INIT(distance_courante_a_l_origine,FLOT__UNDEF));
DEFV(Float,INIT(distance_precedente_a_l_origine,FLOT__UNDEF));
/* Afin de savoir si l'on s'eloigne de l'origine... */
DEFV(Float,INIT(rho_perturbe,FLOT__UNDEF));
DEFV(Float,INIT(phi_perturbe,FLOT__UNDEF));
DEFV(Float,INIT(theta_perturbe,FLOT__UNDEF));
/* Vitesse perturbee (et eventuellement provisoire) du corps courant en coordonnees */
/* spheriques. */
DEFV(Float,INIT(variation_de_rho,FLOT__UNDEF));
DEFV(Float,INIT(variation_de_phi,FLOT__UNDEF));
DEFV(Float,INIT(variation_de_theta,FLOT__UNDEF));
GENERATION_D_UNE_VALEUR(variation_de_rho
,ACCES_LISTE(liste_initiale_des_MINIMUM_DELTA_RHO,corps)
,ACCES_LISTE(liste_initiale_des_MAXIMUM_DELTA_RHO,corps)
);
GENERATION_D_UNE_VALEUR(variation_de_phi
,ACCES_LISTE(liste_initiale_des_MINIMUM_N_PHI,corps)
,ACCES_LISTE(liste_initiale_des_MAXIMUM_N_PHI,corps)
);
GENERATION_D_UNE_VALEUR(variation_de_theta
,ACCES_LISTE(liste_initiale_des_MINIMUM_N_THETA,corps)
,ACCES_LISTE(liste_initiale_des_MAXIMUM_N_THETA,corps)
);
EGAL(variation_de_phi
,MUL2(ARRO(variation_de_phi),ACCES_LISTE(liste_initiale_des_DELTA_PHI,corps))
);
EGAL(variation_de_theta
,MUL2(ARRO(variation_de_theta),ACCES_LISTE(liste_initiale_des_DELTA_THETA,corps))
);
/* Variations aleatoires des coordonnees spheriques du vecteur vitesse du corps courant. */
EGAL(rho_perturbe,ADD2(rho,variation_de_rho));
EGAL(phi_perturbe,ADD2(phi,variation_de_phi));
EGAL(theta_perturbe,ADD2(theta,variation_de_theta));
/* Vitesse perturbee (et eventuellement provisoire) du corps courant (en coordonnees */
/* spheriques). */
INITIALISATION_ACCROISSEMENT_3D(vitesse_perturbee
,Xcartesienne_3D(rho_perturbe,phi_perturbe,theta_perturbe)
,Ycartesienne_3D(rho_perturbe,phi_perturbe,theta_perturbe)
,Zcartesienne_3D(rho_perturbe,phi_perturbe,theta_perturbe)
);
/* Vitesse perturbee (et eventuellement provisoire) du corps courant (en coordonnees */
/* cartesiennes). */
INITIALISATION_POINT_3D(ACCES_COORDONNEES_COURANTES(corps)
,AXPB(ASD1(vitesse_perturbee,dx)
,dct
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
)
,AXPB(ASD1(vitesse_perturbee,dy)
,dct
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
)
,AXPB(ASD1(vitesse_perturbee,dz)
,dct
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
)
);
/* Nouvelle position provisoire et perturbee du corps courant... */
Test(IL_FAUT(utiliser_un_champ_de_force))
Bblock
/* Cas ou l'on utilise un champ de force : on va examiner son gradient, puis on utilisera */
/* ensuite la distance a l'origine via 'liste_initiale_des_DISTANCE_MAXIMALE'. */
DEFV(Int
,INIT(X
,gX_PHYSIQUE_A_VISUALISATION(ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
,FZERO
)
)
);
DEFV(Int
,INIT(Y
,gY_PHYSIQUE_A_VISUALISATION(ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
,FZERO
)
)
);
DEFV(Int
,INIT(Z
,gZ_PHYSIQUE_A_VISUALISATION(ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
,FZERO
)
)
);
/* Positionnement dans le champ de force. */
DEFV(deltaF_3D,gradient_local_tri_dimensionnel);
/* Gradient local (Gx,Gy,Gz). */
DEFV(Float,INIT(module_du_gradient_local_tri_dimensionnel,FLOT__UNDEF));
/* Module |G| du gradient local (Gx,Gy,Gz). */
DEFV(Float,INIT(module_de_la_vitesse_perturbee,FLOT__UNDEF));
/* Module |V| de la vitesse perturbee. */
DEFV(Float,INIT(cosinus_vitesse_gradient,FLOT__UNDEF));
DEFV(Float,INIT(angle_vitesse_gradient,FLOT__UNDEF));
DEFV(Float,INIT(borne_inferieure_de_l_ouverture,FLOT__UNDEF));
DEFV(Float,INIT(borne_superieure_de_l_ouverture,FLOT__UNDEF));
/* Angle entre la vitesse perturbee et le gradient local et ses bornes inferieure et */
/* superieure courantes. */
#define champ_F \
champ_de_force
#define PreX(x) \
nPREX(x,F_NpasX)
#define SucX(x) \
nSUCX(x,F_NpasX)
#define PreY(y) \
nPREY(y,F_NpasY)
#define SucY(y) \
nSUCY(y,F_NpasY)
#define PreZ(z) \
nPREZ(z,F_NpasZ)
#define SucZ(z) \
nSUCZ(z,F_NpasZ)
#define FALOAD_POINT(champ,x,y,z) \
______NORMALISE_NIVEAU(FAload_point(champ \
,x,y,z \
,F_periodiser_X,F_periodiser_Y,F_periodiser_Z \
,F_symetriser_X,F_symetriser_Y,F_symetriser_Z \
,F_prolonger_X,F_prolonger_Y,F_prolonger_Z \
,F_niveau_hors_du_champ_de_force \
) \
)
/* Pour reduire la longueur des lignes qui suivent... */
INITIALISATION_ACCROISSEMENT_3D(gradient_local_tri_dimensionnel
,DIVI(SOUS(FALOAD_POINT(champ_F,SucX(X),NEUT(Y),NEUT(Z))
,FALOAD_POINT(champ_F,PreX(X),NEUT(Y),NEUT(Z))
)
,_____lNORMALISE_OX(DOUB(nPAS(F_NpasX,pasX)))
)
,DIVI(SOUS(FALOAD_POINT(champ_F,NEUT(X),SucY(Y),NEUT(Z))
,FALOAD_POINT(champ_F,NEUT(X),PreY(Y),NEUT(Z))
)
,_____lNORMALISE_OY(DOUB(nPAS(F_NpasY,pasY)))
)
,DIVI(SOUS(FALOAD_POINT(champ_F,NEUT(X),NEUT(Y),SucZ(Z))
,FALOAD_POINT(champ_F,NEUT(X),NEUT(Y),PreZ(Z))
)
,_____lNORMALISE_OZ(DOUB(nPAS(F_NpasZ,pasZ)))
)
);
/* Calcul des trois composantes du gradient local au point {X,Y,Z}. ATTENTION, on notera */
/* que le gradient est recalcule systematiquement pour toutes les tentatives relatives au */
/* point courant ; cela n'est pas tres optimise, mais cela est fait expres afin que les */
/* variables necessaires soient locales au test sur 'utiliser_un_champ_de_force'. */
#undef FALOAD_POINT
#undef SucZ
#undef PreZ
#undef SucY
#undef PreY
#undef SucX
#undef PreX
#undef champ_F
EGAL(module_du_gradient_local_tri_dimensionnel
,longF3D(gradient_local_tri_dimensionnel)
);
/* Calcul du module |G| du gradient local au point {X,Y,Z}. */
EGAL(module_de_la_vitesse_perturbee
,longF3D(vitesse_perturbee)
);
/* Calcul du module |V| de la vitesse perturbee. */
EGAL(borne_inferieure_de_l_ouverture
,ACCES_LISTE(liste_initiale_des_BORNE_INFERIEURE_DE_L_OUVERTURE,corps)
);
EGAL(borne_superieure_de_l_ouverture
,ACCES_LISTE(liste_initiale_des_BORNE_SUPERIEURE_DE_L_OUVERTURE,corps)
);
/* Definition des bornes inferieure et superieure de l'angle entre la vitesse perturbee et */
/* le gradient local. */
Test(IFGT(borne_inferieure_de_l_ouverture,borne_superieure_de_l_ouverture))
Bblock
PRINT_ERREUR("le segment d'une ouverture est mal defini");
CAL1(Prer1("corps........... = %d\n",corps));
CAL1(Prer1("borne inferieure = %f\n",borne_inferieure_de_l_ouverture));
CAL1(Prer1("borne superieure = %f\n",borne_superieure_de_l_ouverture));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IZNE(module_de_la_vitesse_perturbee)
,IZNE(module_du_gradient_local_tri_dimensionnel)
)
)
Bblock
EGAL(cosinus_vitesse_gradient
,DIVI(prdF3D(vitesse_perturbee,gradient_local_tri_dimensionnel)
,MUL2(module_de_la_vitesse_perturbee
,module_du_gradient_local_tri_dimensionnel
)
)
);
/* Calcul du cosinus de l'angle entre la vitesse perturbee et le gradient local, */
EGAL(angle_vitesse_gradient,ACOX(cosinus_vitesse_gradient));
/* Puis de cet angle... */
Eblock
ATes
Bblock
EGAL(angle_vitesse_gradient
,MOYE(borne_inferieure_de_l_ouverture,borne_superieure_de_l_ouverture)
);
/* Dans le cas ou l'un des deux modules au moins est nul, on force une valeur appartenant */
/* au segment de validite. */
Eblock
ETes
Test(IFINff(angle_vitesse_gradient
,borne_inferieure_de_l_ouverture
,borne_superieure_de_l_ouverture
)
)
Bblock
Test(IL_FAUT(prendre_la_premiere_direction_trouvee))
Bblock
EGAL(chercher_une_bonne_perturbation,FAUX);
/* Et cela n'est plus necessaire d'iterer lorsque le cosinus de l'angle est dans le bon */
/* segment... */
Eblock
ATes
Bblock
DEFV(Float,INIT(plus_petit_selecteur_de_l_angle_vitesse_gradient,F_INFINI));
Repe(nombre_d_iterations_si_on_ne_prend_pas_la_premiere_direction_trouvee)
Bblock
DEFV(Float,INIT(selecteur_de_l_angle_vitesse_gradient,FLOT__UNDEF));
GENERATION_D_UNE_VALEUR(selecteur_de_l_angle_vitesse_gradient
,borne_inferieure_de_l_ouverture
,borne_superieure_de_l_ouverture
);
EGAL(plus_petit_selecteur_de_l_angle_vitesse_gradient
,MIN2(selecteur_de_l_angle_vitesse_gradient
,plus_petit_selecteur_de_l_angle_vitesse_gradient
)
);
/* "Selecteur" de l'angle entre le vecteur vitesse perturbee et le gradient qui est le plus */
/* petit de tout ceux que l'on genere ici. */
Eblock
ERep
Test(IFLT(angle_vitesse_gradient
,plus_petit_selecteur_de_l_angle_vitesse_gradient
)
)
Bblock
EGAL(chercher_une_bonne_perturbation,FAUX);
/* Et cela n'est plus necessaire d'iterer lorsque l'angle entre le vecteur vitesse perturbee */
/* et le gradient est inferieur au "selecteur". Il est ainsi evident que si l'angle entre */
/* la vitesse et le gradient est petit (c'est-a-dire proche de la borne inferieure de */
/* l'ouverture), il y a de forte chance pour que le "selecteur" lui soit plus grand. Ainsi */
/* cette methode privilegie les petites valeurs de l'angle, c'est-a-dire finalement les */
/* directions qui collent le mieux avec le gradient, sans pour cela exclure les autres */
/* (lorsque l'on prend une ouverture proche de pi...). Ce dispositif a ete introduit le */
/* 1995112200 afin de lutter contre un phenomene visible dans la sequence : */
/* */
/* xivPdf 9 1 / 002725_003236 */
/* */
/* En effet, dans cette sequence on voit nettement se dessiner une croix orientee a pi/4. */
/* Celle-ci vient de l'ouverture [0,pi/2] qui a ete choisie pour la generer ; alors on peut */
/* verifier facilement que les axes {0,pi/2,pi,3.pi/2} sont repulsifs (puisque dessus on a */
/* 2 chances sur 3 de tourner (a droite ou a gauche) et seulement 1 chance sur 3 d'aller */
/* tout droit et donc de rester dessus. En ce qui concerne les bissectrices du referentiel */
/* (directions a pi/4), elles sont attractives, puisque sur elles 1 fois sur 2 on tourne a */
/* gauche et une fois sur 2 on tourne a droite ; ainsi, on reste sur elles en oscillant. */
/* Tout vient donc de l'ouverture [0,pi/2] qui interdit tout retour en arriere. C'est donc */
/* ce que permet 'prendre_la_premiere_direction_trouvee' a 'FAUX' associe a une grande */
/* ouverture de [0,pi]. C'est ainsi que la sequence : */
/* */
/* xivPdf 9 1 / 004788_005299 */
/* */
/* a ete generee... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou l'on n'utilise pas de champ de force : on va utiliser uniquement la distance */
/* a l'origine via 'liste_initiale_des_DISTANCE_MAXIMALE'. */
Eblock
ETes
EGAL(distance_precedente_a_l_origine
,RdisF3D(ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
,Xcentre_ESPACE
,Ycentre_ESPACE
,Zcentre_ESPACE
)
);
EGAL(distance_courante_a_l_origine
,RdisF3D(ASD1(ACCES_COORDONNEES_COURANTES(corps),x)
,ASD1(ACCES_COORDONNEES_COURANTES(corps),y)
,ASD1(ACCES_COORDONNEES_COURANTES(corps),z)
,Xcentre_ESPACE
,Ycentre_ESPACE
,Zcentre_ESPACE
)
);
/* Afin de savoir si l'on s'eloigne de l'origine... */
Test(IL_FAUT(utiliser_un_champ_de_force))
Bblock
Test(IFET(IFGT(distance_courante_a_l_origine
,ACCES_LISTE(liste_initiale_des_DISTANCE_MAXIMALE,corps)
)
,IL_NE_FAUT_PAS(chercher_une_bonne_perturbation)
)
)
Bblock
EGAL(chercher_une_bonne_perturbation,VRAI);
/* Lorsque l'on s'eloigne trop de l'origine, alors qu'il avait ete decide de s'arreter de */
/* chercher une bonne perturbation, on reprend la recherche... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Test(I3OU(IFLE(distance_courante_a_l_origine
,ACCES_LISTE(liste_initiale_des_DISTANCE_MAXIMALE,corps)
)
,IFLE(distance_courante_a_l_origine
,distance_precedente_a_l_origine
)
,IL_FAUT(chercher_une_bonne_perturbation)
)
)
Bblock
EGAL(chercher_une_bonne_perturbation,FAUX);
/* Et cela n'est plus necessaire d'iterer lorsque, soit on n'est pas sorti du "volume" */
/* dans lequel on peut se deplacer, soit on se rapproche de l'origine... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Test(IZLE(decompteur_de_recherche_d_une_bonne_perturbation))
Bblock
Test(IL_NE_FAUT_PAS(utiliser_un_champ_de_force))
Bblock
PRINT_ATTENTION("apparemment, nous sommes en train de boucler");
CAL1(Prer3("position precedente = (%f,%f,%f)\n"
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
)
);
CAL1(Prer1("distance precedente = %f\n",distance_precedente_a_l_origine));
CAL1(Prer3("position courante = (%f,%f,%f)\n"
,ASD1(ACCES_COORDONNEES_COURANTES(corps),x)
,ASD1(ACCES_COORDONNEES_COURANTES(corps),y)
,ASD1(ACCES_COORDONNEES_COURANTES(corps),z)
)
);
CAL1(Prer1("distance courante = %f\n",distance_courante_a_l_origine));
Eblock
ATes
Bblock
/* Dans le cas ou l'on utilise un champ de force, le bouclage peut arriver "volontairement", */
/* car en effet, si l'on a trouve une vitesse perturbee "compatible" avec le gradient local, */
/* mais qui par malheur nous eloigne, on reprend la recherche. Or malheureusement, suivant */
/* le champ utilise, on peut etre dans des circonstances ou seul l'eloignement de l'origine */
/* est compatible avec ce gradient... */
Eblock
ETes
EGAL(chercher_une_bonne_perturbation,FAUX);
/* Pour eviter de boucler... */
Eblock
ATes
Bblock
DECR(decompteur_de_recherche_d_une_bonne_perturbation,I);
/* Pour eviter de boucler... */
Eblock
ETes
Eblock
ETan
TRANSFERT_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps)
,vitesse_perturbee
);
EGAL(ACCES_STABILITES_COURANTES(corps),INTE(ACCES_LISTE(liste_initiale_des_STABILITE,corps)));
/* Et reinitialisation de la stabilite... */
Eblock
ATes
Bblock
/* Ici, la 'ACCES_VITESSE_COURANTE(...)' ne change pas... */
INITIALISATION_POINT_3D(ACCES_COORDONNEES_COURANTES(corps)
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,dct
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
)
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,dct
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
)
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dz)
,dct
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
)
);
/* Nouvelle position non perturbee du corps courant... */
DECR(ACCES_STABILITES_COURANTES(corps),I);
/* Et decrementation de la stabilite... */
Eblock
ETes
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);
/* Simulation du temps de la simulation... */
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,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_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
);
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_naissance
,nombre_de_corps
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Liberation des espaces alloues... */
/* */
/* Les 'ADRESSE_NON_ENCORE_DEFINIE's ont ete introduits le 20050221171903... */
EDITION_DES_EXTREMA_DES_COORDONNEES_ET_DES_DERIVEES;
/* Edition facultative des extrema des coordonnees et des derivees. */
RETU_Commande;
Eblock
ECommande