Discussion :

[Andromedae]

Bonjour à toutes et à tous,

Voilà j'ai un projet à rendre dans 2 semaines exactement sur la résolution de l'équation de Schrödinger stationnaire à 1D.
Nous avons une méthode qui nous est donnée, sur laquelle nous devons nous baser pour programmer cela pour plusieurs types de potentiels (potentiel plat, Lennard-Jones etc ...).

Néanmoins, j'ai appris la programmation seulement depuis 2 mois et je ne sais mais alors pas du tout comment débuter mon projet ...

Je vous mets le début de mon code :

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
#include <cstdlib> 
#include <vector> 
#include "matprod.h" 
#include <fstream>
 
#define h 6.62606957*pow(10,-34) 		// Définition de la constante de Planck
#define Pi 3.1415926 				// Définition de la valeur de Pi
 
// -------------------------------------------------- //
// ------ Définition du potentiel carré simple ------ //
// -------------------------------------------------- //
 
double V (double x, double xmin, double xmax,  double V0)
{
	if(x<xmin || x>xmax)
		return 0;
	else
		return V0;
}
 
 
int main() {
 
 
cout<<"###########################################################################"<<endl;
cout<<"###########################################################################"<<endl;
cout<<"########################## Projet Informatique ############################"<<endl;
cout<<"############# Résolution de l'équation de Schroedinger à 1D ###############"<<endl;
cout<<"###########################################################################"<<endl;
cout<<"###########################################################################"<<endl;
 
return 0 ;
 
}

Et ci-joint les quelques documents qui m'ont été donné :

Le pdf : projet M1 ==> Mon sujet correspond au premier
Le pdf : Notice ==> Explication d'une méthode de résolution

projets-M1.pdf
Notice 2014.pdf

Je ne souhaite pas forcément que l'on me donne des codes déjà fait, car je veux coder plus ou moins moi-même afin de comprendre ce que je fait.
En espérant avoir un petit coup de pouce

Merci d'avance !


-----------------------------------------------------
Je viens d'ajouter j'espère de façon correcte au niveau de la syntaxe la fonction potentiel J(x) :

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
#include <iostream> 
#include <cmath> 
 
using namespace std ; 
 
#include <cstdlib> 
#include <vector> 
#include "matprod.h" 
#include <fstream>
 
#define h 6.62606957*pow(10,-34) 		// Définition de la constante de Planck
#define Pi 3.1415926 				// Définition de la valeur de Pi
 
// -------------------------------------------------- //
// ------ Définition du potentiel carré simple ------ //
// -------------------------------------------------- //
 
double V (double x, double xmin, double xmax,  double V0)
{
	if(x<xmin || x>xmax)
		return 0;
	else
		return V0;
}
 
double J (double V (double x))
{
	double J = ((2*m)/(pow(h,2)))*(E - V (double x)) ;
 
	return J ;
}
 
 
int main() {
 
 
cout<<"###########################################################################"<<endl;
cout<<"###########################################################################"<<endl;
cout<<"########################## Projet Informatique ############################"<<endl;
cout<<"############# Résolution de l'équation de Schroedinger à 1D ###############"<<endl;
cout<<"###########################################################################"<<endl;
cout<<"###########################################################################"<<endl;
 
cout << V << endl;
 
return 0 ;
 
}

[ternel]

Si tu ne sais pas comment commencer du tout, c'est que tu n'as pas suffisamment compris la méthode.

Tu as su écrire des fonctions, donc tu n'es pas un débutant total en C++, c'est bien.

Tu te heurtes au problème de la conception.

Mon conseil est: prends un crayon, et écrit comment applique la méthode.

Mathématiquement, j'imagine quelque chose comme:
pour tout instant t à partir de T0, par itération de dt, f(t+dt, x) = application_intelligente(f(t, x), t, x);

