mg3d_std_base.C

00001 /*
00002  * Methods of class Mg3d to get the standard spectral bases for scalar and
00003  *  vector fields.
00004  */
00005 
00006 /*
00007  *   Copyright (c) 1999-2001 Eric Gourgoulhon
00008  *
00009  *   This file is part of LORENE.
00010  *
00011  *   LORENE is free software; you can redistribute it and/or modify
00012  *   it under the terms of the GNU General Public License as published by
00013  *   the Free Software Foundation; either version 2 of the License, or
00014  *   (at your option) any later version.
00015  *
00016  *   LORENE is distributed in the hope that it will be useful,
00017  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *   GNU General Public License for more details.
00020  *
00021  *   You should have received a copy of the GNU General Public License
00022  *   along with LORENE; if not, write to the Free Software
00023  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00024  *
00025  */
00026 
00027 
00028 char mg3d_std_base_C[] = "$Header: /cvsroot/Lorene/C++/Source/Mg3d/mg3d_std_base.C,v 1.10 2012/01/24 15:02:28 j_novak Exp $" ;
00029 
00030 /*
00031  * $Id: mg3d_std_base.C,v 1.10 2012/01/24 15:02:28 j_novak Exp $
00032  * $Log: mg3d_std_base.C,v $
00033  * Revision 1.10  2012/01/24 15:02:28  j_novak
00034  * Minor change to avoid warnings
00035  *
00036  * Revision 1.9  2009/10/08 16:21:02  j_novak
00037  * Addition of new bases T_COS and T_SIN.
00038  *
00039  * Revision 1.8  2008/10/29 08:21:35  jl_cornou
00040  * Spectral bases for pseudo vectors added
00041  *
00042  * Revision 1.7  2007/12/14 10:19:32  jl_cornou
00043  * *** empty log message ***
00044  *
00045  * Revision 1.6  2005/10/25 08:56:37  p_grandclement
00046  * addition of std_spectral_base in the case of odd functions near the origin
00047  *
00048  * Revision 1.5  2005/02/16 15:09:16  m_forot
00049  * Add R_CHEBPI_I and R_CHEBPI_P cases
00050  *
00051  * Revision 1.4  2004/11/04 15:21:42  e_gourgoulhon
00052  * The case without any symmetry in theta is now treated.
00053  *
00054  * Revision 1.3  2003/12/19 16:21:45  j_novak
00055  * Shadow hunt
00056  *
00057  * Revision 1.2  2002/08/13 08:02:45  j_novak
00058  * Handling of spherical vector/tensor components added in the classes
00059  * Mg3d and Tenseur. Minor corrections for the class Metconf.
00060  *
00061  * Revision 1.1.1.1  2001/11/20 15:19:27  e_gourgoulhon
00062  * LORENE
00063  *
00064  * Revision 1.2  2000/09/27  15:07:40  eric
00065  * Correction dans le cas type_p = SYM.
00066  *
00067  * Revision 1.1  1999/10/12  14:54:43  eric
00068  * Initial revision
00069  *
00070  *
00071  * $Header: /cvsroot/Lorene/C++/Source/Mg3d/mg3d_std_base.C,v 1.10 2012/01/24 15:02:28 j_novak Exp $
00072  *
00073  */
00074 
00075 // headers C++
00076 
00077 // headers C
00078 #include <assert.h>
00079 
00080 // headers Lorene
00081 #include "grilles.h"
00082 #include "base_val.h"
00083 #include "type_parite.h"
00084 
00085 int std_base_scal_1z(int type_r, int type_t, int type_p) ; 
00086 int std_base_scal_odd_1z(int type_r, int type_t, int type_p) ; 
00087 
00088             //-----------------------------//
00089             //  Bases for a scalar field   //
00090             //-----------------------------//
00091             
00092 
00093 Base_val Mg3d::std_base_scal() const {
00094           
00095     Base_val base(nzone) ;  
00096      
00097     for (int l=0; l<nzone; l++) {
00098     base.b[l] = std_base_scal_1z(type_r[l], type_t, type_p) ;
00099     }
00100     
00101     return base ; 
00102      
00103 }    
00104 
00105 Base_val Mg3d::std_base_scal_odd() const {
00106           
00107     Base_val base(nzone) ;  
00108      
00109     for (int l=0; l<nzone; l++) {
00110     base.b[l] = std_base_scal_odd_1z(type_r[l], type_t, type_p) ;
00111     }
00112     
00113     return base ; 
00114      
00115 }    
00116 
00117             //---------------------------------------//
00118             //  Bases for the Cartesian components   //
00119             //    of a vector field          //
00120             //---------------------------------------//
00121             
00122 
00123 /*
00124  * Calcul les bases spectrales associees aux composantes cartesiennes d'un vecteur
00125  * antisymetrique en z (pour la composante z)
00126  * 
00127  * (*THIS) est la grille du calcul
00128  * SORTIE : un tableau sur les 3 compsantes (x=1, y=2, z=3) contenant les bases
00129  * de decomposition
00130  * 
00131  */
00132 
00133 Base_val** Mg3d::std_base_vect_cart() const {
00134      
00135      // nbre de zones :
00136      int nz = get_nzone() ;
00137      
00138      // Tableau contenant le resultat...
00139      Base_val** bases = new Base_val*[3] ;
00140      for (int i=0 ; i<3 ; i++)
00141     bases[i] = new Base_val(nz) ;
00142                 
00143     // Boucle sur les differentes zones :
00144     for (int l=0; l<nzone; l++) {
00145 
00146     // Type d'echantillonnage de la zone l :
00147     int type_r0 = get_type_r(l) ;
00148 
00149     // Bases de developpement en (r,theta,phi) a determiner pour les composantes
00150     // (1,2,3) du vecteur : 
00151     
00152     int base1,  base2, base3 ;  
00153     switch ( type_p ) {
00154     
00155         case NONSYM :   
00156 //---------------------------------------------------------
00157 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
00158 //---------------------------------------------------------
00159 
00160 // Base en phi:
00161 //-------------
00162         base1 = P_COSSIN ;      
00163         base2 = P_COSSIN ;      
00164         base3 = P_COSSIN ;      
00165     
00166     
00167 // Base en theta:
00168 //---------------
00169         switch ( type_t ) {
00170         case SYM :      
00171 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
00172 //------------------------------------------------------
00173         base1 = base1 | T_COSSIN_CP ; 
00174         base2 = base2 | T_COSSIN_CP ; 
00175         base3 = base3 | T_COSSIN_CI ; 
00176 
00177 // Base en r :
00178 //------------
00179         switch ( type_r0 ) {
00180             
00181             case FIN :           
00182 // echantillonnage fin
00183             
00184             base1 = base1 | R_CHEB  ;  
00185             base2 = base2 | R_CHEB  ;  
00186             base3 = base3 | R_CHEB  ;  
00187             break ;
00188 
00189             case FINJAC :            
00190 // echantillonnage fin de Jacobi
00191             
00192             base1 = base1 | R_JACO02  ;  
00193             base2 = base2 | R_JACO02  ;  
00194             base3 = base3 | R_JACO02  ;  
00195             break ;
00196 
00197 
00198             case RARE :          
00199 // echantillonnage rarefie
00200 
00201             base1 = base1 | R_CHEBPIM_P ;  
00202             base2 = base2 | R_CHEBPIM_P ;  
00203             base3 = base3 | R_CHEBPIM_I ;  
00204             
00205             break ;
00206 
00207             case UNSURR :           
00208 // echantillonnage fin (1/r)
00209 
00210             base1 = base1 | R_CHEBU  ;  
00211             base2 = base2 | R_CHEBU  ;  
00212             base3 = base3 | R_CHEBU  ;  
00213             break ;
00214 
00215 
00216             default : 
00217             cout << 
00218         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
00219               << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00220             cout << 
00221               " dans la zone l = " << l << " n'est pas prevu ! " 
00222               << endl ;
00223               abort () ;
00224         }
00225 
00226         break ; // fin du cas type_t = SYM
00227             
00228 
00229         case NONSYM :   
00230 // pas de symetrie en theta  :  theta dans [0, pi]      
00231 //------------------------------------------------
00232         base1 = base1 | T_COSSIN_C ; 
00233         base2 = base2 | T_COSSIN_C ; 
00234         base3 = base3 | T_COSSIN_C ; 
00235 
00236 // Base en r :
00237 //------------
00238         switch ( type_r0 ) {
00239             
00240             case FIN :           
00241 // echantillonnage fin
00242             
00243             base1 = base1 | R_CHEB  ;  
00244             base2 = base2 | R_CHEB  ;  
00245             base3 = base3 | R_CHEB  ;  
00246             break ;
00247 
00248             case FINJAC :            
00249 // echantillonnage fin de Jacobi
00250             
00251             base1 = base1 | R_JACO02  ;  
00252             base2 = base2 | R_JACO02  ;  
00253             base3 = base3 | R_JACO02  ;  
00254             break ;
00255 
00256             case RARE :          
00257 // echantillonnage rarefie
00258 
00259             base1 = base1 | R_CHEBPI_P ;  
00260             base2 = base2 | R_CHEBPI_P ;  
00261             base3 = base3 | R_CHEBPI_P ;  
00262             
00263             break ;
00264 
00265             case UNSURR :           
00266 // echantillonnage fin (1/r)
00267 
00268             base1 = base1 | R_CHEBU  ;  
00269             base2 = base2 | R_CHEBU  ;  
00270             base3 = base3 | R_CHEBU  ;  
00271             break ;
00272 
00273 
00274             default : 
00275             cout << 
00276         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
00277               << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00278             cout << 
00279               " dans la zone l = " << l << " n'est pas prevu ! " 
00280               << endl ;
00281               abort () ;
00282         }
00283 
00284         break ; // fin du cas type_t = NONSYM
00285             
00286 
00287 
00288             
00289         default : 
00290             cout << 
00291         "Mg3d::std_base_vect_cart : le cas type_p, type_t = " 
00292               << type_p<< " " <<type_t << endl ;
00293             cout << 
00294               " dans la zone l = " << l << " n'est pas prevu ! " 
00295               << endl ;
00296             abort () ;
00297 
00298         }   // fin des cas sur type_t 
00299 
00300 
00301 
00302         break ; // fin du cas sans symetrie pour phi 
00303 
00304 
00305         case SYM :  
00306 //---------------------------------------------------------
00307 // Cas symetrie phi -> phi + pi :  phi in [0, pi]
00308 //---------------------------------------------------------
00309 
00310 // Base en phi:
00311 //-------------
00312         base1 = P_COSSIN_I ;       
00313         base2 = P_COSSIN_I ;       
00314         base3 = P_COSSIN_P ;       
00315     
00316     
00317 // Base en theta:
00318 //---------------
00319         switch ( type_t ) {
00320 
00321         case SYM :      
00322 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
00323 //------------------------------------------------------
00324         base1 = base1 | T_SIN_I ;       
00325         base2 = base2 | T_SIN_I ;       
00326         base3 = base3 | T_COS_I;        
00327 
00328 // Base en r :
00329 //------------
00330         switch ( type_r0 ) {
00331             
00332             case FIN :           
00333 // echantillonnage fin
00334             
00335             base1 = base1 | R_CHEB  ;  
00336             base2 = base2 | R_CHEB  ;  
00337             base3 = base3 | R_CHEB  ;  
00338             break ;
00339 
00340             case FINJAC :            
00341 // echantillonnage fin de Jacobi
00342             
00343             base1 = base1 | R_JACO02  ;  
00344             base2 = base2 | R_JACO02  ;  
00345             base3 = base3 | R_JACO02  ;  
00346             break ;
00347 
00348             case RARE :          
00349 // echantillonnage rarefie
00350 
00351             base1 = base1 | R_CHEBI ;  
00352             base2 = base2 | R_CHEBI ;  
00353             base3 = base3 | R_CHEBI ;  
00354             break ;
00355 
00356             case UNSURR :           
00357 // echantillonnage fin (1/r)
00358 
00359             base1 = base1 | R_CHEBU  ;  
00360             base2 = base2 | R_CHEBU  ;  
00361             base3 = base3 | R_CHEBU  ;  
00362             break ;
00363 
00364 
00365             default : 
00366             cout << 
00367         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
00368               << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
00369             cout << 
00370               " dans la zone l = " << l << " n'est pas prevu ! " 
00371               << endl ;
00372               abort () ;
00373         }
00374 
00375         break ; // fin du cas type_t = SYM
00376             
00377             
00378         case NONSYM :   
00379 // pas de symetrie en theta  :  theta dans [0, pi]      
00380 //------------------------------------------------
00381         base1 = base1 | T_SIN ; 
00382         base2 = base2 | T_SIN ; 
00383         base3 = base3 | T_COS ; 
00384 
00385 // Base en r :
00386 //------------
00387         switch ( type_r0 ) {
00388             
00389             case FIN :           
00390 // echantillonnage fin
00391             
00392             base1 = base1 | R_CHEB  ;  
00393             base2 = base2 | R_CHEB  ;  
00394             base3 = base3 | R_CHEB  ;  
00395             break ;
00396 
00397             case FINJAC :            
00398 // echantillonnage fin de Jacobi
00399             
00400             base1 = base1 | R_JACO02  ;  
00401             base2 = base2 | R_JACO02  ;  
00402             base3 = base3 | R_JACO02  ;  
00403             break ;
00404 
00405             case RARE :          
00406 // echantillonnage rarefie
00407 
00408             base1 = base1 | R_CHEBPI_P ;  
00409             base2 = base2 | R_CHEBPI_P ;  
00410             base3 = base3 | R_CHEBPI_P ;  
00411             
00412             break ;
00413 
00414             case UNSURR :           
00415 // echantillonnage fin (1/r)
00416 
00417             base1 = base1 | R_CHEBU  ;  
00418             base2 = base2 | R_CHEBU  ;  
00419             base3 = base3 | R_CHEBU  ;  
00420             break ;
00421 
00422 
00423             default : 
00424             cout << 
00425         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
00426               << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00427             cout << 
00428               " dans la zone l = " << l << " n'est pas prevu ! " 
00429               << endl ;
00430               abort () ;
00431         }
00432 
00433         break ; // fin du cas type_t = NONSYM
00434             
00435 
00436         default : 
00437             cout << 
00438         "Mg3d::std_base_vect_cart : le cas type_p, type_t = " 
00439               << type_p<< " " <<type_t << endl ;
00440             cout << 
00441               " dans la zone l = " << l << " n'est pas prevu ! " 
00442               << endl ;
00443             abort () ;
00444 
00445         }   // fin des cas sur type_t 
00446 
00447 
00448 
00449     break ; // fin du cas symetrie phi -> phi + pi
00450 
00451 
00452     default : 
00453         cout << 
00454         "Mg3d::std_base_vect_cart : le cas type_p = " << type_p << endl ;
00455         cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00456          << endl ;
00457         abort () ;
00458         
00459         
00460     }   // Fin des cas en phi
00461     
00462     bases[0]->b[l] = base1 ;
00463     bases[1]->b[l] = base2 ;
00464     bases[2]->b[l] = base3 ;
00465     }   //fin de la boucle sur les zones.
00466   
00467     return bases ;
00468 }
00469             //---------------------------------------//
00470             //  Bases for the spherical components   //
00471             //    of a vector field          //
00472             //---------------------------------------//
00473             
00474 
00475 /*
00476  * Calcul les bases spectrales associees aux composantes spheriques d'un 
00477  * vecteur antisymetrique en z (pour la composante z)
00478  * 
00479  * (*THIS) est la grille du calcul
00480  * SORTIE : un tableau sur les 3 compsantes (r=1, theta=2, phi=3) contenant 
00481  * les bases de decomposition
00482  * 
00483  */
00484 
00485 Base_val** Mg3d::std_base_vect_spher() const {
00486      
00487     // nbre de zones :
00488     int nz = get_nzone() ;
00489     
00490     // Tableau contenant le resultat...
00491     Base_val** bases = new Base_val*[3] ;
00492     for (int i=0 ; i<3 ; i++)
00493     bases[i] = new Base_val(nz) ;
00494     
00495     // Boucle sur les differentes zones :
00496     for (int l=0; l<nzone; l++) {
00497     
00498     // Type d'echantillonnage de la zone l :
00499     int type_r0 = get_type_r(l) ;
00500     
00501     // Bases de developpement en (r,theta,phi) a determiner pour les 
00502     // composantes (1,2,3) du vecteur : 
00503     
00504     int base1,  base2, base3 ;  
00505     switch ( type_p ) {
00506         
00507     case NONSYM :   
00508 //---------------------------------------------------------
00509 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
00510 //---------------------------------------------------------
00511 
00512       // Base en phi:
00513       //-------------
00514       base1 = P_COSSIN ;        
00515       base2 = P_COSSIN ;        
00516       base3 = P_COSSIN ;        
00517     
00518     
00519       // Base en theta:
00520       //---------------
00521       switch ( type_t ) {
00522       case SYM :    
00523 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
00524 //------------------------------------------------------
00525     base1 = base1 | T_COSSIN_CP ; 
00526     base2 = base2 | T_COSSIN_SP ; 
00527     base3 = base3 | T_COSSIN_SI ; 
00528 
00529     // Base en r :
00530     //------------
00531     switch ( type_r0 ) {
00532             
00533     case FIN :           
00534 // echantillonnage fin
00535             
00536       base1 = base1 | R_CHEB  ;  
00537       base2 = base2 | R_CHEB  ;  
00538       base3 = base3 | R_CHEB  ;  
00539       break ;
00540 
00541             case FINJAC :            
00542 // echantillonnage fin de Jacobi
00543             
00544             base1 = base1 | R_JACO02  ;  
00545             base2 = base2 | R_JACO02  ;  
00546             base3 = base3 | R_JACO02  ;  
00547             break ;
00548 
00549     case RARE :          
00550 // echantillonnage rarefie
00551 
00552       base1 = base1 | R_CHEBPIM_I ;  
00553       base2 = base2 | R_CHEBPIM_I ;  
00554       base3 = base3 | R_CHEBPIM_I ;  
00555             
00556       break ;
00557 
00558     case UNSURR :           
00559 // echantillonnage fin (1/r)
00560 
00561       base1 = base1 | R_CHEBU  ;  
00562       base2 = base2 | R_CHEBU  ;  
00563       base3 = base3 | R_CHEBU  ;  
00564       break ;
00565 
00566 
00567     default : 
00568       cout << 
00569         "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = " 
00570            << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00571       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00572            << endl ;
00573       abort () ;
00574     }
00575 
00576     break ; // fin du cas type_t = SYM
00577             
00578       case NONSYM :     
00579 // pas de symetrie en theta  :  theta dans [0, pi]      
00580 //------------------------------------------------
00581           
00582           base1 = base1 | T_COSSIN_C ; 
00583           base2 = base2 | T_COSSIN_S ; 
00584           base3 = base3 | T_COSSIN_S ; 
00585           
00586     // Base en r :
00587     //------------
00588           switch ( type_r0 ) {
00589           
00590           case FIN :             
00591 // echantillonnage fin
00592               
00593               base1 = base1 | R_CHEB  ;  
00594               base2 = base2 | R_CHEB  ;  
00595               base3 = base3 | R_CHEB  ;  
00596               break ;
00597 
00598           case FINJAC :              
00599 // echantillonnage fin de Jacobi
00600               
00601               base1 = base1 | R_JACO02  ;  
00602               base2 = base2 | R_JACO02  ;  
00603               base3 = base3 | R_JACO02  ;  
00604               break ;
00605               
00606           case RARE :        
00607 // echantillonnage rarefie
00608               
00609               base1 = base1 | R_CHEBPI_I ;  
00610               base2 = base2 | R_CHEBPI_I ;  
00611               base3 = base3 | R_CHEBPI_P ;  
00612             
00613               break ;
00614 
00615     case UNSURR :           
00616 // echantillonnage fin (1/r)
00617 
00618       base1 = base1 | R_CHEBU  ;  
00619       base2 = base2 | R_CHEBU  ;  
00620       base3 = base3 | R_CHEBU  ;  
00621       break ;
00622 
00623 
00624     default : 
00625       cout << 
00626         "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = " 
00627            << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00628       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00629            << endl ;
00630       abort () ;
00631     }
00632 
00633     break ; // fin du cas type_t = SYM
00634             
00635             
00636       default : 
00637     cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = " 
00638          << type_p<< " " <<type_t << endl ;
00639     cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00640          << endl ;
00641     abort () ;
00642 
00643       } // fin des cas sur type_t 
00644 
00645       break ;   // fin du cas sans symetrie pour phi 
00646 
00647 
00648         case SYM :  
00649 //---------------------------------------------------------
00650 // Cas symetrie phi -> phi + pi :  phi in [0, pi]
00651 //---------------------------------------------------------
00652 
00653       // Base en phi:
00654       //-------------
00655       base1 = P_COSSIN_P ;     
00656       base2 = P_COSSIN_P ;     
00657       base3 = P_COSSIN_P ;     
00658     
00659     
00660       // Base en theta:
00661       //---------------
00662       switch ( type_t ) {
00663 
00664       case SYM :    
00665 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
00666 //------------------------------------------------------
00667     base1 = base1 | T_COS_P ;       
00668     base2 = base2 | T_SIN_P ;       
00669     base3 = base3 | T_SIN_I;        
00670 
00671     // Base en r :
00672     //------------
00673     switch ( type_r0 ) {
00674             
00675     case FIN :           
00676 // echantillonnage fin
00677             
00678       base1 = base1 | R_CHEB  ;  
00679       base2 = base2 | R_CHEB  ;  
00680       base3 = base3 | R_CHEB  ;  
00681       break ;
00682 
00683             case FINJAC :            
00684 // echantillonnage fin de Jacobi
00685             
00686             base1 = base1 | R_JACO02  ;  
00687             base2 = base2 | R_JACO02  ;  
00688             base3 = base3 | R_JACO02  ;  
00689             break ;
00690 
00691     case RARE :          
00692 // echantillonnage rarefie
00693 
00694       base1 = base1 | R_CHEBI ;  
00695       base2 = base2 | R_CHEBI ;  
00696       base3 = base3 | R_CHEBI ;  
00697       break ;
00698 
00699     case UNSURR :           
00700 // echantillonnage fin (1/r)
00701 
00702       base1 = base1 | R_CHEBU  ;  
00703       base2 = base2 | R_CHEBU  ;  
00704       base3 = base3 | R_CHEBU  ;  
00705       break ;
00706 
00707 
00708     default : 
00709       cout << 
00710         "Mg3d::std_base_vect_spher : le cas type_p, type_t, type_r = " 
00711            << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
00712       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00713            << endl ;
00714       abort () ;
00715     }
00716 
00717     break ; // fin du cas type_t = SYM
00718             
00719       case NONSYM :     
00720 // pas de symetrie en theta  :  theta dans [0, pi]      
00721 //------------------------------------------------
00722           
00723           base1 = base1 | T_COS ; 
00724           base2 = base2 | T_SIN ; 
00725           base3 = base3 | T_SIN ; 
00726           
00727     // Base en r :
00728     //------------
00729           switch ( type_r0 ) {
00730           
00731           case FIN :             
00732 // echantillonnage fin
00733               
00734               base1 = base1 | R_CHEB  ;  
00735               base2 = base2 | R_CHEB  ;  
00736               base3 = base3 | R_CHEB  ;  
00737               break ;
00738 
00739           case FINJAC :              
00740 // echantillonnage fin de Jacobi
00741               
00742               base1 = base1 | R_JACO02  ;  
00743               base2 = base2 | R_JACO02  ;  
00744               base3 = base3 | R_JACO02  ;  
00745               break ;
00746               
00747           case RARE :        
00748 // echantillonnage rarefie
00749               
00750               base1 = base1 | R_CHEBPI_I ;  
00751               base2 = base2 | R_CHEBPI_I ;  
00752               base3 = base3 | R_CHEBPI_P ;  
00753             
00754               break ;
00755 
00756     case UNSURR :           
00757 // echantillonnage fin (1/r)
00758 
00759       base1 = base1 | R_CHEBU  ;  
00760       base2 = base2 | R_CHEBU  ;  
00761       base3 = base3 | R_CHEBU  ;  
00762       break ;
00763 
00764       default : 
00765     cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = " 
00766          << type_p<< " " <<type_t << endl ;
00767     cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00768          << endl ;
00769     abort () ;
00770           }
00771       } // fin des cas sur type_t 
00772 
00773       break ;   // fin du cas symetrie phi -> phi + pi
00774 
00775     default : 
00776       cout << 
00777     "Mg3d::std_base_vect_spher : le cas type_p = " << type_p << endl ;
00778       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
00779        << endl ;
00780       abort () ;
00781         
00782         
00783     }   // Fin des cas en phi
00784     
00785     bases[0]->b[l] = base1 ;
00786     bases[1]->b[l] = base2 ;
00787     bases[2]->b[l] = base3 ;
00788     }   //fin de la boucle sur les zones.
00789   
00790   return bases ;
00791 }
00792 
00793 
00794             //---------------------------------------//
00795             //  Bases for the Cartesian components   //
00796             //    of a pseudo vector field       //
00797             //---------------------------------------//
00798             
00799 
00800 /*
00801  * Calcul les bases spectrales associees aux composantes cartesiennes d'un pseudo vecteur
00802  * symetrique en z (pour la composante z)
00803  * 
00804  * (*THIS) est la grille du calcul
00805  * SORTIE : un tableau sur les 3 compsantes (x=1, y=2, z=3) contenant les bases
00806  * de decomposition
00807  * 
00808  */
00809 
00810 Base_val** Mg3d::pseudo_base_vect_cart() const {
00811      
00812      // nbre de zones :
00813      int nz = get_nzone() ;
00814      
00815      // Tableau contenant le resultat...
00816      Base_val** bases = new Base_val*[3] ;
00817      for (int i=0 ; i<3 ; i++)
00818     bases[i] = new Base_val(nz) ;
00819                 
00820     // Boucle sur les differentes zones :
00821     for (int l=0; l<nzone; l++) {
00822 
00823     // Type d'echantillonnage de la zone l :
00824     int type_r0 = get_type_r(l) ;
00825 
00826     // Bases de developpement en (r,theta,phi) a determiner pour les composantes
00827     // (1,2,3) du vecteur : 
00828     
00829     int base1,  base2, base3 ;  
00830     switch ( type_p ) {
00831     
00832         case NONSYM :   
00833 //---------------------------------------------------------
00834 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
00835 //---------------------------------------------------------
00836 
00837 // Base en phi:
00838 //-------------
00839         base1 = P_COSSIN ;      
00840         base2 = P_COSSIN ;      
00841         base3 = P_COSSIN ;      
00842     
00843     
00844 // Base en theta:
00845 //---------------
00846         switch ( type_t ) {
00847         case SYM :      
00848 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
00849 //------------------------------------------------------
00850         base1 = base1 | T_COSSIN_CI ; 
00851         base2 = base2 | T_COSSIN_CI ; 
00852         base3 = base3 | T_COSSIN_CP ; 
00853 
00854 // Base en r :
00855 //------------
00856         switch ( type_r0 ) {
00857             
00858             case FIN :           
00859 // echantillonnage fin
00860             
00861             base1 = base1 | R_CHEB  ;  
00862             base2 = base2 | R_CHEB  ;  
00863             base3 = base3 | R_CHEB  ;  
00864             break ;
00865 
00866             case FINJAC :            
00867 // echantillonnage fin de Jacobi
00868             
00869             base1 = base1 | R_JACO02  ;  
00870             base2 = base2 | R_JACO02  ;  
00871             base3 = base3 | R_JACO02  ;  
00872             break ;
00873 
00874 
00875             case RARE :          
00876 // echantillonnage rarefie
00877 
00878             base1 = base1 | R_CHEBPIM_I ;  
00879             base2 = base2 | R_CHEBPIM_I ;  
00880             base3 = base3 | R_CHEBPIM_P ;  
00881             
00882             break ;
00883 
00884             case UNSURR :           
00885 // echantillonnage fin (1/r)
00886 
00887             base1 = base1 | R_CHEBU  ;  
00888             base2 = base2 | R_CHEBU  ;  
00889             base3 = base3 | R_CHEBU  ;  
00890             break ;
00891 
00892 
00893             default : 
00894             cout << 
00895         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
00896               << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00897             cout << 
00898               " dans la zone l = " << l << " n'est pas prevu ! " 
00899               << endl ;
00900               abort () ;
00901         }
00902 
00903         break ; // fin du cas type_t = SYM
00904             
00905 
00906         case NONSYM :   
00907 // pas de symetrie en theta  :  theta dans [0, pi]      
00908 //------------------------------------------------
00909         base1 = base1 | T_COSSIN_C ; 
00910         base2 = base2 | T_COSSIN_C ; 
00911         base3 = base3 | T_COSSIN_C ; 
00912 
00913 // Base en r :
00914 //------------
00915         switch ( type_r0 ) {
00916             
00917             case FIN :           
00918 // echantillonnage fin
00919             
00920             base1 = base1 | R_CHEB  ;  
00921             base2 = base2 | R_CHEB  ;  
00922             base3 = base3 | R_CHEB  ;  
00923             break ;
00924 
00925             case FINJAC :            
00926 // echantillonnage fin de Jacobi
00927             
00928             base1 = base1 | R_JACO02  ;  
00929             base2 = base2 | R_JACO02  ;  
00930             base3 = base3 | R_JACO02  ;  
00931             break ;
00932 
00933             case RARE :          
00934 // echantillonnage rarefie
00935 
00936             base1 = base1 | R_CHEBPI_P ;  
00937             base2 = base2 | R_CHEBPI_P ;  
00938             base3 = base3 | R_CHEBPI_P ;  
00939             
00940             break ;
00941 
00942             case UNSURR :           
00943 // echantillonnage fin (1/r)
00944 
00945             base1 = base1 | R_CHEBU  ;  
00946             base2 = base2 | R_CHEBU  ;  
00947             base3 = base3 | R_CHEBU  ;  
00948             break ;
00949 
00950 
00951             default : 
00952             cout << 
00953         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
00954               << type_p<< " " << type_t<< " " <<type_r0 << endl ;
00955             cout << 
00956               " dans la zone l = " << l << " n'est pas prevu ! " 
00957               << endl ;
00958               abort () ;
00959         }
00960 
00961         break ; // fin du cas type_t = NONSYM
00962             
00963 
00964 
00965             
00966         default : 
00967             cout << 
00968         "Mg3d::std_base_vect_cart : le cas type_p, type_t = " 
00969               << type_p<< " " <<type_t << endl ;
00970             cout << 
00971               " dans la zone l = " << l << " n'est pas prevu ! " 
00972               << endl ;
00973             abort () ;
00974 
00975         }   // fin des cas sur type_t 
00976 
00977 
00978 
00979         break ; // fin du cas sans symetrie pour phi 
00980 
00981 
00982         case SYM :  
00983 //---------------------------------------------------------
00984 // Cas symetrie phi -> phi + pi :  phi in [0, pi]
00985 //---------------------------------------------------------
00986 
00987 // Base en phi:
00988 //-------------
00989         base1 = P_COSSIN_I ;       
00990         base2 = P_COSSIN_I ;       
00991         base3 = P_COSSIN_P ;       
00992     
00993     
00994 // Base en theta:
00995 //---------------
00996         switch ( type_t ) {
00997 
00998         case SYM :      
00999 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
01000 //------------------------------------------------------
01001         base1 = base1 | T_SIN_P ;       
01002         base2 = base2 | T_SIN_P ;       
01003         base3 = base3 | T_COS_P;        
01004 
01005 // Base en r :
01006 //------------
01007         switch ( type_r0 ) {
01008             
01009             case FIN :           
01010 // echantillonnage fin
01011             
01012             base1 = base1 | R_CHEB  ;  
01013             base2 = base2 | R_CHEB  ;  
01014             base3 = base3 | R_CHEB  ;  
01015             break ;
01016 
01017             case FINJAC :            
01018 // echantillonnage fin de Jacobi
01019             
01020             base1 = base1 | R_JACO02  ;  
01021             base2 = base2 | R_JACO02  ;  
01022             base3 = base3 | R_JACO02  ;  
01023             break ;
01024 
01025             case RARE :          
01026 // echantillonnage rarefie
01027 
01028             base1 = base1 | R_CHEBP ;  
01029             base2 = base2 | R_CHEBP ;  
01030             base3 = base3 | R_CHEBP ;  
01031             break ;
01032 
01033             case UNSURR :           
01034 // echantillonnage fin (1/r)
01035 
01036             base1 = base1 | R_CHEBU  ;  
01037             base2 = base2 | R_CHEBU  ;  
01038             base3 = base3 | R_CHEBU  ;  
01039             break ;
01040 
01041 
01042             default : 
01043             cout << 
01044         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
01045               << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
01046             cout << 
01047               " dans la zone l = " << l << " n'est pas prevu ! " 
01048               << endl ;
01049               abort () ;
01050         }
01051 
01052         break ; // fin du cas type_t = SYM
01053             
01054             
01055         case NONSYM :   
01056 // pas de symetrie en theta  :  theta dans [0, pi]      
01057 //------------------------------------------------
01058         base1 = base1 | T_SIN ; 
01059         base2 = base2 | T_SIN ; 
01060         base3 = base3 | T_COS ; 
01061 
01062 // Base en r :
01063 //------------
01064         switch ( type_r0 ) {
01065             
01066             case FIN :           
01067 // echantillonnage fin
01068             
01069             base1 = base1 | R_CHEB  ;  
01070             base2 = base2 | R_CHEB  ;  
01071             base3 = base3 | R_CHEB  ;  
01072             break ;
01073 
01074             case FINJAC :            
01075 // echantillonnage fin de Jacobi
01076             
01077             base1 = base1 | R_JACO02  ;  
01078             base2 = base2 | R_JACO02  ;  
01079             base3 = base3 | R_JACO02  ;  
01080             break ;
01081 
01082             case RARE :          
01083 // echantillonnage rarefie
01084 
01085             base1 = base1 | R_CHEBPI_P ;  
01086             base2 = base2 | R_CHEBPI_P ;  
01087             base3 = base3 | R_CHEBPI_P ;  
01088             
01089             break ;
01090 
01091             case UNSURR :           
01092 // echantillonnage fin (1/r)
01093 
01094             base1 = base1 | R_CHEBU  ;  
01095             base2 = base2 | R_CHEBU  ;  
01096             base3 = base3 | R_CHEBU  ;  
01097             break ;
01098 
01099 
01100             default : 
01101             cout << 
01102         "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = " 
01103               << type_p<< " " << type_t<< " " <<type_r0 << endl ;
01104             cout << 
01105               " dans la zone l = " << l << " n'est pas prevu ! " 
01106               << endl ;
01107               abort () ;
01108         }
01109 
01110         break ; // fin du cas type_t = NONSYM
01111             
01112         default : 
01113             cout << 
01114         "Mg3d::std_base_vect_cart : le cas type_p, type_t = " 
01115               << type_p<< " " <<type_t << endl ;
01116             cout << 
01117               " dans la zone l = " << l << " n'est pas prevu ! " 
01118               << endl ;
01119             abort () ;
01120 
01121         }   // fin des cas sur type_t 
01122 
01123 
01124 
01125     break ; // fin du cas symetrie phi -> phi + pi
01126 
01127 
01128     default : 
01129         cout << 
01130         "Mg3d::std_base_vect_cart : le cas type_p = " << type_p << endl ;
01131         cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01132          << endl ;
01133         abort () ;
01134         
01135         
01136     }   // Fin des cas en phi
01137     
01138     bases[0]->b[l] = base1 ;
01139     bases[1]->b[l] = base2 ;
01140     bases[2]->b[l] = base3 ;
01141     }   //fin de la boucle sur les zones.
01142   
01143     return bases ;
01144 }
01145             //---------------------------------------//
01146             //  Bases for the spherical components   //
01147             //    of a pseudo-vector field       //
01148             //---------------------------------------//
01149             
01150 
01151 /*
01152  * Calcul les bases spectrales associees aux composantes spheriques d'un 
01153  * pseudo-vecteur symetrique en z (pour la composante z)
01154  * 
01155  * (*THIS) est la grille du calcul
01156  * SORTIE : un tableau sur les 3 compsantes (r=1, theta=2, phi=3) contenant 
01157  * les bases de decomposition
01158  * 
01159  */
01160 
01161 Base_val** Mg3d::pseudo_base_vect_spher() const {
01162      
01163   // nbre de zones :
01164   int nz = get_nzone() ;
01165   
01166   // Tableau contenant le resultat...
01167   Base_val** bases = new Base_val*[3] ;
01168   for (int i=0 ; i<3 ; i++)
01169     bases[i] = new Base_val(nz) ;
01170   
01171   // Boucle sur les differentes zones :
01172   for (int l=0; l<nzone; l++) {
01173     
01174     // Type d'echantillonnage de la zone l :
01175     int type_r0 = get_type_r(l) ;
01176     
01177     // Bases de developpement en (r,theta,phi) a determiner pour les 
01178     // composantes (1,2,3) du vecteur : 
01179     
01180     int base1,  base2, base3 ;  
01181     switch ( type_p ) {
01182     
01183     case NONSYM :   
01184 //---------------------------------------------------------
01185 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
01186 //---------------------------------------------------------
01187 
01188       // Base en phi:
01189       //-------------
01190       base1 = P_COSSIN ;        
01191       base2 = P_COSSIN ;        
01192       base3 = P_COSSIN ;        
01193     
01194     
01195       // Base en theta:
01196       //---------------
01197       switch ( type_t ) {
01198       case SYM :    
01199 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
01200 //------------------------------------------------------
01201     base1 = base1 | T_COSSIN_CI ; 
01202     base2 = base2 | T_COSSIN_SI ; 
01203     base3 = base3 | T_COSSIN_SP ; 
01204 
01205     // Base en r :
01206     //------------
01207     switch ( type_r0 ) {
01208             
01209     case FIN :           
01210 // echantillonnage fin
01211             
01212       base1 = base1 | R_CHEB  ;  
01213       base2 = base2 | R_CHEB  ;  
01214       base3 = base3 | R_CHEB  ;  
01215       break ;
01216 
01217             case FINJAC :            
01218 // echantillonnage fin de Jacobi
01219             
01220             base1 = base1 | R_JACO02  ;  
01221             base2 = base2 | R_JACO02  ;  
01222             base3 = base3 | R_JACO02  ;  
01223             break ;
01224 
01225     case RARE :          
01226 // echantillonnage rarefie
01227 
01228       base1 = base1 | R_CHEBPIM_P ;  
01229       base2 = base2 | R_CHEBPIM_P ;  
01230       base3 = base3 | R_CHEBPIM_P ;  
01231             
01232       break ;
01233 
01234     case UNSURR :           
01235 // echantillonnage fin (1/r)
01236 
01237       base1 = base1 | R_CHEBU  ;  
01238       base2 = base2 | R_CHEBU  ;  
01239       base3 = base3 | R_CHEBU  ;  
01240       break ;
01241 
01242 
01243     default : 
01244       cout << 
01245         "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = " 
01246            << type_p<< " " << type_t<< " " <<type_r0 << endl ;
01247       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01248            << endl ;
01249       abort () ;
01250     }
01251 
01252     break ; // fin du cas type_t = SYM
01253             
01254       case NONSYM :     
01255 // pas de symetrie en theta  :  theta dans [0, pi]      
01256 //------------------------------------------------
01257 
01258     base1 = base1 | T_COSSIN_C ; 
01259     base2 = base2 | T_COSSIN_S ; 
01260     base3 = base3 | T_COSSIN_S ; 
01261 
01262     // Base en r :
01263     //------------
01264     switch ( type_r0 ) {
01265             
01266     case FIN :           
01267 // echantillonnage fin
01268             
01269       base1 = base1 | R_CHEB  ;  
01270       base2 = base2 | R_CHEB  ;  
01271       base3 = base3 | R_CHEB  ;  
01272       break ;
01273 
01274             case FINJAC :            
01275 // echantillonnage fin de Jacobi
01276             
01277             base1 = base1 | R_JACO02  ;  
01278             base2 = base2 | R_JACO02  ;  
01279             base3 = base3 | R_JACO02  ;  
01280             break ;
01281 
01282     case RARE :          
01283 // echantillonnage rarefie
01284 
01285       base1 = base1 | R_CHEBPI_I ;  
01286       base2 = base2 | R_CHEBPI_I ;  
01287       base3 = base3 | R_CHEBPI_P ;  
01288             
01289       break ;
01290 
01291     case UNSURR :           
01292 // echantillonnage fin (1/r)
01293 
01294       base1 = base1 | R_CHEBU  ;  
01295       base2 = base2 | R_CHEBU  ;  
01296       base3 = base3 | R_CHEBU  ;  
01297       break ;
01298 
01299 
01300     default : 
01301       cout << 
01302         "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = " 
01303            << type_p<< " " << type_t<< " " <<type_r0 << endl ;
01304       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01305            << endl ;
01306       abort () ;
01307     }
01308 
01309     break ; // fin du cas type_t = NONSYM
01310             
01311             
01312       default : 
01313     cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = " 
01314          << type_p<< " " <<type_t << endl ;
01315     cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01316          << endl ;
01317     abort () ;
01318 
01319       } // fin des cas sur type_t 
01320 
01321       break ;   // fin du cas sans symetrie pour phi 
01322 
01323 
01324     case SYM :  
01325 //---------------------------------------------------------
01326 // Cas symetrie phi -> phi + pi :  phi in [0, pi]
01327 //---------------------------------------------------------
01328 
01329       // Base en phi:
01330       //-------------
01331       base1 = P_COSSIN_P ;     
01332       base2 = P_COSSIN_P ;     
01333       base3 = P_COSSIN_P ;     
01334     
01335     
01336       // Base en theta:
01337       //---------------
01338       switch ( type_t ) {
01339 
01340       case SYM :    
01341 // symetrie theta -> pi - theta :  theta dans [0, pi/2]     
01342 //------------------------------------------------------
01343     base1 = base1 | T_COS_I ;       
01344     base2 = base2 | T_SIN_I ;       
01345     base3 = base3 | T_SIN_P;        
01346 
01347     // Base en r :
01348     //------------
01349     switch ( type_r0 ) {
01350             
01351     case FIN :           
01352 // echantillonnage fin
01353             
01354       base1 = base1 | R_CHEB  ;  
01355       base2 = base2 | R_CHEB  ;  
01356       base3 = base3 | R_CHEB  ;  
01357       break ;
01358 
01359             case FINJAC :            
01360 // echantillonnage fin de Jacobi
01361             
01362             base1 = base1 | R_JACO02  ;  
01363             base2 = base2 | R_JACO02  ;  
01364             base3 = base3 | R_JACO02  ;  
01365             break ;
01366 
01367     case RARE :          
01368 // echantillonnage rarefie
01369 
01370       base1 = base1 | R_CHEBP ;  
01371       base2 = base2 | R_CHEBP ;  
01372       base3 = base3 | R_CHEBP ;  
01373       break ;
01374 
01375     case UNSURR :           
01376 // echantillonnage fin (1/r)
01377 
01378       base1 = base1 | R_CHEBU  ;  
01379       base2 = base2 | R_CHEBU  ;  
01380       base3 = base3 | R_CHEBU  ;  
01381       break ;
01382 
01383 
01384     default : 
01385       cout << 
01386         "Mg3d::std_base_vect_spher : le cas type_p, type_t, type_r = " 
01387            << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
01388       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01389            << endl ;
01390       abort () ;
01391     }
01392 
01393     break ; // fin du cas type_t = SYM
01394             
01395       case NONSYM :     
01396 // pas de symetrie en theta  :  theta dans [0, pi]      
01397 //------------------------------------------------
01398           
01399           base1 = base1 | T_COS ; 
01400           base2 = base2 | T_SIN ; 
01401           base3 = base3 | T_SIN ; 
01402           
01403     // Base en r :
01404     //------------
01405           switch ( type_r0 ) {
01406           
01407           case FIN :             
01408 // echantillonnage fin
01409               
01410               base1 = base1 | R_CHEB  ;  
01411               base2 = base2 | R_CHEB  ;  
01412               base3 = base3 | R_CHEB  ;  
01413               break ;
01414 
01415           case FINJAC :              
01416 // echantillonnage fin de Jacobi
01417               
01418               base1 = base1 | R_JACO02  ;  
01419               base2 = base2 | R_JACO02  ;  
01420               base3 = base3 | R_JACO02  ;  
01421               break ;
01422               
01423           case RARE :        
01424 // echantillonnage rarefie
01425               
01426               base1 = base1 | R_CHEBPI_I ;  
01427               base2 = base2 | R_CHEBPI_I ;  
01428               base3 = base3 | R_CHEBPI_P ;  
01429             
01430               break ;
01431 
01432     case UNSURR :           
01433 // echantillonnage fin (1/r)
01434 
01435       base1 = base1 | R_CHEBU  ;  
01436       base2 = base2 | R_CHEBU  ;  
01437       base3 = base3 | R_CHEBU  ;  
01438       break ;
01439 
01440       default : 
01441     cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = " 
01442          << type_p<< " " <<type_t << endl ;
01443     cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01444          << endl ;
01445     abort () ;
01446     
01447       } // fin des cas sur type_t 
01448 
01449       default : 
01450     cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = " 
01451          << type_p<< " " <<type_t << endl ;
01452     cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01453          << endl ;
01454     abort () ;
01455     
01456       } // fin des cas sur type_t 
01457 
01458       break ;   // fin du cas symetrie phi -> phi + pi
01459 
01460     default : 
01461       cout << 
01462     "Mg3d::std_base_vect_spher : le cas type_p = " << type_p << endl ;
01463       cout << " dans la zone l = " << l << " n'est pas prevu ! " 
01464        << endl ;
01465       abort () ;
01466         
01467         
01468     }   // Fin des cas en phi
01469     
01470     bases[0]->b[l] = base1 ;
01471     bases[1]->b[l] = base2 ;
01472     bases[2]->b[l] = base3 ;
01473   } //fin de la boucle sur les zones.
01474   
01475   return bases ;
01476 }
01477
Generated on Tue Feb 7 01:35:18 2012 for LORENE by  doxygen 1.4.6