Ignore:
Timestamp:
Jun 2, 2006, 6:00:25 PM (19 years ago)
Author:
ansari
Message:

petite optimisation supplementaire par simplification du code ds la boucle du calcul Sum[alm*Plm] ... ds LambdaLMBuilder , Reza 2/6/2006

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/SophyaLib/Samba/lambdaBuilder.cc

    r2959 r2966  
    134134 
    135135  r_8 lam_mm = 1. / sqrt(4.*Pi) *bignorm2;
    136   r_8 lam_0, lam_1, lam_2;
    137   register r_8 a_rec, b_rec;
    138 
    139   const complex<r_8>* almp = alm.columnData(0);
    140   r_8* arecp = a_recurrence_.columnData(0);
    141 
    142   int_4 l, m;
     136  register r_8 lam_0, lam_1, lam_2;
     137
     138  int_4 l, m, k;
    143139
    144140  for (m=0; m<=mmax;m++)   {
    145     //MOV^     const complex<r_8>* almp = alm.columnData(m);
     141    const complex<r_8>* almp = alm.columnData(m);
    146142    complex<r_8>* bmp = &(bm(m));
    147    
    148     *bmp = (lam_mm / bignorm2)*(*almp);  almp++;
     143    r_8* arecp = a_recurrence_.columnData(m);
     144    *bmp = (lam_mm / bignorm2)*almp[0];  almp++;
    149145
    150146    lam_0=0.;
    151147    lam_1=1. /bignorm2 ;
    152148   
    153     a_rec = *arecp; arecp++; // a_recurrence_(m,m);
    154     b_rec = 0.;
    155     for (l=m+1; l<=lmax; l++) {
    156       lam_2 = (cth*lam_1-b_rec*lam_0)*a_rec;
    157      
    158       //DEL        lambda_(l,m) = lam_2*lam_mm;
    159       *bmp += lam_2*lam_mm*(*almp);   almp++;
    160       b_rec=1./a_rec;
    161       //           a_rec= LWK->a_recurr(l,m);
    162       a_rec= *arecp; arecp++; // a_recurrence_(l,m);
    163       lam_0 = lam_1;
     149    //    for (l=m+1; l<=lmax; l++) {
     150    for (k=0; k<lmax-m; k++) {
     151      lam_2 = (cth*lam_1-lam_0)*arecp[k];
     152      lam_0 = lam_1/arecp[k];
    164153      lam_1 = lam_2;
     154
     155      *bmp += (lam_2*lam_mm)*almp[k]; 
    165156    }
    166157    lam_mm = -lam_mm*sth* sqrt( (2.*m+3.)/ (2.*m+2.) );
     
    200191 
    201192  r_8 lam_mm = 1. / sqrt(4.*Pi) *bignorm2;
    202   r_8 lam_0, lam_1, lam_2;
    203   register r_8 a_rec, b_rec;
    204  
    205   complex<r_8>* almp = alm.columnData(0);
    206   r_8* arecp = a_recurrence_.columnData(0);
    207 
    208   int_4 l, m;
     193  register r_8 lam_0, lam_1, lam_2;
     194 
     195  int_4 l, m, k;
     196
    209197  for (m=0; m<=mmax;m++)  {
    210     //MOV^ complex<r_8>* almp = alm.columnData(m);
     198    complex<r_8>* almp = alm.columnData(m);
    211199    complex<r_8>  phi = phase(m);
    212200   
     
    216204    lam_1=1. /bignorm2 ;
    217205   
    218     //MOV^ r_8* arecp = a_recurrence_.columnData(m);
    219     a_rec = *arecp; arecp++; // a_recurrence_(m,m);
    220     b_rec = 0.;
    221     for (l=m+1; l<=lmax; l++)   {
    222       lam_2 = (cth*lam_1-b_rec*lam_0)*a_rec;
    223      
    224       //DEL        lambda_(l,m) = lam_2*lam_mm;
    225       *almp += (lam_2*lam_mm) * phi;    almp++;
    226      
    227       b_rec=1./a_rec;
    228       //           a_rec= LWK->a_recurr(l,m);
    229       a_rec= *arecp; arecp++; // a_recurrence_(l,m);
    230       lam_0 = lam_1;
     206    r_8* arecp = a_recurrence_.columnData(m);
     207    //    for (l=m+1; l<=lmax; l++)   {
     208    for (k=0; k<lmax-m; k++) {
     209      lam_2 = (cth*lam_1-lam_0)*arecp[k];
     210      lam_0 = lam_1/arecp[k];
    231211      lam_1 = lam_2;
     212
     213      almp[k] += (lam_2*lam_mm) * phi;
    232214    }
    233215    lam_mm = -lam_mm*sth* sqrt( (2.*m+3.)/ (2.*m+2.) );
     
    250232 
    251233  r_8 lam_mm = 1. / sqrt(4.*Pi) *bignorm2;
    252   r_8 lam_0, lam_1, lam_2;
    253   register r_8 a_rec, b_rec;
    254   register r_4 cff;
    255   complex<r_4>* almp = alm.columnData(0);
    256   r_8* arecp = a_recurrence_.columnData(0);
    257 
    258   int_4 l, m;
     234  register r_8 lam_0, lam_1, lam_2;
     235 
     236  int_4 l, m, k;
     237
    259238  for (m=0; m<=mmax;m++)  {
    260     //MOV^ complex<r_4>* almp = alm.columnData(m);
     239    complex<r_4>* almp = alm.columnData(m);
    261240    complex<r_4>  phi = phase(m);
    262241   
    263     cff = lam_mm / bignorm2;
    264     *almp += cff*phi;  almp++;
     242    *almp += ((r_4)(lam_mm / bignorm2))*phi;    almp++;
    265243
    266244    lam_0=0.;
    267245    lam_1=1. /bignorm2 ;
    268246   
    269     //MOV^ r_8* arecp = a_recurrence_.columnData(m);
    270     a_rec = *arecp; arecp++; // a_recurrence_(m,m);
    271     b_rec = 0.;
    272     for (l=m+1; l<=lmax; l++)   {
    273       lam_2 = (cth*lam_1-b_rec*lam_0)*a_rec;
    274      
    275       //DEL        lambda_(l,m) = lam_2*lam_mm;
    276       cff = (lam_2*lam_mm);
    277       *almp += cff * phi;    almp++;
    278      
    279       b_rec=1./a_rec;
    280       //           a_rec= LWK->a_recurr(l,m);
    281       a_rec= *arecp; arecp++; // a_recurrence_(l,m);
    282       lam_0 = lam_1;
     247    r_8* arecp = a_recurrence_.columnData(m);
     248    //    for (l=m+1; l<=lmax; l++)   {
     249    for (k=0; k<lmax-m; k++) {
     250      lam_2 = (cth*lam_1-lam_0)*arecp[k];
     251      lam_0 = lam_1/arecp[k];
    283252      lam_1 = lam_2;
     253
     254      almp[k] += ((r_4)(lam_2*lam_mm)) * phi;
    284255    }
    285256    lam_mm = -lam_mm*sth* sqrt( (2.*m+3.)/ (2.*m+2.) );
    286257  }
    287 }
     258
     259}
     260
    288261
    289262
     
    292265 compute a static array of coefficients independant from theta (common to all instances of the LambdaBuilder Class
    293266*/
     267
    294268void  LambdaLMBuilder::updateArrayRecurrence(int_4 lmax)
    295269   {
Note: See TracChangeset for help on using the changeset viewer.