du coup, il "suffit" de décomposer ca en pièces qui vont bien:
une boucle for (t = T0; t<...; t+=dt)
un tableau de valeur pour discrétiser f selon les valeurs de x en t
un second tableau pour f en t+dt
une fonction spécifique pour calculer la nouvelle valeur de f en (x, t+dt), sachant f(x, t), t et x.
savoir permuter les tableaux: en avancant de dt, je n'ai plus besoin de t; t+dt devient mon nouveau t, et je calcule un nouveau t+dt (dans l'ancien t, dont la mémoire est disponible)

Comme tu es malin, et en C++, tu utiliseras std::array, voire std::vector, pour faire tes tableaux.

[Andromedae]

Tout d'abord merci de votre réponse.

Si je comprends bien (ce qui n'est pas forcément évident lol), il faudrait que j'applique la méthode de Runge-Kutta qui me permettrait d'estimer un première solution et de l'utiliser pour calculer la solution suivante qui serait donc plus précise ?

Néanmoins, je n'arrive pas à faire le lien entre ces méthodes, et mon problème physique lui-même.

Quant à la partir programmation en C++, je suis tout de même un gros débutant.

----------------------------------------------

Notre responsable de projet nous a écrit une méthode par code qui peut éventuellement nous aider :

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
// Programme C++ Laplace : résoudre une équation elliptique d'ordre deux par raccord en un point 
// médian des courbes intégrées depuis les bords. Problème aux conditions limites de type Dirichlet. 
//
// Système @ résoudre :
//
// Ru(Phi_0, Phi_1) ) = 0 avec Phi, Psi : deux paramètres de la variable r satisfaisant aux 
// équations différentielles 
// 
//   d Phi / dr = Psi   
//   d Psi / dr = l(l+1)/r^2 Phi 
//
// sujettes aux conditions : 
// Phi(eps) = PHI0   Psi(eps) = libre   en r = eps << 1 ; 
// Phi(2)   = libre   Psi(2) = PSI1     en r = 2. 
//
// Les quatre courbes intégrées se rencontrent en r = RM avec RM = 1 une constante symboliques. 
// 
// Code inclus dans la distribution arbalete.tar pour le projet Schroedinger / M1 - Programmation 2014. 
// Une notice en format pdf contient des information complémentaires / questions. 
// 
#include <iostream> 
#include <cmath> 
 
using namespace std ; 
 
#include <cstdlib> 
//
// Classe standard vector, mais classe perso matprod 
// 
#include <vector> 
#include "matprod.h" 
 
// Classse d'E/S standard et celle utilisée auparavant (optionnel) 
// 
#include <fstream>
#include "class_es.h"
 
// Constante symboliques : 
// 
#define KMAX 50       // Nombre d'itérations maximale pour converger 
#define RM 1.0        // Position du point de raccord des courbes (pt  milieu)  
#define PHI1 -1.0/4   // Valeur de Phi en r = 2 (bord extérieur) 
#define EPS  0.05     // Valeur de r = eps (bord intérieur) 
#define PHI0 -1./EPS  // Valeur de Phi(eps) 
#define N 1000        // Nombre de points pour l'intégration (fnc integre) 
 
double  l = 0.10 ;    // Variable globale l ]0, 2[ : double (pour exploration) 
double rm = RM ;      // Varaible globale pour la position du point de raccord 
 
// 
// Intégration (rapide) Euler 1 : de la position courante r, jusqu'à n*dr. 
// 
 void integre( double *Psi, double *Phi, double r, double dr, unsigned int n ) { 
      unsigned int i ; 
    for( i = 0 ; i < n ; i++ ) 
      { 
	*Phi += *Psi * dr ; 
        *Psi += l*(l+1)/r/r * (*Phi) * dr ; 
         r += dr ; 
      }
    return ; 
    }    
 
// 
// Utilitaire pour calculer le produit scalaire entre deux vecteurs 
// (pourrait être ajouté @ la classe matprod ou vecteur).
// 
double vdot( std::vector<double> a, std::vector<double> b ) 
  { 
    double somme = 0 ; int i=0, n ; n = max( a.size(), b.size() ) ; while( i < n ) { somme += a[i]*b[i]; i++ ; } 
    return somme ; 
  }
 
 
// Partie principale du programme : 
// ================================
// 
int main()
{
  unsigned int i, n = N, Taille = 2; 
 
  matrice J(Taille), M(Taille) ; 
  std::vector<double> ori(Taille), ext(Taille), R(Taille), Rf(Taille), Delta(Taille), b(Taille) ;
  //vect ori(Taille), ext(Taille), R(Taille), Delta(Taille) ;
 
    // Paramètre d'intégration : 
    // 
  double Ru, lambda = 0.05 , Psi, Phi, Psi0, r, dr ; 
 
  // Initialise le vecteur de contraintes @ l'orgine  (ori) et au bord externe (ext). 
  // deux contraintes pour 4 paramètres : Phi (indice 0) et Psi (indice 1) aux deux bords. 
  // 
  for( i = 0 ; i < Taille ; i++ ) { ori[i] = (double)0.0 ; ext[i] = (double)0.0; }
 
    Psi0 = - (double)l / EPS * ( PHI0 ) ; 
    ori[0] = PHI0 ; ori[1] = Psi0 ; 
    ext[0] = PHI1 ; ext[1] = - (double)l / 2.0 * ( PHI1 ) ; 
 
    cout << " ori 0 et 1  : " << ori[0] << " " << ori[1] << " " << std::endl ; 
    cout << " ext 0 et 1  : " << ext[0] << " " << ext[1] << " " << std::endl ; 
 
    int k = 0 ; Ru = 1 ; 
 
    // Boucle itérative pour contrôler la qualité du raccord en r = rm : 
    //
    while( k < KMAX && Ru > 1.e-8 ) {
 
    // Position près de l'origine + pas d'intégration : 
    // r != 0 pour éviter une singularité
    //
      r = EPS ;  dr = (rm -r ) / (n-1) ;
 
    // On intègre de l'origine ->  point milieu de la grille ( --> )
    // Valeurs initiales pour (Phi, Psi ) : 
    //
    Phi = ori[0] ; Psi = ori[1] ; 
    integre( &Psi, &Phi, r, dr, n ) ; 
 
    // Sauvegarde des valeurs atteintes en r = rm : point "milieu" M 
    // Sens ">" : 1iere colonne, indice 0 
    //
    M.B[0][0] = Phi ; M.B[1][0] = Psi;
 
    // On intègre de r = 2 vers le point milieu de la grille  ( <-- ) 
    // Sens "<" : 2ieme colonne, indice 1 
    //
    r = 2 ; dr = (rm - r ) / (n-1 ) ; 
 
    // Valeurs initiales pour (Phi, Psi ) : 
    //
    Phi = ext[0] ; Psi = ext[1] ; 
    integre( &Psi, &Phi, r, dr, n ) ;
 
    // Sauvegarde des valeurs atteintes en r = rm : point "milieu" M 
    // Sens ">" : 2ieme colonne, indice 1 
    //
    M.B[0][1] = Phi ; M.B[1][1] = Psi; 
 
    // Vecteur des différences R, sa norme au quarré Ru :
    //  
    R[0] =  ( M.B[0][0] - M.B[0][1] ) ; R[1] =  (M.B[1][0] - M.B[1][1] )  ; 
    Ru = vdot(R,R) ; 
 
    cout << " k, Valeur scalaire de l'incertitude : " << k << " " << Ru << std::endl ; 
 
    // Sauvegarde le vecteur R de référence : change de signe pour résoudre (-> élimination gaussienne) 
    //
       Rf[0] = - R[0] ; Rf[1] = - R[1] ; 
 
    // On reprend mais en effectuant les différences finies pour construire la matrice des variances J :
    // on utlise le paramètre "lambda" en pourcentage (lambda %) pour varier les paramètres libres aux limites.  
    //  
    Phi = ori[0] ; Psi = (1+lambda)*ori[1] ; 
    integre( &Psi, &Phi, r, dr, n ) ;
 
    // Calcule maintenant les **différences** avec les anciennes valeurs obtenues au  point "milieu" M 
    // sens ">" : 1ere colonne indice 0 
    //
    M.B[0][0] = Phi - M.B[0][0] ; M.B[1][0] = Psi - M.B[1][0] ;
 
    // On intègre ensuite de r = 2 vers le point milieu de la grille ( <-- ) 
    //
    r = 2 ; 
    dr = (rm - r ) / (n-1 ) ; 
    // Valeurs initiales pour (Phi, Psi ) :
    // 
    Phi = (1+lambda)*ext[0] ; Psi = 1*ext[1] ; 
    integre( &Psi, &Phi, r, dr, n ) ;
 
    // Calcule maintenant les **différences** avec les anciennes valeurs obtenues au  point "milieu" M 
    // sens "<" : 2ieme colonne, indice = 1  (*signe inversé*, voir définition de R) 
    //
    M.B[0][1] = M.B[0][1] - Phi ; M.B[1][1] = M.B[1][1] - Psi ;
 
    // Matrice des variances J : rappel - la matrice "M" comprend maintenant des différences 
    // Schéma simple de différences finies 
    //
    J.B[0][0] = 2 * M.B[0][0] / ( lambda*ori[1] ) ;  J.B[0][1] = 2 * M.B[0][1] / ( lambda*ext[0] ) ; 
    J.B[1][0] = 2 * M.B[1][0] / ( lambda*ori[1] ) ;  J.B[1][1] = 2 * M.B[1][1] / ( lambda*ext[0] ) ; 
 
    matrice Jp ; Jp.copie(&J) ; // Copie of the original Jacobian matrix - test de cohérence validé : inversion de J.
 
    // Elimination gaussienne : procède avec la matrice après pivots, solution de J*Delta = R 
    // (le signe négatif absorbé dans la définition de Rf). 
    //
    Delta = reduction_gaussienne( J, Rf ) ;
 
    // Nouvelles valeurs pour les conditions limites : mise à jour (@ chaque itération)
    //
    ori[1] += Delta[0] ; ext[0] += Delta[1] ; 
    k++ ; 
 
    }
 
    cout << " Valeurs finales : k = " << k << " " << " Psi0 = " << ori[1] << " Phi(2) = " << ext[0] << std::endl ; 
 
    // Intégration des courbes, sauvegarde : s'assurer de la convergence .. 
    // 
    fstream fichier ; fichier.open( "Laplace.dat",  ios::out ) ; cout << fichier.is_open() << std::endl ; 
 
    // On intègre de l'origine ->  point milieu de la grille ( --> )
    //
    r = EPS ;  dr = (rm -r ) / (n-1) ;
    Phi = ori[0] ; Psi = ori[1] ; 
    for ( i = 0 ; i < n ; i++ ) 
      { 
	fichier << r << " " << Phi << " " << Psi << std::endl ; 
	integre( &Psi, &Phi, r, dr, 1 ) ; 
	r += dr ; 
      }
 
    // On intègre du bord < --   point milieu de la grille ( <-- )
    //
    r = 2 ;  dr = (rm -r ) / (n-1) ;
    Phi = ext[0] ; Psi = ext[1] ; 
    for ( i = 0 ; i < n ; i++ ) 
      { 
	fichier << r << " " << Phi << " " << Psi << std::endl ; 
	integre( &Psi, &Phi, r, dr, 1 ) ; 
	r += dr ; 
      }
 
    fichier.close() ; 
 
return 1; 
}

[ternel]

Pas de chance pour toi, ton prof n'a apparemment pas compris que le C++ est un langage disposant de bons compilateurs, et qu'il faut apprendre à l'utiliser correctement.
Son code est très très C, et même en C, pas très propre.

Il faut bien comprendre que C et C++ ne sont pas deux variantes d'un même langage, même si les codes C sont compilables comme si c'était du C++.

Je vais essayer d'en écrire une version plus C++.

edit:
en fait, il y a trop de chose que je ne peux pas changer, notamment matprod.h .

Par contre, regarde ce que sont les références (int &), pour remplacer les pointeurs (int *)
Il te faudra faire des fonctions simples, de quelques instructions.
Une fonction fait quelque chose, certes.
Mais la réciproque est vraie aussi, faire quelque chose, c'est le rôle d'une fonction. Chaque fois que tu as un commentaire pour expliquer ce que fait un bloc d'instruction, il faut envisager d'en faire une fonction.

Essaie de réécrire le main de ton prof pour extraire la méthode runge_kunta dans une (ou plusieurs) fonction(s).

[Andromedae]

Merci beaucoup leternel de tout le travail que tu fais pour m'aider.
En effet, j'ai beaucoup de mal à comprendre le code de mon prof.

[Andromedae]

Hum je pense qu'il faudrait que je fasse mon projet avec les méthodes indiquées dans les 2 pdf sans calquer je pense sur le code de mon prof (que je comprends pas très bien par ailleurs).
Le problème est que je vois toujours pas comment commencer après avoir défini l'ensemble de définition de mon potentiel, ainsi que ma fonction J(x).

L'idéal serait déjà de réussir le cas du potentiel plat (puit de potentiel carré), les autres potentiels seront bien plus simples après.

Donc si une âme charitable a une idée, un code etc à me proposer .. je suis preneur ! Passer toute une après midi sans réellement avancer ça donne mal à la tête lol

[Andromedae]

Dans mon code ci-dessous, comment puis je écrire syntaxement en C++ que ma fonction J = ... prenne en compte ma fonction déclarée juste au dessus V(x) ?

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
#include <iostream> 
#include <cmath> 
 
using namespace std ; 
 
#include <cstdlib> 
#include <vector> 
#include "matprod.h" 
#include <fstream>
 
#define h 6.62606957*pow(10,-34) 		// Définition de la constante de Planck
#define m 9.1*pow(10,-31)			// Définition de la masse : masse d'un électron par exemple
#define Pi 3.1415926 				// Définition de la valeur de Pi
 
 
// -------------------------------------------------- //
// ------ Définition du potentiel carré simple ------ //
// -------------------------------------------------- //
 
double V (double x, double xmin, double xmax, float V0)
{
	if(x<xmin || x>xmax)
		return 0;
	else
		return V0;
}
 
double J (double V, double E )
{
	J = ((2*m)/(pow(h,2)))*(E - V(x, xmin, xmax, V0)) ;
 
	return J ;
}
 
 
int main() {
 
double xmin = 0 ;
double xmax = 2 ;
double x = 1 ;
double V0 = -1 ;
 
double J ;
 
 
cout << J << endl;
 
return 0 ;
 
}

[Invité]

pour commencer,
faire des define nommés h et m c'est un peu chercher les embrouilles donc utilises plutot PLANK_CONSTANT et MOMENT (je sais même plus ce que c'est m )

