Simulation complexe d'un cycliste

**hoturi** · 01/10/2015, 23h14

bonsoir tous le monde je suis des cours pour apprendre le langage JAVA, j'avance assez bien mais les exercices ne sont pas tous du même niveau, le dernier en date est plutôt compliqué c'est une simulation d'un cycliste et je ne sais vraiment pas par quel bout commencer je suis complètement perdu.

Voici l’annoncé si certain d'entre vous peuvent m'aider a commencer cela serai super parce que j'avoue ne pas savoir comment faire (ils sont fout dans cette formation pour de l'initiation je trouve les exercices très difficile).

Énonce.

On s'intéresse ici à écrire un programme permettant de simuler le trajet d'un cycliste lors d'un tour en montagne (suite à la location de la semaine passée ;-)).

2.2 Modélisation du cycliste

Figure 1: Le trajet prévu pour le cycliste (de gauche à droite).
Le programme demandé devra simuler le trajet (temps, distance, vitesse, accélération et puissance développée) d'un cycliste effectuant un trajet (cf figure 1) de dtot kilomètres en montagne, constitué d'une montée de d1 kilomètres à p1 pourcents et d'une descente de dtot−d1 kilomètres à p2 pourcents. Par exemple, un tour de 50 km (dtot=50) dont 30 km (d1=30) sont en montée à 5 % (p1=5) et le reste est une descente à 10% (p2=10).

On supposera de plus qu'il y a un vent constant tout le long du trajet. Le sens du vent est pris dans le sens du cycliste : un vent négatif (vent contraire) signifie que le cycliste se prend le vent de face (comme dans l'exemple de la figure) ; un vent positif signifie que le vent pousse le cycliste dans le dos.

Le cycliste sera représenté dans le programme par sa masse (en kilogrammes), sa vitesse (en kilomètres par heure), son accélération (en kilomètres par heure par minute), la distance (en kilomètres) qu'il a parcouru depuis le début de la montée et la puissance (en watts) qu'il développe.

Nous vous fournissons déjà quelques variables dans le programme téléchargé :

t représentera le temps (en minutes) depuis le début de la montée (le programme commence donc au temps t=0) ;

d, la distance (en kilomètres) que le cycliste a parcouru depuis le début de la montée ;

v, la vitesse du cycliste (en kilomètres par heure) au temps t ; au départ, c'est donc la vitesse avec laquelle le cycliste aborde la montée (il ne part pas de zéro, mais attaque la montée à 30 km/h) ;

acc, l'accélération du cycliste (en kilomètres par heure par minute) au temps t ; c'est donc le nombre de kilomètres par heure qu'il va gagner/perdre dans la prochaine minute ; elle sera calculée au fur et à mesure en fonction des autres paramètres ; sa valeur initiale n'a donc pas d'importance et nous avons choisi 0 ;

et p, la puissance (en watts) que le cycliste développe au temps t en pédalant ; il faudra la recalculer à chaque fois en fonction de la fatigue du cycliste (voir plus loin) ; nous avons choisi une valeur initiale de 175 W.

Le reste du code fourni consiste en :

plusieurs messages à afficher pour poser des questions à l'utilisateur (voir plus loin) ;

la condition et la ligne permettant d'afficher les informations sur le cycliste toutes les 5 minutes ; la condition utilise des fonctions qui n'ont pas été présentées dans le cours (Math.abs, Math.round) dont le but est simplement d'éviter trop d'affichages en n'affichant qu'une ligne toutes les 5 minutes de simulation ; utilisez ces lignes fournies telles quelles ;

deux messages utiles pour des conditions particulières (décrites plus bas) ;

l'affichage des deux derniers messages, à ne pas modifier.

Pour commencer, votre programme devra demander à l'utilisateur les grandeurs suivantes (voir exemple de déroulement en fin de l'énoncé) :

la masse du cycliste (en kilogrammes) ; cette masse doit être comprise entre 40 et 180 kg (inclus) ;

la vitesse du vent (en kilomètres par heure) ; elle doit être comprise entre –20 et +20 km/h ;

