Discussion :

[momovelo]

Bonjour,
Voila j'ai un petit problème dont je ne vois pas bien la source. J'ai créé un petit programme me permettant de calculer des trucs (osef) et de me les sortir sous forme de données en .dat. Mon programme marche au poil mais je rencontre un problème avec l'exécutable lors qu'il est seul. Je m'explique. J'ai regroupé les différentes parties de mon code dans un dossier avec un makefile. J'ouvre le dossier dans un terminal je tape "make" puis "./main" et là le programme roule: il calcul puis il me sort mes .dat. Le problème intervient lorsque je compile mon code, "make", puis ferme le terminal et double clic sur mon exécutable. Le terminal s'ouvre, les calculs s'effectuent mais je n'ai aucun .dat qui sort? Comment est-ce possible?!

Merci de votre aide.

Mon Makefile si ça peut 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
##############################
# Makefile du TP Projet
##############################
 
 
#Chemin pour utiliser Vecteur.o
VECTEUR=./Vecteur
 
OBJECTS = main.o  EDO2.o $(VECTEUR)/Vecteur.o
all: main
 
COMPILCOMMAND=g++ -std=c++11  -I$(VECTEUR)  -c -o $@   $<
 
# Commande generique 
%.o: %.cpp %.h
	$(COMPILCOMMAND)
 
#commande pour l’executable
%.o: %.cpp 
	$(COMPILCOMMAND)
 
# Fichiers source a generer
EDO2.o: EDO2.h
main.o:          EDO2.h  
 
# Creation de l'executable
main: $(OBJECTS)
	g++ -std=c++11 -o main $(OBJECTS)  -lgsl -lgslcblas 
 
# Commande de nettoyage
clean:
	rm -f *.o main *.dat *~

[foetus]

C'est le "working directory" qui change

À la console tu forces la racine de ton exécutable avec "./"

Alors que lorsque tu double cliques dessus, le "working directory" c'est peut-être ton "home", peut-être "/bin", peut-être "/user/bin" ...

Il faut soit afficher le "working directory" (avec une interruption pour le voir *) soit rechercher le fichier ".dat" à partir de la racine "/" (éventuellement regarder dans 2-3 dossiers connus avant)


* -> Soit avec un Sleep de X secondes soit avec une boîte de dialogue

[momovelo]

J'ai oublié de l'expliciter, je suis une vraie bite dans ce domaine
Comme faire exactement? Merci.

Ah oui, je vois ce que tu veux dire. Effectivement après vérification mes .dat on bien été envoyés à la racine de mon pc. Mais du coup comment faire en sorte qu'ils soient créés dans le même dossier que mon exécutable? La manip se fait au niveau du make file ou du fstream?

Bon j'ai essayé plein de chose mais rien ne marche...
Voila où j'en suis:

Code :

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

1
2
3
string filename= "./Résultats/Diffusion-L="+to_string(barriere)+"nm-E="+to_string(Energie)+"eV.dat";
 
    ofstream fichier(filename);

[foetus]