Ensuite, au lieu de mettre en commentaire que ta fonction calcule un potentiel carré...t'as qu'à l'appeler SimpleSquarePotential()

Ensuite tu définis la fonction J, mais dans le main, tu déclares la variable J... ce qui n'a pas beaucoup de sens.
De même tu passes un double V en argument à la fonction J, alors que V est censée etre une fonction, ca n'a pas beaucoup de sens non plus. (double est un nombre pas une fonction..)

Plutot que coder un truc comme ca, peut etre devrais tu commencer par apprendre les bases?
créer une fonction, appeler une fonction..

[Andromedae]

Tout d'abord, merci galerien69 pour ta réponse.

Il est vrai que tu as sans nul doute bien plus d'expérience en programmation que moi, ce qui se voit par les simplifications que tu me proposes.
Après, il est vrai que j'ai du apprendre sur le tas avec seulement les outils qui m'étaient nécessaires lors des travaux pratiques de programmation.
En effet, l'ensemble de ma promo programme déjà depuis plus d'un an du C/C++.
Pour part, je suis arrivé seulement en master dans ma nouvelle fac, et je n'avais aucune base de programmation (pas de cours dispensés dans mon ancienne université).

J'ai donc du me mettre très rapidement à apprendre des choses sur le tas, sans des bases solides. De plus, les diverses matières de physique et mathématiques en M1 me laissent que très peu de temps pour me plonger dans la programmation.