la distance totale du parcours (en kilomètres) ; cette distance doit être supérieure ou égale à 11 km et inférieure ou égale à 200 km ;

la longueur (en kilomètres) de la montée ; cette distance doit être positive et telle qu'il reste au moins 10 km de descente ; il faudra afficher dans la question la longueur maximale possible ;

la pente (en pourcents) de la montée ; elle doit être plus grande que zéro et inférieure ou égale à 20% ;

la pente (en pourcents) de la descente ; elle doit être plus grande que zéro et inférieure ou égale à 20%.

En cas de valeur entrée incorrecte, votre programme devra (de suite) poser à nouveau la question (voir exemple de déroulement plus bas) ; et ce, jusqu'à obtention d'une réponse correcte.

Nous vous conseillons ensuite de définir deux constantes :

le « pas de temps » DT avec lequel nous allons faire avancer les calculs de la simulation ; fixez-le à 1/60 ;

la « puissance minimale » P_MIN que le cycliste fournit ; elle sera de 10 W.

2.3 Simulation du mouvement
Procédez de la façon suivante pour calculer l'évolution du cycliste :

afficher les informations courantes (code fourni) ;

augmenter le temps t d'un pas de temps (DT défini plus haut) ;

calculer la vitesse V du vent par rapport au cycliste : c'est simplement la différence entre la vitesse du cycliste et celle du vent : V=v–vitesse du vent ;

calculer la fatigue du cycliste : si le cycliste est encore en montée et que sa puissance est supérieure à la puissance minimale (définie plus haut : 10 W), alors il perd 0.5 fois DT de puissance (il pédale moins fort à cause de la fatigue) ;

calculer l'accélération du cycliste ; elle vaut :

