Bonjour, j'ai développé sous DevC++5 un programme de "méthode des images" pour accélérer mes simulations du champ acoustique (la connaissance du but du programme n'est pas nécessaire à la compréhension du problème) jusqu'ici faites sous Matlab (un logiciel de calcul scientifique basé sur un language de programmation + évolué que le C). A ma grande surprise, le programme en C/C++ même optimisé (à ma sauce, je ne suis pas un pro) va moins vite que celui sous Matlab... l'effet désiré n'étant pas atteint!
Le coeur du programme qui prend le plus de temps est le suivant:
///////////////////////////////
// DEMARRAGE DE L'ALGORITHME //
///////////////////////////////
ofstream p_fichier_H ("H.txt");
// Debut boucle sur la fréquence:
for (nf = 0 ; nf <= Nf - 1 ; nf++ )
{
Cst = j/deux*f[nf]*Rho;
// Debut boucle sur la position des sources:
for (ns = 0 ; ns <= Ns - 1 ; ns++ )
{
// Debut boucle sur axe X des sources-images:
for (m = -ORDRE[nf] ; m <= ORDRE[nf] ; m++ )
{
// Debut boucle sur axe Y des sources-images:
for (n = -ORDRE[nf] ; n <= ORDRE[nf] ; n++ )
{
// Debut condition nombre reflexions sur les murs:
if ((abs(m)+abs(n)) <= ORDRE[nf])
{
// Debut boucle sur axe Z des sources-images:
for (p = -ORDRE[nf] ; p <= ORDRE[nf] ; p++ )
{
// Debut condition nombre reflexions sur les murs:
if ((abs(m)+abs(n)+abs(p)) <= ORDRE[nf])
{
// Calcul des projections de la distance origine - source-image:
Six = m * Lx + pow( -1.0 , m ) * Sx[ns] ;
Siy = n * Ly + pow( -1.0 , n ) * Sy[ns] ;
Siz = p * Lz + pow( -1.0 , p ) * Sz[ns] ;
// Debut boucle sur la position des Micros:
for (nmic = 0 ; nmic <= Nmic-1 ; nmic++ )
{
// Calcul des projections de la distance micro - source-image:
Rx = Six - Mx[nmic] ;
Ry = Siy - My[nmic] ;
Rz = Siz - Mz[nmic] ;
// Calcul de la distance micro - source-image:
R = sqrt( pow( Rx , 2 ) + pow( Ry , 2 ) + pow( Rz , 2 ) ) ;
// Calcul des impédances de surface selon chaque axe:
Zx = Zsurf[nf] * abs( Rx ) / R / Zc;
Zy = Zsurf[nf] * abs( Ry ) / R / Zc;
Zz = Zsurf[nf] * abs( Rz ) / R / Zc;
// Somme la contribution de la source(m,n,p) à la fréq(nf) sur le micro(nmic):
Ptot[nmic] = Ptot[nmic] + Cst*exp(-j*deux*pi*f[nf]*R/C)/R
*cpx_pow_dbl(( Zx - un ) / ( Zx + un ) , abs(m))
*cpx_pow_dbl(( Zy - un ) / ( Zy + un ) , abs(n))
*cpx_pow_dbl(( Zz - un ) / ( Zz + un ) , abs(p));
// *cpx_pow_dbl(( Zx - un ) / ( Zx + un ) , abs(m))
// *cpx_pow_dbl(( Zy - un ) / ( Zy + un ) , abs(n))
// *cpx_pow_dbl(( Zz - un ) / ( Zz + un ) , abs(p));
// Fin boucle position des Micros
}
// Fin condition nombre reflexions sur les murs
}
// Fin boucle sur axe Z des sources-images
}
// Fin condition nombre reflexions sur les murs
}
// Fin boucle sur axe Y des sources-images
}
// Fin boucle sur axe X des sources-images
}
//////////////////////////////////////////
// Ecriture des données puis remise à 0: /
//////////////////////////////////////////
// Debut boucle Micros
for (nmic = 0 ; nmic <= Nmic-1 ; nmic++ )
{
p_fichier_H << real(Ptot[nmic]) << "\t" << imag(Ptot[nmic]) << "\t";
// Remise à zero du vecteur:
Ptot[nmic] = (0.0,0.0);
// Fin boucle Micros
}
p_fichier_H << endl;
// Fin boucle sur la position des sources
}
// Fin boucle sur la fréquence
}
p_fichier_H.close();
qui fait appel à la fonction: complex<double> cpx_pow_dbl(complex<double> x, double n)
{
//complex<double> y = pow(abs(x), n)*exp(n*j*arg(x));
return pow(abs(x), n)*exp(n*j*arg(x));
}
qui a l'air de prendre pas mal de temps.
Je me demande donc comment est-ce possible que mon programme soit plus lent et je vous demande si qqu'un a une idée pour accélérer les calculs.
Merci d'avance...
AlexG