Pb code java

Bonjour à tous,
Actuellement j'essaie de me lancer dans la programmation java, et je suis une formation en ligne dans laquelle nous devons coder des programmes données sous forme de problème en langage naturel.

il y en a un sur lequel, je bloque totalement et je pense que le soucis vient de mon code, mais je n'arrive pas à le déboguer.
Nous devons suivre une logique de programmation qui nous est imposée et nous ne connaissons pas encore à ce stade la POO.
je vous poste le sujet ainsi que la partie de mon code qui ne me retourne pas du tout le même résultat qu'eux pour un jeux d'essai et je vous remercie de votre aide .

mon code :

double masseC,vent,dTot,dReste,dMonte,dDescente,pMonte,pDescente, pasTemps;
        
        pasTemps = 1.0/60.0;
        final double DT = pasTemps;
        final int P_MIN = 10;
        
        do{
        	System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
        	masseC = clavier.nextDouble();
        	/*System.out.println();*/
        }while (masseC <40 || masseC >180 );
        
		do{
			System.out.print("vent (entre -20 et +20 km/h) ? ");
			vent = clavier.nextDouble();
			/*System.out.println();*/
		}while (vent < -20 || vent > 20);
        
        do{
        	System.out.print("distance du parcours (<= 200 km) ? ");
        	dTot = clavier.nextDouble();
        	/*System.out.println();*/
        }while((dTot < 11.0 || dTot > 200.0));
        
        dReste = dTot - 10;
        
        do{
        	System.out.print("distance au sommet du col (<= "+dReste);
        	System.out.print(" km) ? ");
        	dMonte = clavier.nextDouble();
        	/*System.out.println();*/
        }while(dMonte > dReste);
        
        dDescente = dTot - dMonte;
        
        do{
        	System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
        	pMonte = clavier.nextDouble();
        	/*System.out.println();*/
        }while(pMonte > 20);
        

        do{
        	System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
        	pDescente = clavier.nextDouble();
        	/*System.out.println();*/
        }while(pDescente > 20);
        
        
		double V;
		
        
        double roundedTime = Math.round(t);
        boolean arret;
        
       
        while(v >= 3.0 && d < dTot){
        	 /*vent par rapport cycliste*/
            V = v-vent;
            
        /*while(v >= 3.0 && d < dMonte){*/
        	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);
              }  
        		
              
                t += DT;
                
                V = v-vent;
                
                if (d < dMonte && p > P_MIN){
                	/*détermine puissance*/
                	p -= 0.5*DT;
                	
                }
                
                /*Acc*/
                acc +=  -2118.96 * Math.sin(Math.atan(pMonte/100.0))
                acc -= 5.0*V*(Math.abs(V)/masseC)  ;
                
                
                if (p > 0 && v > 0){
                	acc += 777.6*(p/(v*masseC));
                }
                if ( Math.abs(acc) < 1e-5){
                	acc = 0.0;
                }else{
                	v += acc * DT;
                }
                	
                /*distance*/
                d = d + (v *(DT/60));
                
                
                if(d >= dMonte){
                	System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
                }
                
            
        }
        
        if (d < dTot){
        	
        	// conditions spéciales
	        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;
        }
        

je vous poste l'ennoncé :
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 strictement 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 ».