moins 2'118.96 fois le sinus de l'arctangente de la pente divisée par 100. (Pour ceux que la Physique intéresse, il s'agit là de l'accélération liée au poids : 2'118.96 étant 9.81×60×3.6 en raison des unités (kilomètres par heure par minute).) En Java, on écrit simplement :
« -2118.96 * Math.sin(Math.atan(pente/100)) » ;
Notez que ce terme ne change pas tant que la pente ne change pas ;

moins 5 fois V fois Math.abs(V) divisé par la masse du cycliste ; (Physique : c'est la force exercée par le vent sur le cycliste ; 5 provient de 0.3×60/3.6.)

si la puissance et la vitesse du cycliste sont toutes les deux plus grandes que zéro (i.e. s'il n'a pas posé le pied par terre), on ajoute sa poussée (il pédale) : 777.6 (60×3.6×3.6) fois sa puissance divisé par le produit de sa vitesse et de sa masse :

777.6×pv×m
si après tous ces calculs la valeur absolue de l'accélération (Math.abs(acc)) est plus petite que 10−5 (qui s'écrit « 1e-5 » en Java), alors on la mettra à 0 ;

sinon, calculer la nouvelle vitesse du cycliste en ajoutant à l'ancienne valeur le produit de l'accélération par le « pas de temps » :

v=v+acc×DT
puis mettre à jour la distance parcourue : lui ajouter le produit de la (nouvelle) vitesse et du « pas de temps » divisé par 60 : (Cette division par 60 vient des unités : la vitesse est en kilomètres par heure alors que le temps est en minutes.)

d=d+v×DT60
terminer enfin par le traitement des cas particuliers :

dès que le cycliste aborde la descente :

afficher un message :

## Bernard a atteint le sommet en ... min.

le cycliste arrête alors de pédaler fortement, il ne produit plus que la puissance minimale (définie plus haut) ; autrement dit : pendant toute la descente la puissance du cycliste est égale à la puissance minimale ;

penser également à changer la pente pour celle de la descente, qui doit de plus être négative ;

si la vitesse du cycliste devient inférieure à 3 km/h, le cycliste se décourage et abandonne : quitter votre programme en affichant « ## Bernard abandonne, il n'en peut plus » et les informations (temps, distance, vitesse, accélération et puissance) ; les deux instructions nécessaires pour réaliser ces affichages sont fournies ; pour quitter le programme, simplement utiliser l'instruction « return ».

voici le code que j'ai commencé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import java.util.Scanner;
 
class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {
 
        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W
 
 
        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
 
 
        // variables utilisateur
 
        double masseCycliste = 0.0;
        double vent = 0.0;
        double dtot = 0.0;
        double lmonté = 0.0;
        double Pmonté = 0.0;
        double Pdescente = 0.0;
        double Dt = 1/60;
        double P_Min = 10;
 
        do { 
        	System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
        		masseCycliste= clavier.nextDouble();
        }while(!(masseCycliste>=40) || !(masseCycliste<=180) );
 
        do { 
        	System.out.print("vent (entre -20 et +20 km/h) ? ");
        		vent= clavier.nextDouble();
        }while(!(vent>=-20) || !(vent<=20));
 
        do { 
        	System.out.print("distance du parcours (<= 200 km) ? ");
        		dtot= clavier.nextDouble();
        }while(!(dtot>=11) || !(dtot<=200));
 
        do { 
        	System.out.print("distance au sommet du col " +(dtot - 10)+ " <=");
        	System.out.print(" km) ? ");	
        	lmonté= clavier.nextDouble();
        }while(!(lmonté>=0) || !(lmonté<=(dtot - 10)));
 
        do { 
            System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
        		Pmonté= clavier.nextDouble();
        }while(!(Pmonté>0) || !(Pmonté<=20));
 
        do { 
            System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
        		Pdescente= clavier.nextDouble();
        }while(!(Pdescente>0) || !(Pdescente<=20));
 
 
        // affichage des informations courantes :
 
        double roundedTime = Math.round(t);
 
        		if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
        			System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                              t, d, v, acc, p); 
 
        double pente = Pmonté;	      
        double Dsommet = dtot-lmonté;
 
        // augmenter le temps :
        do {t = t+Dt;
 
 
 
        // calcul vitesse du vent :
        double V = v-vent;
 
        // calcul fatigue cycliste :
        if (Dsommet > 0 && p> P_Min ) { p = p-0.5*Dt;}
 
        // calcul vitesse accélaration :
      	acc = (2118.96*Math.atan(pente/100))-5*V*Math.abs(V);
 
        		if (p>0 && v>0){acc = acc+(777.6*(p/(v*masseCycliste)));}
 
        		{
        		if (Math.abs(acc)<1e-5) {acc= 0;}
        		else{ v=v*acc*Dt;}
 
        		}
 
        		}while(d>=dtot);
        		}
 
 
 
        // conditions spéciales
 
        System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
        System.out.println("## Bernard abandonne, il n'en peut plus");
        System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                          t, d, v, acc, p);
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
 
        System.out.println("## Bernard est arrivé");
        System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                          t, d, v, acc, p);
    }
}

Merci d'avance pour votre aide.

**francky74** · 02/10/2015, 00h35

Bonjour Hoturi,

Petite aide ! je dis petite car je n'ai pas pu lire ton texte en entier .... un peu long

Bon, de ce que j'ai lu et à mon avis personnel qui sera sûrement et allègrement démonté par les cadors du site

Je vois que le code que tu as fourni est codé sans utiliser la particularité de java qui est un language orienté objet. Perso, j'aurais codé autrement et je ne reprends donc pas ton exemple car il me prendrait plus de temps (désolé).

Moi, j'aurais créé déjà deux beans :
1- Cycliste
2- Trajet

comme suit :
Trajet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package beans;
 
public class Trajet {
	private float dtot;	//distance totale du parcours
	private float longMont;	//longueur de la montée (en kilomètres)
	private float penteMont;	//pourcentage de la montée
	private float descente;	//longueur de la descente (en kilomètres)
	private float penteDesc;	//pourcentage de la descente
	private float vent;	//force du vent
 
	//CONSTRUCTEUR
	public Trajet(float dtot, float d1, float p1, float p2, float vent) {
		super();
		this.dtot = dtot;
		this.longMont = d1;
		this.penteMont = p1;
		this.penteDesc = p2;
		this.setVent(vent);
 
		descente = dtot - d1;
	}
 