Je vais essayé de réécrire mon code en suivant tes conseils, de lire en parallèle les notions de cours qui me serviront.

[Andromedae]

Je crois que cette fois-ci c'est mieux

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
#include <iostream> 
#include <cmath> 
 
using namespace std ; 
 
#include <cstdlib> 
#include <vector> 
#include "matprod.h" 
#include <fstream>
 
#define PLANCK_CONSTANT 6.62606957*pow(10,-34) 		// Définition de la constante de Planck
#define ELECTRON_MASSE 9.1*pow(10,-31)			// Définition de la masse : masse d'un électron par exemple
#define Pi 3.1415926 					// Définition de la valeur de Pi
 
 
 
// -------------------------------------------------- //
// ------ Définition du potentiel carré simple ------ //
// -------------------------------------------------- //
 
double SimpleSquarePotential (double x, double xmin, double xmax, double V0)
{
	if( xmin < x < xmax )
 
		return V0;
	else
		return 0;
}
 
double Schrodinger_term ( double E, double V0 )
{
	double J = ((2*ELECTRON_MASSE)/(pow(PLANCK_CONSTANT,2)))*(E - V0) ;
 
	return J ;
}
 
 
int main() {
 
double xmin = 0 ;
double xmax = 2 ;
double x = 1 ;
double V0 = -1 ;
double E = -0.5 ;
double J ;
 
double test_1 ;
test_1 = J ;
 
 
cout << J << endl;
 
return 0 ;
 
}

