/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S R E L A T I V E S A L A M A R C H E A L E A T O I R E : */
/* */
/* */
/* Author of '$xrk/rdn_walk.53$I' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1998??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E L A M A R C H E A L E A T O I R E : */
/* */
/*************************************************************************************************************************************/
Bblock
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_EFFECTIF
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
)
,AXPB(ASD1(vitesse_perturbee,dy)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
)
,AXPB(ASD1(vitesse_perturbee,dz)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
)
);
/* Nouvelle position provisoire et perturbee du corps courant. ATTENTION, jusqu'a la */
/* date du 20000529105344, il y avait ici, par erreur, 'dct' et non pas 'DCT_EFFECTIF'. */
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(deltaF_3D,Fgradient_local_tri_dimensionnel);
/* Gradient local (Gx,Gy,Gz). */
DEFV(Float,INIT(module_du_Fgradient_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 eF_NpasX \
MUL2(COND(IL_FAUT(adapter_les_F_nPAS),DIVI(MAX2(pasX,SOUA(X_anticipe,X)),pasX),UN),F_NpasX)
#define PreX(x) \
nPREX(x,eF_NpasX)
#define SucX(x) \
nSUCX(x,eF_NpasX)
#define eF_NpasY \
MUL2(COND(IL_FAUT(adapter_les_F_nPAS),DIVI(MAX2(pasY,SOUA(Y_anticipe,Y)),pasY),UN),F_NpasY)
#define PreY(y) \
nPREY(y,eF_NpasY)
#define SucY(y) \
nSUCY(y,eF_NpasY)
#define eF_NpasZ \
MUL2(COND(IL_FAUT(adapter_les_F_nPAS),DIVI(MAX2(pasZ,SOUA(Z_anticipe,Z)),pasZ),UN),F_NpasZ)
#define PreZ(z) \
nPREZ(z,eF_NpasZ)
#define SucZ(z) \
nSUCZ(z,eF_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(Fgradient_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 eF_NpasZ
#undef SucY
#undef PreY
#undef eF_NpasY
#undef SucX
#undef PreX
#undef eF_NpasX
#undef champ_F
EDITION_E(BLOC(CAL2(Prin3(" POTENTIEL gradient={%+f,%+f,%+f}"
,ASD1(Fgradient_local_tri_dimensionnel,dx)
,ASD1(Fgradient_local_tri_dimensionnel,dy)
,ASD1(Fgradient_local_tri_dimensionnel,dz)
)
);
)
);
EGAL(module_du_Fgradient_local_tri_dimensionnel
,longF3D(Fgradient_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_Fgradient_local_tri_dimensionnel)
)
)
Bblock
EGAL(cosinus_vitesse_gradient
,DIVI(prdF3D(vitesse_perturbee,Fgradient_local_tri_dimensionnel)
,MUL2(module_de_la_vitesse_perturbee
,module_du_Fgradient_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... */
#ifdef ACCES_PONDERATIONS_DE_G
Test(EST_VRAI(le_champ_de_gravitation_est_central))
Bblock
DEFV(deltaF_3D,rayon_vecteur_courant);
# define CENTRE_DU_CHAMP_DE_GRAVITATION(type1,type2) \
COND(EST_FAUX(le_champ_de_gravitation_est_central_et_dynamique) \
,centre_du_champ_de_gravitation_central`type1 \
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps_centre_de_gravitation_dynamique),type2) \
)
INITIALISATION_ACCROISSEMENT_3D(rayon_vecteur_courant
,SOUS(CENTRE_DU_CHAMP_DE_GRAVITATION(X,x)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
)
,SOUS(CENTRE_DU_CHAMP_DE_GRAVITATION(Y,y)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
)
,SOUS(CENTRE_DU_CHAMP_DE_GRAVITATION(Z,z)
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
)
);
# undef CENTRE_DU_CHAMP_DE_GRAVITATION
NORMALISATION_ACCROISSEMENT_3D(rayon_vecteur_courant);
/* Calcul du vecteur unitaire du champ de gravitation central au point courant {X,Y,Z}. */
EGAL(acceleration_du_champ_de_gravitation_X
,MUL2(intensite_du_champ_de_gravitation_central,ASD1(rayon_vecteur_courant,dx))
);
EGAL(acceleration_du_champ_de_gravitation_Y
,MUL2(intensite_du_champ_de_gravitation_central,ASD1(rayon_vecteur_courant,dy))
);
EGAL(acceleration_du_champ_de_gravitation_Z
,MUL2(intensite_du_champ_de_gravitation_central,ASD1(rayon_vecteur_courant,dz))
);
/* Calcul du vecteur G definissant le champ de gravitation central au point courant {X,Y,Z}. */
Eblock
ATes
Bblock
Eblock
ETes
INITIALISATION_ACCROISSEMENT_3D(ACCES_VITESSE_COURANTE(corps)
,ADD2(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,MUL2(ACCES_PONDERATIONS_DE_G(corps)
,MUL2(MUL2(sEVOLUTION_DE_G(numero_de_la_periode_courante)
,acceleration_du_champ_de_gravitation_X
)
,DCT_EFFECTIF
)
)
)
,ADD2(ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,MUL2(ACCES_PONDERATIONS_DE_G(corps)
,MUL2(MUL2(sEVOLUTION_DE_G(numero_de_la_periode_courante)
,acceleration_du_champ_de_gravitation_Y
)
,DCT_EFFECTIF
)
)
)
,ADD2(ASD1(ACCES_VITESSE_COURANTE(corps),dz)
,MUL2(ACCES_PONDERATIONS_DE_G(corps)
,MUL2(MUL2(sEVOLUTION_DE_G(numero_de_la_periode_courante)
,acceleration_du_champ_de_gravitation_Z
)
,DCT_EFFECTIF
)
)
)
);
/* Prise en compte du champ de gravitation 'G' (introduit le 20000529105344). */
#Aifdef ACCES_PONDERATIONS_DE_G
#Eifdef ACCES_PONDERATIONS_DE_G
INITIALISATION_POINT_3D(ACCES_COORDONNEES_COURANTES(corps)
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dx)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),x)
)
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dy)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),y)
)
,AXPB(ASD1(ACCES_VITESSE_COURANTE(corps),dz)
,DCT_EFFECTIF
,ASD1(ACCES_COORDONNEES_PRECEDENTES(corps),z)
)
);
/* Nouvelle position non perturbee du corps courant. ATTENTION, jusqu'a la */
/* date du 20000529105344, il y avait ici, par erreur, 'dct' et non pas 'DCT_EFFECTIF'. */
DECR(ACCES_STABILITES_COURANTES(corps),I);
/* Et decrementation de la stabilite... */
Eblock
ETes
Eblock