	//ACCESSEURS
	public float getDtot() {return dtot;}
	public void setDtot(float dtot) {this.dtot = dtot;}
	public float getD1() {return longMont;}
	public void setD1(float d1) {this.longMont = d1;}
	public float getP1() {return penteMont;}
	public void setP1(float p1) {this.penteMont = p1;}
	public float getP2() {return penteDesc;}
	public void setP2(float p2) {this.penteDesc = p2;}
	public float getDescente() {return descente;}
	public float getVent() {return vent;}
	public void setVent(float vent) {this.vent = vent;}	
}

Cycliste

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package beans;
 
public class Cycliste {
 
	private String nom;
	private float masse;	//en kilogrammes
	private float vitesse;	//en kilomètres / heure
	private float acceleration;	//en km / heure / minute
	private float puiss;	// en watts
 
	//CONSTRUCTEUR
	public Cycliste(String nom, float masse) {
		super();
 
		this.masse = masse;
	}
 
	//ACCESSEURS
	public float getMasse() {return masse;}
	public void setMasse(float masse) {this.masse = masse;}
	public float getVitesse() {return vitesse;}
	public void setVitesse(float vitesse) {this.vitesse = vitesse;}
	public float getAcceleration() {return acceleration;}
	public void setAcceleration(float acceleration) {this.acceleration = acceleration;}
	public float getPuiss() {return puiss;}
	public void setPuiss(float puiss) {this.puiss = puiss;}
	public String getNom() {return nom;}
	public void setNom(String nom) {this.nom = nom;}	
}

Pour effectuer tous les calculs .. etc je créé toujours un contrôleur que voici :
Controleur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package controleur;
 
import java.util.Scanner;
 
import beans.Cycliste;
import beans.Trajet;
 
public class Controleur {
 
	float masse, vitVent, dtot, longMont, penteMont, penteDesc;
	String nom;
 
	public Controleur() {
		super();
 
		//demande des paramètres
		poserQuestions();
 
 
		//création des objets cycliste et trajet
		Cycliste poulidor = new Cycliste(nom, masse);
 
		Trajet prologueTourDeFrance = new Trajet(dtot, longMont, penteMont, penteDesc, vitVent);
 
		System.out.println("Cycliste :\n\tnom : " + nom + "\n\tmasse : " + masse + "\nTrajet :\n\tdistance totale : "
				+ dtot + "\n\tlongueur descente : " + (dtot - longMont));
 
	}
 
	//méthodes
	private void poserQuestions() {
 
		Scanner scan = new Scanner(System.in);
 
		System.out.println("nom du cycliste :");
		nom = scan.next();
 
		do{
			System.out.println("Indiquer la masse du cylcite (entre 40 et 180 kilos)");
			masse = scan.nextFloat();
		}while(masse < 40 || masse > 180);
 
		do{
			System.out.println("Indiquer la vitesse du vent (entre -20 et 20 km/heure)");
			vitVent = scan.nextFloat();
		}while(vitVent < -20 || vitVent > 20);
 
		do{
			System.out.println("Indiquer la distance totale du parcours (entre 11 et 200 km)");
			dtot = scan.nextFloat();
		}while(dtot < 11 || dtot > 200);
 
		do{
			System.out.println("Indiquer la longueur de la montée (>0 et dtot - distanceMontée > 10)");
			longMont = scan.nextFloat();
		}while(longMont < 0 || dtot - longMont < 10);
 
		do{
			System.out.println("Indiquer la pente de la montée (> 0% et <= 20 %)");
			penteMont = scan.nextFloat();
		}while(penteMont < 0 || penteMont > 20);
 
		do{
			System.out.println("Indiquer la pente de la descente (> 0% et <= 20 %)");
			penteDesc = scan.nextFloat();
		}while(penteDesc < 0 || penteDesc > 20);
	}
}

et avec mes habitudes, je créé un Lanceur ....
Lanceur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
package principal;
 