Je n'obtiens plus d'erreurs dans le terminal et il me retourne une valeur numérique

==> C'est comprendre la physique que je dois programmer :/

[ternel]

sauf que c'est du "n'importe quoi", vu que tu affiches une valeur non initialisée.

Il faut appeler la fonction.

par exemple avec:

Code :

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

double j = J(V0, E);

[Andromedae]

D'accord. Je pensais qu'en fixant E et Vo au début du main c'était bon. Je vais tester cela

Code modifié :

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
#include <iostream> 
#include <cmath> 
 
using namespace std ; 
 
#include <cstdlib> 
#include <vector> 
#include "matprod.h" 
#include <fstream>
 
#define PLANCK_CONSTANT 1			// Définition de la constante de Planck
#define ELECTRON_MASSE 1			// Définition de la masse : masse d'un électron par exemple
#define Pi 3.1415926 				// Définition de la valeur de Pi
 
 
 
// -------------------------------------------------- //
// ------ Définition du potentiel carré simple ------ //
// -------------------------------------------------- //
 
double SimpleSquarePotential (double x, double xmin, double xmax, double V0)
{
	if( xmin < x < xmax )
 
		return V0;
}
 
double Schrodinger_term ( double E, double V0 )
{
	double J = ((2*ELECTRON_MASSE)/(PLANCK_CONSTANT*PLANCK_CONSTANT))*(E - V0) ;
 
	return J ;
}
 
 
int main() {
 
double xmin ;
double xmax = 2 ;
double x = 1 ;
 
 
double j = Schrodinger_term (-0.5, 3) ;
 
 
 
cout << "Le terme J(x) vaut pour x = " << x << " : " << j << endl;
 
return 0 ;
 
}