Je ne connais pas Linux (enfin si mais pas l'API C/ C++), mais je vois 2 trucs :

• chdir
• system ou 1 exec system("cd /XXX/XXX/XXX");.

[momovelo]

En fait le problème c'est que mon code est amené à être utilisé pas d'autres personnes, mes profs en l'occurence. Du coup j'aimerais que peu importe où se trouve le programme il me crache mes .dat dans le même dossier.
Il n'y a pas moyen récupéré le répertoire de l'exécutable et de l'insérer comme fonction de mon ofstream?

[foetus]

Je ne connais pas Linux (enfin si mais pas l'API C/ C++), mais as-tu regardé le argv[0]?

Dans ton main, il y a 2 paramètres main(int argc, char* argv[]).
Et le argv[0] est souvent/ toujours le nom de l'exécutable. Peut-être qu'il y a un chemin?

[momovelo]

Non j'ai juste un int main()

Je vais te mettre tout mon code ainsi que mon makefile si ça peut t'aider (attention c'est un peu lourds ^^):

EDO2.h

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
#ifndef __EDO2_H__
#define __EDO2_H__
#include "Vecteur/Vecteur.h"
#define eV 1.6e-19
#define nm 1e-9
 
class EDO2 {
 
protected:
 
    int N;//Nombre d'iteration/de points
    double L;//Largueur de la barriere
    double V;//Potentiel
    int rk; //Methode utilisee
 
    //m: Masse particule; hb: Constante de Dirac
    double  m=1.9e-31,hb=1.04082e-33;
 
    Vecteur yf; // Valeurs de y(xf)
    double *xtab,*ytabNorm,*Energie,*Trans,*TAnaly;
    Vecteur *ytabRe, *yptabRe,*ytabIm, *yptabIm;
 
    void stocke(int i,double x,double ytabNorm, Vecteur Re, Vecteur Rep, Vecteur Im, Vecteur Imp );
    void stockeT(int i,double x, double y, double z);
 
public:
 
    EDO2(int Ni);
    ~EDO2();
 
    void setRk(int a){rk=a;};
    void setL(double a){L=a*nm;};
    void setV(double a){V=a*eV;};
 
    //Systeme d'equa diff
    Vecteur evalSys(double x, double E, Vecteur y);
 
    //Integration par Runge-Kutta
    Vecteur calculDiff(double x0,double xf,double E);
 
    //Calcul coefficient de transmission
    double calculT(double E);
    double calculTAnaly(double E, double h);
 
    //Calcul de T(E)
    double tracerT();
 
    //Sortie des .dat
    void ecrireDiff(double E);
    void ecrireT();
};
 
#endif

EDO2.cpp

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
227
228
#include "EDO2.h"
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
 
EDO2::EDO2(int Ni) : N(Ni)
{
    yf.redim(4);
    // On alloue les tableaux servant a stocker les données
    xtab=new double [N+1]; // [0..N] => N+1
    ytabNorm=new double [N+1];
    Energie=new double [N+1];
    Trans=new double [N+1];
    TAnaly=new double [N+1];
    ytabRe=new Vecteur [N+1];
    yptabRe=new Vecteur [N+1];
    ytabIm=new Vecteur [N+1];
    yptabIm=new Vecteur [N+1];
    for (int i=0;i<N+1;i++) {
        ytabRe[i].redim(2);
        yptabRe[i].redim(2);
        ytabIm[i].redim(2);
        yptabIm[i].redim(2);
    }
}
 
EDO2::~EDO2()
{
    delete[] xtab; delete[] ytabNorm; delete[] ytabRe; delete[] yptabRe; delete[] ytabIm; delete[] yptabIm;delete[] Energie; delete[] Trans; delete[] TAnaly;
}
 
//Stockage des donnees
void EDO2::stocke(int i,double x,double Norm, Vecteur Re, Vecteur Rep, Vecteur Im, Vecteur Imp )
{
    xtab[i]=x;
    ytabRe[i]=Re;
    yptabRe[i]=Rep;
    ytabIm[i]=Im;
    yptabIm[i]=Imp;
    ytabNorm[i]=Norm;
}
void EDO2::stockeT(int i,double En, double T, double TAnalytique)
{
    Energie[i]=En;
    Trans[i]=T;
    TAnaly[i]=TAnalytique;
}
 
//Ecriture des donnees sous forme d'un .dat
void EDO2::ecrireDiff(double E)
{int barriere=rint(L/nm);  int Energie=rint(E/eV);
 
    string filename= "./Résultats/Diffusion-L="+to_string(barriere)+"nm-E="+to_string(Energie)+"eV.dat";
 
    ofstream fichier(filename);
    fichier<<"# x"<<setw(20)<<"Re"<<setw(20)<<"Im"<<setw(20)<<"Norme"<<endl;
    for (int i = 0 ; i < N+1 ; i++) {
        fichier<< setprecision(12) << xtab[i];
        fichier << setw(20) << setprecision(12) << ytabRe[i](1)<< setw(20) << setprecision(12) << ytabIm[i](1)<< setw(20) << setprecision(12) << ytabNorm[i];
        fichier << endl;}
    fichier.close();
}
void EDO2::ecrireT()
{int barriere=rint(L/nm);  int EnergieV=rint(V/eV);
    string filename = "./Résultats/Transmission-"+to_string(barriere)+"nm-V="+to_string(EnergieV)+"eV.dat";
 
    ofstream fichier( filename );
    fichier<<"# Energie"<<setw(20)<<"Tnum"<<setw(20)<<"Tanaly"<<endl;
    for (int i = 0 ; i < N+1 ; i++) {
        fichier<< setprecision(12) << Energie[i];
        fichier << setw(20) << setprecision(12) << Trans[i]<< setw(20) << setprecision(12) <<TAnaly[i];
        fichier << endl;}
    fichier.close();
}
 
 
 
//Le systeme d'equa diff
Vecteur EDO2::evalSys(double x, double E, Vecteur y)
{
    //Vecteur d'onde suivant x: interieur ou exterieur du potentiel
    double K=(2*m)/(hb*hb),
    Kiterieur=K*(V-E),
    Kexterieur=K*-E;
    if (x>=0 && x<=L) K=Kiterieur;
    else K=Kexterieur;
 
 
    //Notre systeme d'equations
    Vecteur v(2);
    v(1)=y(2);
    v(2)=K*y(1);
    return v;}
 
 
//Resolution de ce systeme
Vecteur EDO2::calculDiff(double x0,double xf, double E)
{
    //Vecteur d'onde pour conditions initiales
    double k=(sqrt(2*m*E))/hb;
 
    //Condition initiale Re
    double y00Re[2]={cos(k*x0),-k*sin(k*x0)};//Formule d'Euler
    Vecteur y0Re(2,y00Re);
 
    //Condition initiale Im
    double y00Im[2]={sin(k*x0),k*cos(k*x0)};
    Vecteur y0Im(2,y00Im);
 
    double x;
    Vecteur yRe(2),yIm(2);
    Vecteur ypRe(2),ypIm(2);
    Vecteur k1(2), k2(2), k3(2), k4(2);
    yRe=y0Re;
    yIm=y0Im;
    double ynorm; //La norme
    double h = (xf - x0)/N;//Le pas
 
 
    for (int i = 0 ; i<N ; i++) {
        x = x0 + i*h;
        ynorm=yRe(1)*yRe(1)+yIm(1)*yIm(1);//Definition de la norme
        ypRe= evalSys(x,E, yRe);
        ypIm= evalSys(x,E, yIm);
        stocke(i,x*(1/nm),ynorm,yRe,ypRe,yIm,ypIm);//Stockage des donnees
 
        //Rung-Kutta d'ordre 4
        if(rk==4){
       //Re
        k1 = h * ypRe;
        k2 = h * evalSys(x+h/2,E ,yRe+k1/2 );
        k3 = h * evalSys(x+h/2,E, yRe+k2/2);
        k4 = h * evalSys(x+h,E ,  yRe+k3 );
        yRe=yRe+(k1+2*k2+2*k3+k4)/6;
 
        //Im
        k1 = h * ypIm;
        k2 = h * evalSys(x+h/2,E, yIm+k1/2 );
        k3 = h * evalSys(x+h/2,E, yIm+k2/2);
        k4 = h * evalSys(x+h, E,  yIm+k3 );
        yIm=yIm+(k1+2*k2+2*k3+k4)/6;}
 
 
        //Rung-Kutta d'ordre 2
        else if(rk==2){
 
        //Re
        k1 = h * ypRe;
        k2 = h * evalSys(x+h/2,E ,yRe+k1/2 );
        yRe = yRe + k2;
 
        //Im
        k1 = h * ypIm;
        k2 = h * evalSys(x+h/2,E ,yIm+k1/2 );
        yIm = yIm + k2;}
 
          }
 
    // yf est de la forme:
    yf(1)=yRe(1);//     (Re )
    yf(2)=yRe(2);//  yf=(Re')
    yf(3)=yIm(1);//     (Im )
    yf(4)=yIm(2);//     (Im')
    stocke(N,xf*(1/nm),ynorm,yRe,evalSys(xf,E,yRe),yIm,evalSys(xf,E,yIm));
    return yf; }
 
double EDO2::calculT(double E)
{double k, a,b,ia,ib,t,it,T,x0=100.*nm;
 
    Vecteur psi0=calculDiff(x0,0,E);//Recuperation condition limte x=0
 
    //Voir annexe rapport
    k=(sqrt(2*m*E))/hb;
    ib=0.5*(psi0(3)+(psi0(2)/k));
    ia=0.5*(psi0(3)-(psi0(2)/k));
    a=0.5*(psi0(1)+(psi0(4)/k));
    b=0.5*(psi0(1)-(psi0(4)/k));
 
    t=a/(a*a+ia*ia);
    it=-ia/(a*a+ia*ia);
    T=pow(t,2)+pow(it,2);
    return T;
    }
 
double EDO2::calculTAnaly(double E,double h)
{double TAnaly,K1,K10,K2,K20;
    //Tout ce qui suit sert a calculer T analytique
    K1=sqrt(2*m*V*L*L*(1-(E/V)))/hb;
    K2=sqrt(2*m*V*L*L*((E/V)-1))/hb;
    K10=sqrt(2*m*V*L*L*(1-((V-h)/V)))/hb;
    K20=sqrt(2*m*V*L*L*(((V+h)/V)-1))/hb;
    if (E<V)TAnaly=1/(1+((pow(sinh(K1),2))/(4*(E/(V*V))*(V-E))));
 
    else if(E==V) TAnaly=((1/(1+((pow(sinh(K10),2))/(4*((V-h)/(V*V))*(V-(V-h))))))+(1/(1+((pow(sin(K20),2))/(4*((V+h)/(V*V))*((V+h)-V))))))/2.;
 
    else TAnaly=1/(1+((pow(sin(K2),2))/(4*(E/(V*V))*(E-V))));
    return TAnaly;}
 
 
 
double EDO2::tracerT()//Calcul de T pour différentes energies
{
    double E0=0.,Ef=2.*V,x0=100.*nm;
 
    double E,k,T,TAnaly,K1,K10,K2,K20, Err=0.;
    Vecteur psi0;
 
    double h = (Ef - E0)/N;
 
    for(int i=1; i<=N; i++)
    {E = E0 + i*h;
        //Calcul numerique de T
        T=calculT(E);
 
        //Calcul analytique de T
        TAnaly=calculTAnaly(E,h);
 
        //Erreur comme somme des difference TAnaly et T
        Err+=fabs(TAnaly-T);
 
        stockeT(i,(E*(1/eV)),T,TAnaly);
 
    }
    return (Err/N);
    }

main.cpp

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
#include <iostream>
#include <iomanip>
#include <cmath>
#include "EDO2.h"
using namespace std;
int main() {
 
    int rk, N; double E,L,V,Err;
 
    cout<<endl
    <<"##########################################################"<<endl
    <<"############                                  ############"<<endl
    <<"############ Programme de Diffusion Quantique ############"<<endl
    <<"############                                  ############"<<endl
    <<"##########################################################"<<endl
    <<"# Martinon/Diop ############################### Mai 2016 #"<<endl
    <<"##########################################################"<<endl<<endl<<endl;
 
 
    cout <<"Selectioner le nombre de points:";               cin>>N;
    cout <<"Selectioner la methode a utiliser Rk(2 ou 4):";  cin>>rk;
    cout <<"Selectioner la largueur du potentiel (en nm):";  cin>>L;
    cout <<"Selectioner l'energie du potentiel (en eV):";    cin>>V;
    cout <<"Selectioner l'energie de la particule (en eV):"; cin>>E;
    cout<<endl;
 
    cout<<"N="<<N<<setw(18)<<"Methode:RK"<<rk<<setw(10)<<"L="<<L<<"nm"<<setw(10)<<"V="<<V<<"eV"<<setw(10)<<"E="<<E<<"eV"<<endl<<endl;
 
    EDO2 psi(N);
 
    psi.setL(L);
    psi.setV(V);
    psi.setRk(rk);
 
 
    double x0=100.*nm , xf=-100.*nm, timeT, timeTE, dt;
    E=E*eV;
    Vecteur yres(4);
 
    //Mesure temps de calcul T
    timeT = clock() ;
 
    yres=psi.calculDiff(x0,xf,E);
 
    //Ecriture .dat
    psi.ecrireDiff(E);
 
    //Calcul T
    psi.calculT(E);
 
    dt = clock() - timeT ;
    timeT = (double)dt/CLOCKS_PER_SEC;
    cout<<"Coefficient de transmission T="<<psi.calculT(E)<<endl;
    cout<<"Coefficient de reflexion R="<<1-psi.calculT(E)<<endl;
 
    //Mesure temps de calcul T(E)
    timeTE = clock() ;
 
    Err=psi.tracerT();
 
    dt = clock() - timeTE ;
    timeTE = (double)dt/CLOCKS_PER_SEC;
 
    cout<<endl<<"Temps de calcul de T:"<<timeT<<"secondes."<<endl;
    cout<<"Temps de calcul T(E):"<<timeTE<<"secondes."<<endl<<endl;
    cout<<"Precision moyenne de la methode:"<<Err<<endl<<endl;
    cout<<"Sortie de psi et de T(E) sous forme de .dat dans /Résultats"<<endl<<endl;
 
    //Ecriture .dat
    psi.ecrireT();
 
    return 0;}

Makefile:

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
##############################
# Makefile du TP Projet
##############################
 
 
#Chemin pour utiliser Vecteur.o
VECTEUR=./Vecteur
 
OBJECTS = main.o  EDO2.o $(VECTEUR)/Vecteur.o
all: main
 
COMPILCOMMAND=g++ -std=c++11  -I$(VECTEUR)  -c -o $@   $<
 
# Commande generique 
%.o: %.cpp %.h
	$(COMPILCOMMAND)
 
#commande pour l’executable
%.o: %.cpp 
	$(COMPILCOMMAND)
 
# Fichiers source a generer
EDO2.o: EDO2.h
main.o:          EDO2.h  
 
# Creation de l'executable
main: $(OBJECTS)
	g++ -std=c++11 -o main $(OBJECTS)  -lgsl -lgslcblas 
 
# Commande de nettoyage
clean:
	rm -f *.o main *.dat *~ ./Résultats/*.dat

[foetus]

Non j'ai juste un int main()

Et qu'est-ce qui t'empêche de coder le main officiel?

[momovelo]

Bha heu, j'en sais rien

Non, je me casse les dents là dessus mais je ne vois vraiment pas..

[jo_link_noir]

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
#include <string> 
#include <iostream>
 
int main(int, char ** av) {
  std::string d = av[0];
  auto const pos = d.rfind('/');
  if (pos != std::string::npos) {
    d.resize(pos+1);
  }
  else {
    d = "./";
  }
 
  std::cout << "directory: " << d;
}

[momovelo]

J'ai pas compris ce que fais ton code à part me sortir "directory: ./"

[jo_link_noir]

Il donne le chemin du programme relatif au dossier de travail, c'est à dire le dossier de l'exécutable.
Au besoin, le dossier de travail peut être changé avec chdir.

note: Sur Windows, il faudrait utiliser '\\' au lieu de '/'.

[foetus]

J'ai pas compris ce que fais ton code à part me sortir "directory: ./"

Sors toi les doigts

Documentation de rfind: il te sort "./" parce qu'il n'y a pas le chemin, juste le nom de l'exécutable.
De toute manière tu colles un point d'arrêt (breakpoint) et tu es fixé en 30 secondes.

Avec une recherche Google How do I get the directory that a program is running from?, sous Linux, soit:

• Utiliser le fichier "/proc/XXX_PID/exe" (mais ce n'est pas portable à 100% apparemment) (*)
• Soit getcwd

Sous Windows, GetModuleFileName


* ->

Code :

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

1
2
3
4
5
6
char szTmp[32];
sprintf(szTmp, "/proc/%d/exe", getpid());
int bytes = MIN(readlink(szTmp, pBuf, len), len - 1);
if(bytes >= 0)
	pBuf[bytes] = '\0';
return bytes;

note: Sur Windows, il faudrait utiliser '\\' au lieu de '/'.

Dans les API Windows, les 2 sont supportés

[momovelo]

J'ai oublié de l'expliciter, je suis une vraie bite dans ce domaine
Comme faire exactement? Merci.

J'ai appris le code il y a six mois. Alors c'est bien beau de me traiter de branleur mais ça ne m'aide pas vraiment...
De plus, désolé de ne pas vous l'avoir précisé, je code sous mac (famille unix).

[foetus]

J'ai appris le code il y a six mois. Alors c'est bien beau de me traiter de branleur mais ça ne m'aide pas vraiment...

Pas de branleur, mais ne pas avoir de réflexes

Il y a Internet et des sites références pour décrire toutes les méthodes standards: Tu ne vois pas ce que fait un bout de code, et tu vois std::rfind ou std::npos: réflexe je vais voir.

Savoir ce qu'il y a dans une variable (ici argv[0]): réflexe 2 lignes de code et un point d'arrêt.

Un problème, réflexe: stackoverflow ou un autre (une fois que le problème est dégagé, parce que des fois c'est le brouillard )

De plus, désolé de ne pas vous l'avoir précisé, je code sous mac (famille unix).

Et tu te plains en ayant les 2 meilleurs compilateurs C++ : gcc et clang.

Par contre effectivement le truc du "/proc/XXX_PID/exe" cela va passer moyen-moyen: il faut tester

[momovelo]

Rah il ne veut vraiment pas!
Je viens de coder ça:

Code :

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

1
2
3
4
5
 
#include <unistd.h>
#include <limits.h>
char buff[PATH_MAX + 1];
    char *cwd = getcwd( buff, PATH_MAX + 1 );

cwd retourne le working directory (je le stocke dans WD). Maintenant dans mon ofstream je fais simplement ofstrem fichier(WD+filename);
Quand je fais un petit cout<<WD+filename j'ai bien le répertoire où je veux que mes .dat sortent.
Mais le problème persiste, lorsque je lance le main seul, les .dat disparaissent...

[fenkys]

Tu es sûr d'avoir les droits d'écriture sur le dossier final ? Si ce n'est pas le cas, le programme ne plantera pas, tu n'auras juste pas tes fichiers.

[jo_link_noir]

Dans les API Windows, les 2 sont supportés

Peut-être, mais le caractère cherché dans argv n'est pas quantique .