import controleur.Controleur;
 
public class Lanceur {
 
	public static void main(String[] args) {
		Controleur ctrl = new Controleur();
	}
 
}

Voilà, ce que je peux faire pour toi ! je ne pense pas avoir le temps de faire plus ce week-end

Mais déjà essaie de comprendre ce que j'ai fait.

Tu peux ajouter quelques parties de code que tu as fait dans le controleur.

On voit que les contraintes sont vérifiées avec des do ... while, je crée ensuite les objets puis j'affiche pour vérifier visuellement.

**hoturi** · 02/10/2015, 01h23

Merci pour votre réponse hélas je ne peux utiliser le langage orienté objet dans cette exercice je dois uniquement utiliser des structure conditionnels, des itérations et des boucles.

En faite d’après ce que j'ai compris je dois créer une grosse boucle qui avance par pas de temps de 5 min à l'aide de cette formule :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
double roundedTime = Math.round(t);
        		if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
        			System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                              t, d, v, acc, p); }

En faite pour l'instant je n'arrive pas a créer la boucle qui vas englober tous mes calculs, je n'ai que traduit dans mon code l'ensemble des formules qui sont salicaire pour calculer l'avancer du cycliste.

Enfin bref je sais toujours pas comment commencer tous cela et surtout je n'arrive pas a schématiser (dans ma tête) le processus que je dois traduire en code, ce qui est encore plus gênant.

**francky74** · 02/10/2015, 23h17

Bonjour !

Alors dans ce cas, au lieu de donner l'énoncé de ton problème en un gros bloc, je te conseille plutôt de décrire ce que tu souhaite faire à l'endroit où tu es bloqué.
Peut-être que tu l'as dit dans ton message mais, très sincèrement, je n'ai pas tout lu et je pense que nombre de personnes qui auraient pu t'aider se sont désistée en voyant la tartine de l'énoncé

Créé plutôt un nouveau sujet en expliquant l'endroit où tu es bloqué (sans donner tous les détails de l'énoncé mais plutôt les détails qui aideront les autres à t'aider àrésoudre ton problème) et le but recherché.

A mon avis tu trouveras plus d'aide. Après j'ai peut-être tort mais c'est mon ressenti

.

Je suis vraiment désolé de ne pouvoir t'aider plus mais moi-même je suis en formation, j'ai déjà un très gros exercice à réaliser dans l'année et en plus je suis en période en entreprise actuellement (bien qu'en arrêt maladie ...) et je doit donc aussi faire un mémoire !!! avec en plus deux enfants jeunes ....

je sais toujours pas comment commencer tous cela et surtout je n'arrive pas a schématiser (dans ma tête) le processus que je dois traduire en code

Voilà le type de problème que tu rencontrera souvent si tu es débutant. On commence à coder en se disant je vais faire un cycliste qui va monter une côte ....
puis petit à petit on a une myriade des petits ou gros problèmes qui s'ajoutent et on fini par laisser tomber devant la montagne de problèmes à résoudre !

Tout cela parce que l'on a pas schématisé les actions que l'on doit faire avant de se lancer dans le codage.
Bien sûr, on ne peux pas penser à tout mais déjà, prendre une feuille de papier et noter séquentiellement les étapes qui vont devoir s'enchaîner pour arriver à notre but est une étape importante.

Ainsi, je te conseillerais de créer au moins un petit diagramme d'activités UML. Lis ce petit tuto qui devrait t'éclairer comme les feux d'une voiture .....

http://laurent-audibert.developpez.c...amme-activites

Bon courage ! si tu as d'autres problèmes, n'hésites pas à poster sur ce forum d'entraide

**hoturi** · 03/10/2015, 01h14

C'est bon après pas mal de travail j'ai enfin réussi mon exercice enfin presque evidemment il me reste un truc qui ne vas pas mais je ne sais pas quoi, un très léger décalage entre mon résultat et le résultat attendu

exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 Votre programme a écrit (ligne 2) :
  "5, 1.06, 12.26, -0.0284,  172.50"
  là où notre programme voulait :
  "5, 1.05, 12.26, -0.0284,  172.50"
  Lignes 4 à 7, votre programme a écrit :
  "15, 3.08, 11.97, -0.0288,  167.50"
  "20, 4.07, 11.83, -0.0290,  165.00"
  "25, 5.05, 11.68, -0.0291,  162.50"
  "30, 6.02, 11.54, -0.0293,  160.00"
  là où notre programme voulait :
  "15, 3.07, 11.97, -0.0288,  167.50"
  "20, 4.06, 11.83, -0.0290,  165.00"
  "25, 5.04, 11.68, -0.0291,  162.50"
  "30, 6.01, 11.54, -0.0293,  160.00"

Voici mon code si quelqu'un voit ce qui cloche merci de me le signaler, perso je pense que cela vient de la variable Dt (Dt = 1/60 soit 0.0166666666.....66667), je dois avoir un un pb d'arrondie mais comment faire?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import java.util.Scanner;
 
class exercices {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {
 
        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.00; // accélération, en km/h/min
        double p = 175.00;  // puissance, en W
 
 
        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
 
 
        // variables utilisateur
 
        double masseCycliste = 80;
        double vent = 10;
        double dtot = 35;
        double lmonté = 20;
        double Pmonté = 8;
        double Pdescente = 12;
        float a = 1;
        float b = 60;
        float Dt = a/b; 
        double P_Min = 10;
        System.out.println (Dt);
 
 
 
 
        // ==== SIMULATION ====
 
 
       double t1 = 0.00;
       double d1 =0.00;
 
 
 
 
 
      // affichage des informations courantes :	
       System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
               t, d, v, acc, p);
 
         do {	        	 
 
        // calcul fatigue cycliste :
                if (lmonté > 0 && p> P_Min ) { p = p-0.5*Dt;}	 	
        // augmenter le temps :	
        	t1 = (t+Dt);
           	t = t1;       	         	
       // mettre à jour la distance :		
        		d1 = d+v*(Dt/60); 
           		d=d1;        	
       // calcul vitesse du vent :
                double V = v-vent;                              
      // calcul vitesse accélaration :
              	acc = (-2118.96*Math.sin(Math.atan(Pmonté/100)))-((5*V*(Math.abs(V)/masseCycliste)));                              		
                		if (p>0 && v>0) {acc = acc+(777.6*(p/(v*masseCycliste)));}        		                		
                		{if (Math.abs(acc)<1e-5) {acc= 0;
                		}                		
                v = v+acc*Dt;}              	        			
 
        	if (v<=3) {System.out.println("## Bernard abandonne, il n'en peut plus"); System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                    t, d, v, acc, p); 
        			   return;}
 
                         double roundedTime = Math.round(t);	
        	if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
        	System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                              t, d, v, acc, p); } 
 
 
         }while(lmonté>=d1);		
         System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
 
 
 
 
 
         // ATTTENTION à ENLEVER
 
 
        // ======>Cas particuliers LA DESCENTE :
 
         do {   
        	 p = P_Min;    	 
 
  // augmenter le temps :	
 	t1 = (t+Dt);
    	t = t1;	 
  // mettre à jour la distance :		
 	d1 = d+v*(Dt/60); 
    	d=d1;
 
  // calcul vitesse du vent :
         double V = v-vent;        
  // calcul vitesse accélaration :
       	acc = (-2118.96*Math.sin(Math.atan(-Pdescente/100)))-((5*V*(Math.abs(V)/masseCycliste)));
 
 
         		if (p>0 && v>0) {acc = acc+(777.6*(p/(v*masseCycliste)));}        		
 
         		{if (Math.abs(acc)<1e-5) {acc= 0;}
 
         v = v+acc*Dt;
       	}	
         double roundedTime = Math.round(t);	
         if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
         			System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                               t, d, v, acc, p); }
         }while((dtot)>=d1);
 
 
         System.out.println("## Bernard est arrivé");
         System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                           t, d, v, acc, p);
 =        
         }		
 
 
      	}