==> Le terminal m'affiche -7, ça m'a l'air juste

[ternel]

Tu avais fixé le E créé dans la fonction main.
Mais ce n'est pas le même E que l'argument de ta fonction J.
Et de toute façon, il faut appeler une fonction en donnant les valeurs de ses arguments pour pouvoir l'évaluer.

J'espère que tu l'as compris, et te souhaite bon courage pour la suite.

[Médinoc]

Attention, j'ai vu beaucoup de #define complexes non-parenthesés dans les codes postés ici.

[Andromedae]

Vaut mieux que je fasse des doubles plutot que des #define ?

[_zzyx_]

#define HPLANK 6.62607E-34 ==>
Monsieur le compilateur, avant de commencer à compiler, est-ce que tu veux bien remplacer dans dans le code source chaque occurence de hplank par 6.62607E-34 (en dur)
Le piège est que si tu fais un define complexe
#define TOTO 5+4+3+2+1 // = 15
puis que dans le code tu écris tata=TOTO*2 Le compilateur va te retourner 16 car 5+4+3+2+1*2


const double HPLANK=6.62607E-34 ==>
Tu définis une variable constante (qui peut pas changer) avec une valeur donnée, après c'est le compilateur qui décide si il vaut mieux faire appel à une variable ou si il vaut mieux remplacer à la compilation
Tu y gagnes sur tous les plans :
ta variables a un type clair (c'est quoi le type par défaut de Mantisse * exposant : double, float, long double ? )
Le debuggage est plus simple
Pas d'erreur genre 5+4+3+2+1*2
tu peux encapsuler ta variable dans un namespace

Éventuellement tu vas gagner un pouillème de perfo avec la premìere approche (et encore il faudrais tester)

[Andromedae]

Merci beaucoup de cette précision
Je vais remplacer mes #define alors !

[Flob90]

J'ai parcouru rapidement les énoncés et le code d'exemple de ton prof.

Première remarque, passe en unité atomique, ça te simplifiera grandement les valeurs numériques.

Ensuite, prend le code de ton prof et la description de la méthode de l'arbalète jusqu'à les comprendre (son code est certes par parfait, mais il est suffisamment commenté pour comprendre plus clairement la description de la méthode donné en énoncé).

[Andromedae]

Unité atomique soit m = c = h = 1 ?

Je suis dessus depuis quelques jours mais toujours autant de mal à le comprendre :/

[Flob90]

Non, si par m tu sous-entend masse de l'électron, alors oui 1 u.a., c'est pas la constante de Planck qui vaut 1 mais la constante de Planck réduite. La célérité vaut 137 (l'inverse de la constante de structure fine) mais je crois pas que tu en ai besoin dans ton problème. Avec ces valeurs numériques, tu te simplifies ton équation de Schrodinger (plus besoin de tes defines) et les résultats obtenue seront dans l'ordre de l'unité.

Pour la méthode, j'aurais bien aimé pouvoir reprendre les formules données dans ton énoncé, mais je ne sais pas comment mettre du latex sur le forum (je vais chercher).

Le code qu'il vous donne se réfère à la notice explicative, je te conseille de comprendre ce document avant toute chose. Il y a un point que je ne comprends pas, c'est le choix de intervalle de résolution et des conditions aux limites et l'autre document ne m'aide pas à comprendre, personnellement j'irais directement demander de l'aide au professeur ou à un camarade qui a compris.

Excepté ces deux points, l'idée est de fixer 2 conditions aux limites et de trouver les 2 autres (il faut cependant un point de départ). Pour ça tu sépares l'intervalle en deux, tu résout par un schéma numérique simple sur ces deux sous-intervalles (Euler), tu auras donc deux valeurs différentes pour la fonction d'onde et sa dérivée à la jonction des intervalles. Ensuite tu modifies un peu les 2 conditions non fixées et tu recommences, tu va donc obtenir les variations pour les différences au niveau de la jonction pour la fonction d'onde et sa dérivée. C'est la matrice J du document, grâce à elle tu va pouvoir modifier à nouveau les 2 valeurs libres (si tu ne comprends pas la formule, utilises la directement). Puis tu recommences jusqu'à ce que les différences soient assez faibles.

Tu trouves donc la fonction d'onde (près d'une singularité) associée à une énergie, l'énoncé ne dit pas comment choisir les énergies à tester (de même que dans la notice le nombre quantique secondaire est pris quelconque alors qu'il devrait être entier).