LORENE
mg3d_std_base.C
1 /*
2  * Methods of class Mg3d to get the standard spectral bases for scalar and
3  * vector fields.
4  */
5 
6 /*
7  * Copyright (c) 1999-2001 Eric Gourgoulhon
8  *
9  * This file is part of LORENE.
10  *
11  * LORENE is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * LORENE is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with LORENE; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24  *
25  */
26 
27 
28 
29 
30 /*
31  * $Id: mg3d_std_base.C,v 1.15 2025/03/26 10:12:20 j_novak Exp $
32  * $Log: mg3d_std_base.C,v $
33  * Revision 1.15 2025/03/26 10:12:20 j_novak
34  * New derived grid containing 50% more points in every direction, additional tool for de-aliasing.
35  *
36  * Revision 1.14 2016/12/05 16:17:59 j_novak
37  * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
38  *
39  * Revision 1.13 2014/10/13 08:53:07 j_novak
40  * Lorene classes and functions now belong to the namespace Lorene.
41  *
42  * Revision 1.12 2014/10/06 15:13:14 j_novak
43  * Modified #include directives to use c++ syntax.
44  *
45  * Revision 1.11 2013/06/05 15:10:42 j_novak
46  * Suppression of FINJAC sampling in r. This Jacobi(0,2) base is now
47  * available by setting colloc_r to BASE_JAC02 in the Mg3d constructor.
48  *
49  * Revision 1.10 2012/01/24 15:02:28 j_novak
50  * Minor change to avoid warnings
51  *
52  * Revision 1.9 2009/10/08 16:21:02 j_novak
53  * Addition of new bases T_COS and T_SIN.
54  *
55  * Revision 1.8 2008/10/29 08:21:35 jl_cornou
56  * Spectral bases for pseudo vectors added
57  *
58  * Revision 1.7 2007/12/14 10:19:32 jl_cornou
59  * *** empty log message ***
60  *
61  * Revision 1.6 2005/10/25 08:56:37 p_grandclement
62  * addition of std_spectral_base in the case of odd functions near the origin
63  *
64  * Revision 1.5 2005/02/16 15:09:16 m_forot
65  * Add R_CHEBPI_I and R_CHEBPI_P cases
66  *
67  * Revision 1.4 2004/11/04 15:21:42 e_gourgoulhon
68  * The case without any symmetry in theta is now treated.
69  *
70  * Revision 1.3 2003/12/19 16:21:45 j_novak
71  * Shadow hunt
72  *
73  * Revision 1.2 2002/08/13 08:02:45 j_novak
74  * Handling of spherical vector/tensor components added in the classes
75  * Mg3d and Tenseur. Minor corrections for the class Metconf.
76  *
77  * Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
78  * LORENE
79  *
80  * Revision 1.2 2000/09/27 15:07:40 eric
81  * Correction dans le cas type_p = SYM.
82  *
83  * Revision 1.1 1999/10/12 14:54:43 eric
84  * Initial revision
85  *
86  *
87  * $Header: /cvsroot/Lorene/C++/Source/Mg3d/mg3d_std_base.C,v 1.15 2025/03/26 10:12:20 j_novak Exp $
88  *
89  */
90 
91 // headers C++
92 
93 // headers C
94 #include <cassert>
95 
96 // headers Lorene
97 #include "grilles.h"
98 #include "base_val.h"
99 #include "type_parite.h"
100 
101  //-----------------------------//
102  // Bases for a scalar field //
103  //-----------------------------//
104 
105 
106 namespace Lorene {
107 Base_val Mg3d::std_base_scal() const {
108 
109  Base_val base(nzone) ;
110 
111  for (int l=0; l<nzone; l++) {
112  switch ( colloc_r[l] ) {
113  case BASE_CHEB :
114  base.b[l] = std_base_scal_1z(type_r[l], type_t, type_p) ;
115  break ;
116 
117  case BASE_LEG :
118  base.b[l] = leg_base_scal_1z(type_r[l], type_t, type_p) ;
119  break ;
120 
121  case BASE_JAC02 :
122  base.b[l] = jac02_base_scal_1z(type_r[l], type_t, type_p) ;
123  break ;
124 
125  default :
126  cout << "Mg3d::std_base_scal : unknown type of radial base!"
127  << endl ;
128  abort() ;
129 
130  } // End of switch
131  } // End of loop on domains
132 
133  return base ;
134 
135 }
136 
137 Base_val Mg3d::std_base_scal_odd() const {
138 
139  Base_val base(nzone) ;
140 
141  for (int l=0; l<nzone; l++) {
142  switch ( colloc_r[l] ) {
143  case BASE_CHEB :
144  base.b[l] = std_base_scal_odd_1z(type_r[l], type_t, type_p) ;
145  break ;
146 
147  case BASE_LEG :
148  base.b[l] = leg_base_scal_odd_1z(type_r[l], type_t, type_p) ;
149  break ;
150 
151  case BASE_JAC02 : // No defined parity for Jacobi(0,2) polynomials
152  base.b[l] = jac02_base_scal_1z(type_r[l], type_t, type_p) ;
153  break ;
154 
155  default :
156  cout << "Mg3d::std_base_scal_odd : unknown type of radial base!"
157  << endl ;
158  abort() ;
159 
160  } // End of switch
161  } // End of loop on domains
162 
163  return base ;
164 
165 }
166 
167  //---------------------------------------//
168  // Bases for the Cartesian components //
169  // of a vector field //
170  //---------------------------------------//
171 
172 
173 /*
174  * Calcul les bases spectrales associees aux composantes cartesiennes d'un vecteur
175  * antisymetrique en z (pour la composante z)
176  *
177  * (*THIS) est la grille du calcul
178  * SORTIE : un tableau sur les 3 compsantes (x=1, y=2, z=3) contenant les bases
179  * de decomposition
180  *
181  */
182 
183 Base_val** Mg3d::std_base_vect_cart() const {
184 
185  // nbre de zones :
186  int nz = get_nzone() ;
187 
188  // Tableau contenant le resultat...
189  Base_val** bases = new Base_val*[3] ;
190  for (int i=0 ; i<3 ; i++)
191  bases[i] = new Base_val(nz) ;
192 
193  // Boucle sur les differentes zones :
194  for (int l=0; l<nzone; l++) {
195 
196  assert (colloc_r[l] == BASE_CHEB) ;
197 
198  // Type d'echantillonnage de la zone l :
199  int type_r0 = get_type_r(l) ;
200 
201  // Bases de developpement en (r,theta,phi) a determiner pour les composantes
202  // (1,2,3) du vecteur :
203 
204  int base1, base2, base3 ;
205  switch ( type_p ) {
206 
207  case NONSYM :
208 //---------------------------------------------------------
209 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
210 //---------------------------------------------------------
211 
212 // Base en phi:
213 //-------------
214  base1 = P_COSSIN ;
215  base2 = P_COSSIN ;
216  base3 = P_COSSIN ;
217 
218 
219 // Base en theta:
220 //---------------
221  switch ( type_t ) {
222  case SYM :
223 // symetrie theta -> pi - theta : theta dans [0, pi/2]
224 //------------------------------------------------------
225  base1 = base1 | T_COSSIN_CP ;
226  base2 = base2 | T_COSSIN_CP ;
227  base3 = base3 | T_COSSIN_CI ;
228 
229 // Base en r :
230 //------------
231  switch ( type_r0 ) {
232 
233  case FIN :
234 // echantillonnage fin
235 
236  base1 = base1 | R_CHEB ;
237  base2 = base2 | R_CHEB ;
238  base3 = base3 | R_CHEB ;
239  break ;
240 
241 
242  case RARE :
243 // echantillonnage rarefie
244 
245  base1 = base1 | R_CHEBPIM_P ;
246  base2 = base2 | R_CHEBPIM_P ;
247  base3 = base3 | R_CHEBPIM_I ;
248 
249  break ;
250 
251  case UNSURR :
252 // echantillonnage fin (1/r)
253 
254  base1 = base1 | R_CHEBU ;
255  base2 = base2 | R_CHEBU ;
256  base3 = base3 | R_CHEBU ;
257  break ;
258 
259 
260  default :
261  cout <<
262  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
263  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
264  cout <<
265  " dans la zone l = " << l << " n'est pas prevu ! "
266  << endl ;
267  abort () ;
268  }
269 
270  break ; // fin du cas type_t = SYM
271 
272 
273  case NONSYM :
274 // pas de symetrie en theta : theta dans [0, pi]
275 //------------------------------------------------
276  base1 = base1 | T_COSSIN_C ;
277  base2 = base2 | T_COSSIN_C ;
278  base3 = base3 | T_COSSIN_C ;
279 
280 // Base en r :
281 //------------
282  switch ( type_r0 ) {
283 
284  case FIN :
285 // echantillonnage fin
286 
287  base1 = base1 | R_CHEB ;
288  base2 = base2 | R_CHEB ;
289  base3 = base3 | R_CHEB ;
290  break ;
291 
292  case RARE :
293 // echantillonnage rarefie
294 
295  base1 = base1 | R_CHEBPI_P ;
296  base2 = base2 | R_CHEBPI_P ;
297  base3 = base3 | R_CHEBPI_P ;
298 
299  break ;
300 
301  case UNSURR :
302 // echantillonnage fin (1/r)
303 
304  base1 = base1 | R_CHEBU ;
305  base2 = base2 | R_CHEBU ;
306  base3 = base3 | R_CHEBU ;
307  break ;
308 
309 
310  default :
311  cout <<
312  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
313  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
314  cout <<
315  " dans la zone l = " << l << " n'est pas prevu ! "
316  << endl ;
317  abort () ;
318  }
319 
320  break ; // fin du cas type_t = NONSYM
321 
322 
323 
324 
325  default :
326  cout <<
327  "Mg3d::std_base_vect_cart : le cas type_p, type_t = "
328  << type_p<< " " <<type_t << endl ;
329  cout <<
330  " dans la zone l = " << l << " n'est pas prevu ! "
331  << endl ;
332  abort () ;
333 
334  } // fin des cas sur type_t
335 
336 
337 
338  break ; // fin du cas sans symetrie pour phi
339 
340 
341  case SYM :
342 //---------------------------------------------------------
343 // Cas symetrie phi -> phi + pi : phi in [0, pi]
344 //---------------------------------------------------------
345 
346 // Base en phi:
347 //-------------
348  base1 = P_COSSIN_I ;
349  base2 = P_COSSIN_I ;
350  base3 = P_COSSIN_P ;
351 
352 
353 // Base en theta:
354 //---------------
355  switch ( type_t ) {
356 
357  case SYM :
358 // symetrie theta -> pi - theta : theta dans [0, pi/2]
359 //------------------------------------------------------
360  base1 = base1 | T_SIN_I ;
361  base2 = base2 | T_SIN_I ;
362  base3 = base3 | T_COS_I;
363 
364 // Base en r :
365 //------------
366  switch ( type_r0 ) {
367 
368  case FIN :
369 // echantillonnage fin
370 
371  base1 = base1 | R_CHEB ;
372  base2 = base2 | R_CHEB ;
373  base3 = base3 | R_CHEB ;
374  break ;
375 
376  case RARE :
377 // echantillonnage rarefie
378 
379  base1 = base1 | R_CHEBI ;
380  base2 = base2 | R_CHEBI ;
381  base3 = base3 | R_CHEBI ;
382  break ;
383 
384  case UNSURR :
385 // echantillonnage fin (1/r)
386 
387  base1 = base1 | R_CHEBU ;
388  base2 = base2 | R_CHEBU ;
389  base3 = base3 | R_CHEBU ;
390  break ;
391 
392 
393  default :
394  cout <<
395  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
396  << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
397  cout <<
398  " dans la zone l = " << l << " n'est pas prevu ! "
399  << endl ;
400  abort () ;
401  }
402 
403  break ; // fin du cas type_t = SYM
404 
405 
406  case NONSYM :
407 // pas de symetrie en theta : theta dans [0, pi]
408 //------------------------------------------------
409  base1 = base1 | T_SIN ;
410  base2 = base2 | T_SIN ;
411  base3 = base3 | T_COS ;
412 
413 // Base en r :
414 //------------
415  switch ( type_r0 ) {
416 
417  case FIN :
418 // echantillonnage fin
419 
420  base1 = base1 | R_CHEB ;
421  base2 = base2 | R_CHEB ;
422  base3 = base3 | R_CHEB ;
423  break ;
424 
425  case RARE :
426 // echantillonnage rarefie
427 
428  base1 = base1 | R_CHEBPI_P ;
429  base2 = base2 | R_CHEBPI_P ;
430  base3 = base3 | R_CHEBPI_P ;
431 
432  break ;
433 
434  case UNSURR :
435 // echantillonnage fin (1/r)
436 
437  base1 = base1 | R_CHEBU ;
438  base2 = base2 | R_CHEBU ;
439  base3 = base3 | R_CHEBU ;
440  break ;
441 
442 
443  default :
444  cout <<
445  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
446  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
447  cout <<
448  " dans la zone l = " << l << " n'est pas prevu ! "
449  << endl ;
450  abort () ;
451  }
452 
453  break ; // fin du cas type_t = NONSYM
454 
455 
456  default :
457  cout <<
458  "Mg3d::std_base_vect_cart : le cas type_p, type_t = "
459  << type_p<< " " <<type_t << endl ;
460  cout <<
461  " dans la zone l = " << l << " n'est pas prevu ! "
462  << endl ;
463  abort () ;
464 
465  } // fin des cas sur type_t
466 
467 
468 
469  break ; // fin du cas symetrie phi -> phi + pi
470 
471 
472  default :
473  cout <<
474  "Mg3d::std_base_vect_cart : le cas type_p = " << type_p << endl ;
475  cout << " dans la zone l = " << l << " n'est pas prevu ! "
476  << endl ;
477  abort () ;
478 
479 
480  } // Fin des cas en phi
481 
482  bases[0]->b[l] = base1 ;
483  bases[1]->b[l] = base2 ;
484  bases[2]->b[l] = base3 ;
485  } //fin de la boucle sur les zones.
486 
487  return bases ;
488 }
489  //---------------------------------------//
490  // Bases for the spherical components //
491  // of a vector field //
492  //---------------------------------------//
493 
494 
495 /*
496  * Calcul les bases spectrales associees aux composantes spheriques d'un
497  * vecteur antisymetrique en z (pour la composante z)
498  *
499  * (*THIS) est la grille du calcul
500  * SORTIE : un tableau sur les 3 compsantes (r=1, theta=2, phi=3) contenant
501  * les bases de decomposition
502  *
503  */
504 
505 Base_val** Mg3d::std_base_vect_spher() const {
506 
507  // nbre de zones :
508  int nz = get_nzone() ;
509 
510  // Tableau contenant le resultat...
511  Base_val** bases = new Base_val*[3] ;
512  for (int i=0 ; i<3 ; i++)
513  bases[i] = new Base_val(nz) ;
514 
515  // Boucle sur les differentes zones :
516  for (int l=0; l<nzone; l++) {
517 
518  assert (colloc_r[l] == BASE_CHEB) ;
519 
520  // Type d'echantillonnage de la zone l :
521  int type_r0 = get_type_r(l) ;
522 
523  // Bases de developpement en (r,theta,phi) a determiner pour les
524  // composantes (1,2,3) du vecteur :
525 
526  int base1, base2, base3 ;
527  switch ( type_p ) {
528 
529  case NONSYM :
530 //---------------------------------------------------------
531 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
532 //---------------------------------------------------------
533 
534  // Base en phi:
535  //-------------
536  base1 = P_COSSIN ;
537  base2 = P_COSSIN ;
538  base3 = P_COSSIN ;
539 
540 
541  // Base en theta:
542  //---------------
543  switch ( type_t ) {
544  case SYM :
545 // symetrie theta -> pi - theta : theta dans [0, pi/2]
546 //------------------------------------------------------
547  base1 = base1 | T_COSSIN_CP ;
548  base2 = base2 | T_COSSIN_SP ;
549  base3 = base3 | T_COSSIN_SI ;
550 
551  // Base en r :
552  //------------
553  switch ( type_r0 ) {
554 
555  case FIN :
556 // echantillonnage fin
557 
558  base1 = base1 | R_CHEB ;
559  base2 = base2 | R_CHEB ;
560  base3 = base3 | R_CHEB ;
561  break ;
562 
563  case RARE :
564 // echantillonnage rarefie
565 
566  base1 = base1 | R_CHEBPIM_I ;
567  base2 = base2 | R_CHEBPIM_I ;
568  base3 = base3 | R_CHEBPIM_I ;
569 
570  break ;
571 
572  case UNSURR :
573 // echantillonnage fin (1/r)
574 
575  base1 = base1 | R_CHEBU ;
576  base2 = base2 | R_CHEBU ;
577  base3 = base3 | R_CHEBU ;
578  break ;
579 
580 
581  default :
582  cout <<
583  "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = "
584  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
585  cout << " dans la zone l = " << l << " n'est pas prevu ! "
586  << endl ;
587  abort () ;
588  }
589 
590  break ; // fin du cas type_t = SYM
591 
592  case NONSYM :
593 // pas de symetrie en theta : theta dans [0, pi]
594 //------------------------------------------------
595 
596  base1 = base1 | T_COSSIN_C ;
597  base2 = base2 | T_COSSIN_S ;
598  base3 = base3 | T_COSSIN_S ;
599 
600  // Base en r :
601  //------------
602  switch ( type_r0 ) {
603 
604  case FIN :
605 // echantillonnage fin
606 
607  base1 = base1 | R_CHEB ;
608  base2 = base2 | R_CHEB ;
609  base3 = base3 | R_CHEB ;
610  break ;
611 
612  case RARE :
613 // echantillonnage rarefie
614 
615  base1 = base1 | R_CHEBPI_I ;
616  base2 = base2 | R_CHEBPI_I ;
617  base3 = base3 | R_CHEBPI_P ;
618 
619  break ;
620 
621  case UNSURR :
622 // echantillonnage fin (1/r)
623 
624  base1 = base1 | R_CHEBU ;
625  base2 = base2 | R_CHEBU ;
626  base3 = base3 | R_CHEBU ;
627  break ;
628 
629 
630  default :
631  cout <<
632  "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = "
633  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
634  cout << " dans la zone l = " << l << " n'est pas prevu ! "
635  << endl ;
636  abort () ;
637  }
638 
639  break ; // fin du cas type_t = SYM
640 
641 
642  default :
643  cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = "
644  << type_p<< " " <<type_t << endl ;
645  cout << " dans la zone l = " << l << " n'est pas prevu ! "
646  << endl ;
647  abort () ;
648 
649  } // fin des cas sur type_t
650 
651  break ; // fin du cas sans symetrie pour phi
652 
653 
654  case SYM :
655 //---------------------------------------------------------
656 // Cas symetrie phi -> phi + pi : phi in [0, pi]
657 //---------------------------------------------------------
658 
659  // Base en phi:
660  //-------------
661  base1 = P_COSSIN_P ;
662  base2 = P_COSSIN_P ;
663  base3 = P_COSSIN_P ;
664 
665 
666  // Base en theta:
667  //---------------
668  switch ( type_t ) {
669 
670  case SYM :
671 // symetrie theta -> pi - theta : theta dans [0, pi/2]
672 //------------------------------------------------------
673  base1 = base1 | T_COS_P ;
674  base2 = base2 | T_SIN_P ;
675  base3 = base3 | T_SIN_I;
676 
677  // Base en r :
678  //------------
679  switch ( type_r0 ) {
680 
681  case FIN :
682 // echantillonnage fin
683 
684  base1 = base1 | R_CHEB ;
685  base2 = base2 | R_CHEB ;
686  base3 = base3 | R_CHEB ;
687  break ;
688 
689  case RARE :
690 // echantillonnage rarefie
691 
692  base1 = base1 | R_CHEBI ;
693  base2 = base2 | R_CHEBI ;
694  base3 = base3 | R_CHEBI ;
695  break ;
696 
697  case UNSURR :
698 // echantillonnage fin (1/r)
699 
700  base1 = base1 | R_CHEBU ;
701  base2 = base2 | R_CHEBU ;
702  base3 = base3 | R_CHEBU ;
703  break ;
704 
705 
706  default :
707  cout <<
708  "Mg3d::std_base_vect_spher : le cas type_p, type_t, type_r = "
709  << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
710  cout << " dans la zone l = " << l << " n'est pas prevu ! "
711  << endl ;
712  abort () ;
713  }
714 
715  break ; // fin du cas type_t = SYM
716 
717  case NONSYM :
718 // pas de symetrie en theta : theta dans [0, pi]
719 //------------------------------------------------
720 
721  base1 = base1 | T_COS ;
722  base2 = base2 | T_SIN ;
723  base3 = base3 | T_SIN ;
724 
725  // Base en r :
726  //------------
727  switch ( type_r0 ) {
728 
729  case FIN :
730 // echantillonnage fin
731 
732  base1 = base1 | R_CHEB ;
733  base2 = base2 | R_CHEB ;
734  base3 = base3 | R_CHEB ;
735  break ;
736 
737  case RARE :
738 // echantillonnage rarefie
739 
740  base1 = base1 | R_CHEBPI_I ;
741  base2 = base2 | R_CHEBPI_I ;
742  base3 = base3 | R_CHEBPI_P ;
743 
744  break ;
745 
746  case UNSURR :
747 // echantillonnage fin (1/r)
748 
749  base1 = base1 | R_CHEBU ;
750  base2 = base2 | R_CHEBU ;
751  base3 = base3 | R_CHEBU ;
752  break ;
753 
754  default :
755  cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = "
756  << type_p<< " " <<type_t << endl ;
757  cout << " dans la zone l = " << l << " n'est pas prevu ! "
758  << endl ;
759  abort () ;
760  }
761  } // fin des cas sur type_t
762 
763  break ; // fin du cas symetrie phi -> phi + pi
764 
765  default :
766  cout <<
767  "Mg3d::std_base_vect_spher : le cas type_p = " << type_p << endl ;
768  cout << " dans la zone l = " << l << " n'est pas prevu ! "
769  << endl ;
770  abort () ;
771 
772 
773  } // Fin des cas en phi
774 
775  bases[0]->b[l] = base1 ;
776  bases[1]->b[l] = base2 ;
777  bases[2]->b[l] = base3 ;
778  } //fin de la boucle sur les zones.
779 
780  return bases ;
781 }
782 
783 
784  //---------------------------------------//
785  // Bases for the Cartesian components //
786  // of a pseudo vector field //
787  //---------------------------------------//
788 
789 
790 /*
791  * Calcul les bases spectrales associees aux composantes cartesiennes d'un pseudo vecteur
792  * symetrique en z (pour la composante z)
793  *
794  * (*THIS) est la grille du calcul
795  * SORTIE : un tableau sur les 3 compsantes (x=1, y=2, z=3) contenant les bases
796  * de decomposition
797  *
798  */
799 
800 Base_val** Mg3d::pseudo_base_vect_cart() const {
801 
802  // nbre de zones :
803  int nz = get_nzone() ;
804 
805  // Tableau contenant le resultat...
806  Base_val** bases = new Base_val*[3] ;
807  for (int i=0 ; i<3 ; i++)
808  bases[i] = new Base_val(nz) ;
809 
810  // Boucle sur les differentes zones :
811  for (int l=0; l<nzone; l++) {
812 
813  assert (colloc_r[l] == BASE_CHEB) ;
814 
815  // Type d'echantillonnage de la zone l :
816  int type_r0 = get_type_r(l) ;
817 
818  // Bases de developpement en (r,theta,phi) a determiner pour les composantes
819  // (1,2,3) du vecteur :
820 
821  int base1, base2, base3 ;
822  switch ( type_p ) {
823 
824  case NONSYM :
825 //---------------------------------------------------------
826 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
827 //---------------------------------------------------------
828 
829 // Base en phi:
830 //-------------
831  base1 = P_COSSIN ;
832  base2 = P_COSSIN ;
833  base3 = P_COSSIN ;
834 
835 
836 // Base en theta:
837 //---------------
838  switch ( type_t ) {
839  case SYM :
840 // symetrie theta -> pi - theta : theta dans [0, pi/2]
841 //------------------------------------------------------
842  base1 = base1 | T_COSSIN_CI ;
843  base2 = base2 | T_COSSIN_CI ;
844  base3 = base3 | T_COSSIN_CP ;
845 
846 // Base en r :
847 //------------
848  switch ( type_r0 ) {
849 
850  case FIN :
851 // echantillonnage fin
852 
853  base1 = base1 | R_CHEB ;
854  base2 = base2 | R_CHEB ;
855  base3 = base3 | R_CHEB ;
856  break ;
857 
858  case RARE :
859 // echantillonnage rarefie
860 
861  base1 = base1 | R_CHEBPIM_I ;
862  base2 = base2 | R_CHEBPIM_I ;
863  base3 = base3 | R_CHEBPIM_P ;
864 
865  break ;
866 
867  case UNSURR :
868 // echantillonnage fin (1/r)
869 
870  base1 = base1 | R_CHEBU ;
871  base2 = base2 | R_CHEBU ;
872  base3 = base3 | R_CHEBU ;
873  break ;
874 
875 
876  default :
877  cout <<
878  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
879  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
880  cout <<
881  " dans la zone l = " << l << " n'est pas prevu ! "
882  << endl ;
883  abort () ;
884  }
885 
886  break ; // fin du cas type_t = SYM
887 
888 
889  case NONSYM :
890 // pas de symetrie en theta : theta dans [0, pi]
891 //------------------------------------------------
892  base1 = base1 | T_COSSIN_C ;
893  base2 = base2 | T_COSSIN_C ;
894  base3 = base3 | T_COSSIN_C ;
895 
896 // Base en r :
897 //------------
898  switch ( type_r0 ) {
899 
900  case FIN :
901 // echantillonnage fin
902 
903  base1 = base1 | R_CHEB ;
904  base2 = base2 | R_CHEB ;
905  base3 = base3 | R_CHEB ;
906  break ;
907 
908  case RARE :
909 // echantillonnage rarefie
910 
911  base1 = base1 | R_CHEBPI_P ;
912  base2 = base2 | R_CHEBPI_P ;
913  base3 = base3 | R_CHEBPI_P ;
914 
915  break ;
916 
917  case UNSURR :
918 // echantillonnage fin (1/r)
919 
920  base1 = base1 | R_CHEBU ;
921  base2 = base2 | R_CHEBU ;
922  base3 = base3 | R_CHEBU ;
923  break ;
924 
925 
926  default :
927  cout <<
928  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
929  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
930  cout <<
931  " dans la zone l = " << l << " n'est pas prevu ! "
932  << endl ;
933  abort () ;
934  }
935 
936  break ; // fin du cas type_t = NONSYM
937 
938 
939 
940 
941  default :
942  cout <<
943  "Mg3d::std_base_vect_cart : le cas type_p, type_t = "
944  << type_p<< " " <<type_t << endl ;
945  cout <<
946  " dans la zone l = " << l << " n'est pas prevu ! "
947  << endl ;
948  abort () ;
949 
950  } // fin des cas sur type_t
951 
952 
953 
954  break ; // fin du cas sans symetrie pour phi
955 
956 
957  case SYM :
958 //---------------------------------------------------------
959 // Cas symetrie phi -> phi + pi : phi in [0, pi]
960 //---------------------------------------------------------
961 
962 // Base en phi:
963 //-------------
964  base1 = P_COSSIN_I ;
965  base2 = P_COSSIN_I ;
966  base3 = P_COSSIN_P ;
967 
968 
969 // Base en theta:
970 //---------------
971  switch ( type_t ) {
972 
973  case SYM :
974 // symetrie theta -> pi - theta : theta dans [0, pi/2]
975 //------------------------------------------------------
976  base1 = base1 | T_SIN_P ;
977  base2 = base2 | T_SIN_P ;
978  base3 = base3 | T_COS_P;
979 
980 // Base en r :
981 //------------
982  switch ( type_r0 ) {
983 
984  case FIN :
985 // echantillonnage fin
986 
987  base1 = base1 | R_CHEB ;
988  base2 = base2 | R_CHEB ;
989  base3 = base3 | R_CHEB ;
990  break ;
991 
992  case RARE :
993 // echantillonnage rarefie
994 
995  base1 = base1 | R_CHEBP ;
996  base2 = base2 | R_CHEBP ;
997  base3 = base3 | R_CHEBP ;
998  break ;
999 
1000  case UNSURR :
1001 // echantillonnage fin (1/r)
1002 
1003  base1 = base1 | R_CHEBU ;
1004  base2 = base2 | R_CHEBU ;
1005  base3 = base3 | R_CHEBU ;
1006  break ;
1007 
1008 
1009  default :
1010  cout <<
1011  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
1012  << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
1013  cout <<
1014  " dans la zone l = " << l << " n'est pas prevu ! "
1015  << endl ;
1016  abort () ;
1017  }
1018 
1019  break ; // fin du cas type_t = SYM
1020 
1021 
1022  case NONSYM :
1023 // pas de symetrie en theta : theta dans [0, pi]
1024 //------------------------------------------------
1025  base1 = base1 | T_SIN ;
1026  base2 = base2 | T_SIN ;
1027  base3 = base3 | T_COS ;
1028 
1029 // Base en r :
1030 //------------
1031  switch ( type_r0 ) {
1032 
1033  case FIN :
1034 // echantillonnage fin
1035 
1036  base1 = base1 | R_CHEB ;
1037  base2 = base2 | R_CHEB ;
1038  base3 = base3 | R_CHEB ;
1039  break ;
1040 
1041  case RARE :
1042 // echantillonnage rarefie
1043 
1044  base1 = base1 | R_CHEBPI_P ;
1045  base2 = base2 | R_CHEBPI_P ;
1046  base3 = base3 | R_CHEBPI_P ;
1047 
1048  break ;
1049 
1050  case UNSURR :
1051 // echantillonnage fin (1/r)
1052 
1053  base1 = base1 | R_CHEBU ;
1054  base2 = base2 | R_CHEBU ;
1055  base3 = base3 | R_CHEBU ;
1056  break ;
1057 
1058 
1059  default :
1060  cout <<
1061  "Mg3d::std_base_vect_cart : le cas type_p, type_t, type_r = "
1062  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
1063  cout <<
1064  " dans la zone l = " << l << " n'est pas prevu ! "
1065  << endl ;
1066  abort () ;
1067  }
1068 
1069  break ; // fin du cas type_t = NONSYM
1070 
1071  default :
1072  cout <<
1073  "Mg3d::std_base_vect_cart : le cas type_p, type_t = "
1074  << type_p<< " " <<type_t << endl ;
1075  cout <<
1076  " dans la zone l = " << l << " n'est pas prevu ! "
1077  << endl ;
1078  abort () ;
1079 
1080  } // fin des cas sur type_t
1081 
1082 
1083 
1084  break ; // fin du cas symetrie phi -> phi + pi
1085 
1086 
1087  default :
1088  cout <<
1089  "Mg3d::std_base_vect_cart : le cas type_p = " << type_p << endl ;
1090  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1091  << endl ;
1092  abort () ;
1093 
1094 
1095  } // Fin des cas en phi
1096 
1097  bases[0]->b[l] = base1 ;
1098  bases[1]->b[l] = base2 ;
1099  bases[2]->b[l] = base3 ;
1100  } //fin de la boucle sur les zones.
1101 
1102  return bases ;
1103 }
1104  //---------------------------------------//
1105  // Bases for the spherical components //
1106  // of a pseudo-vector field //
1107  //---------------------------------------//
1108 
1109 
1110 /*
1111  * Calcul les bases spectrales associees aux composantes spheriques d'un
1112  * pseudo-vecteur symetrique en z (pour la composante z)
1113  *
1114  * (*THIS) est la grille du calcul
1115  * SORTIE : un tableau sur les 3 compsantes (r=1, theta=2, phi=3) contenant
1116  * les bases de decomposition
1117  *
1118  */
1119 
1120 Base_val** Mg3d::pseudo_base_vect_spher() const {
1121 
1122  // nbre de zones :
1123  int nz = get_nzone() ;
1124 
1125  // Tableau contenant le resultat...
1126  Base_val** bases = new Base_val*[3] ;
1127  for (int i=0 ; i<3 ; i++)
1128  bases[i] = new Base_val(nz) ;
1129 
1130  // Boucle sur les differentes zones :
1131  for (int l=0; l<nzone; l++) {
1132 
1133  assert (colloc_r[l] == BASE_CHEB) ;
1134 
1135  // Type d'echantillonnage de la zone l :
1136  int type_r0 = get_type_r(l) ;
1137 
1138  // Bases de developpement en (r,theta,phi) a determiner pour les
1139  // composantes (1,2,3) du vecteur :
1140 
1141  int base1, base2, base3 ;
1142  switch ( type_p ) {
1143 
1144  case NONSYM :
1145 //---------------------------------------------------------
1146 // Cas sans symetrie sur phi : phi dans [0, 2 pi[
1147 //---------------------------------------------------------
1148 
1149  // Base en phi:
1150  //-------------
1151  base1 = P_COSSIN ;
1152  base2 = P_COSSIN ;
1153  base3 = P_COSSIN ;
1154 
1155 
1156  // Base en theta:
1157  //---------------
1158  switch ( type_t ) {
1159  case SYM :
1160 // symetrie theta -> pi - theta : theta dans [0, pi/2]
1161 //------------------------------------------------------
1162  base1 = base1 | T_COSSIN_CI ;
1163  base2 = base2 | T_COSSIN_SI ;
1164  base3 = base3 | T_COSSIN_SP ;
1165 
1166  // Base en r :
1167  //------------
1168  switch ( type_r0 ) {
1169 
1170  case FIN :
1171 // echantillonnage fin
1172 
1173  base1 = base1 | R_CHEB ;
1174  base2 = base2 | R_CHEB ;
1175  base3 = base3 | R_CHEB ;
1176  break ;
1177 
1178  case RARE :
1179 // echantillonnage rarefie
1180 
1181  base1 = base1 | R_CHEBPIM_P ;
1182  base2 = base2 | R_CHEBPIM_P ;
1183  base3 = base3 | R_CHEBPIM_P ;
1184 
1185  break ;
1186 
1187  case UNSURR :
1188 // echantillonnage fin (1/r)
1189 
1190  base1 = base1 | R_CHEBU ;
1191  base2 = base2 | R_CHEBU ;
1192  base3 = base3 | R_CHEBU ;
1193  break ;
1194 
1195 
1196  default :
1197  cout <<
1198  "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = "
1199  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
1200  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1201  << endl ;
1202  abort () ;
1203  }
1204 
1205  break ; // fin du cas type_t = SYM
1206 
1207  case NONSYM :
1208 // pas de symetrie en theta : theta dans [0, pi]
1209 //------------------------------------------------
1210 
1211  base1 = base1 | T_COSSIN_C ;
1212  base2 = base2 | T_COSSIN_S ;
1213  base3 = base3 | T_COSSIN_S ;
1214 
1215  // Base en r :
1216  //------------
1217  switch ( type_r0 ) {
1218 
1219  case FIN :
1220 // echantillonnage fin
1221 
1222  base1 = base1 | R_CHEB ;
1223  base2 = base2 | R_CHEB ;
1224  base3 = base3 | R_CHEB ;
1225  break ;
1226 
1227  case RARE :
1228 // echantillonnage rarefie
1229 
1230  base1 = base1 | R_CHEBPI_I ;
1231  base2 = base2 | R_CHEBPI_I ;
1232  base3 = base3 | R_CHEBPI_P ;
1233 
1234  break ;
1235 
1236  case UNSURR :
1237 // echantillonnage fin (1/r)
1238 
1239  base1 = base1 | R_CHEBU ;
1240  base2 = base2 | R_CHEBU ;
1241  base3 = base3 | R_CHEBU ;
1242  break ;
1243 
1244 
1245  default :
1246  cout <<
1247  "Mg3d::std_base_vect_sphere : le cas type_p, type_t, type_r = "
1248  << type_p<< " " << type_t<< " " <<type_r0 << endl ;
1249  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1250  << endl ;
1251  abort () ;
1252  }
1253 
1254  break ; // fin du cas type_t = NONSYM
1255 
1256 
1257  default :
1258  cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = "
1259  << type_p<< " " <<type_t << endl ;
1260  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1261  << endl ;
1262  abort () ;
1263 
1264  } // fin des cas sur type_t
1265 
1266  break ; // fin du cas sans symetrie pour phi
1267 
1268 
1269  case SYM :
1270 //---------------------------------------------------------
1271 // Cas symetrie phi -> phi + pi : phi in [0, pi]
1272 //---------------------------------------------------------
1273 
1274  // Base en phi:
1275  //-------------
1276  base1 = P_COSSIN_P ;
1277  base2 = P_COSSIN_P ;
1278  base3 = P_COSSIN_P ;
1279 
1280 
1281  // Base en theta:
1282  //---------------
1283  switch ( type_t ) {
1284 
1285  case SYM :
1286 // symetrie theta -> pi - theta : theta dans [0, pi/2]
1287 //------------------------------------------------------
1288  base1 = base1 | T_COS_I ;
1289  base2 = base2 | T_SIN_I ;
1290  base3 = base3 | T_SIN_P;
1291 
1292  // Base en r :
1293  //------------
1294  switch ( type_r0 ) {
1295 
1296  case FIN :
1297 // echantillonnage fin
1298 
1299  base1 = base1 | R_CHEB ;
1300  base2 = base2 | R_CHEB ;
1301  base3 = base3 | R_CHEB ;
1302  break ;
1303 
1304  case RARE :
1305 // echantillonnage rarefie
1306 
1307  base1 = base1 | R_CHEBP ;
1308  base2 = base2 | R_CHEBP ;
1309  base3 = base3 | R_CHEBP ;
1310  break ;
1311 
1312  case UNSURR :
1313 // echantillonnage fin (1/r)
1314 
1315  base1 = base1 | R_CHEBU ;
1316  base2 = base2 | R_CHEBU ;
1317  base3 = base3 | R_CHEBU ;
1318  break ;
1319 
1320 
1321  default :
1322  cout <<
1323  "Mg3d::std_base_vect_spher : le cas type_p, type_t, type_r = "
1324  << type_p<< " " <<type_t<< " " <<type_r0 << endl ;
1325  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1326  << endl ;
1327  abort () ;
1328  }
1329 
1330  break ; // fin du cas type_t = SYM
1331 
1332  case NONSYM :
1333 // pas de symetrie en theta : theta dans [0, pi]
1334 //------------------------------------------------
1335 
1336  base1 = base1 | T_COS ;
1337  base2 = base2 | T_SIN ;
1338  base3 = base3 | T_SIN ;
1339 
1340  // Base en r :
1341  //------------
1342  switch ( type_r0 ) {
1343 
1344  case FIN :
1345 // echantillonnage fin
1346 
1347  base1 = base1 | R_CHEB ;
1348  base2 = base2 | R_CHEB ;
1349  base3 = base3 | R_CHEB ;
1350  break ;
1351 
1352  case RARE :
1353 // echantillonnage rarefie
1354 
1355  base1 = base1 | R_CHEBPI_I ;
1356  base2 = base2 | R_CHEBPI_I ;
1357  base3 = base3 | R_CHEBPI_P ;
1358 
1359  break ;
1360 
1361  case UNSURR :
1362 // echantillonnage fin (1/r)
1363 
1364  base1 = base1 | R_CHEBU ;
1365  base2 = base2 | R_CHEBU ;
1366  base3 = base3 | R_CHEBU ;
1367  break ;
1368 
1369  default :
1370  cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = "
1371  << type_p<< " " <<type_t << endl ;
1372  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1373  << endl ;
1374  abort () ;
1375 
1376  } // fin des cas sur type_r
1377 
1378  break ;
1379 
1380  default :
1381  cout << "Mg3d::std_base_vect_spher : le cas type_p, type_t = "
1382  << type_p<< " " <<type_t << endl ;
1383  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1384  << endl ;
1385  abort () ;
1386 
1387  } // fin des cas sur type_t
1388 
1389  break ; // fin du cas symetrie phi -> phi + pi
1390 
1391  default :
1392  cout <<
1393  "Mg3d::std_base_vect_spher : le cas type_p = " << type_p << endl ;
1394  cout << " dans la zone l = " << l << " n'est pas prevu ! "
1395  << endl ;
1396  abort () ;
1397 
1398 
1399  } // Fin des cas en phi
1400 
1401  bases[0]->b[l] = base1 ;
1402  bases[1]->b[l] = base2 ;
1403  bases[2]->b[l] = base3 ;
1404  } //fin de la boucle sur les zones.
1405 
1406  return bases ;
1407 }
1408 
1409 }
Lorene::Mg3d::std_base_vect_cart
Base_val ** std_base_vect_cart() const
Returns the standard spectral bases for the Cartesian components of a vector.
Definition: mg3d_std_base.C:183
P_COSSIN
#define P_COSSIN
dev. standart
Definition: type_parite.h:245
R_CHEBPI_I
#define R_CHEBPI_I
Cheb. pair-impair suivant l impair pour l=0.
Definition: type_parite.h:174
Lorene::Mg3d::type_p
int type_p
Type of sampling in (SYM, NONSYM)
Definition: grilles.h:296
Lorene
Lorene prototypes.
Definition: app_hor.h:67
T_COS
#define T_COS
dev. cos seulement
Definition: type_parite.h:196
T_COSSIN_SP
#define T_COSSIN_SP
sin pair-cos impair alternes, sin pour m=0
Definition: type_parite.h:210
Lorene::Mg3d::type_t
int type_t
Type of sampling in (SYM, NONSYM)
Definition: grilles.h:293
Lorene::Mg3d::pseudo_base_vect_cart
Base_val ** pseudo_base_vect_cart() const
Returns the standard spectral bases for the Cartesian components of a pseudo-vector.
Definition: mg3d_std_base.C:800
T_SIN
#define T_SIN
dev. sin seulement
Definition: type_parite.h:198
Lorene::Mg3d::pseudo_base_vect_spher
Base_val ** pseudo_base_vect_spher() const
Returns the standard spectral bases for the spherical components of a pseudo-vector.
Definition: mg3d_std_base.C:1120
Lorene::Mg3d::std_base_scal_odd
Base_val std_base_scal_odd() const
Returns the standard odd spectral bases for a scalar.
Definition: mg3d_std_base.C:137
T_COS_I
#define T_COS_I
dev. cos seulement, harmoniques impaires
Definition: type_parite.h:204
R_CHEBI
#define R_CHEBI
base de Cheb. impaire (rare) seulement
Definition: type_parite.h:170
R_CHEBP
#define R_CHEBP
base de Cheb. paire (rare) seulement
Definition: type_parite.h:168
T_COS_P
#define T_COS_P
dev. cos seulement, harmoniques paires
Definition: type_parite.h:200
T_COSSIN_C
#define T_COSSIN_C
dev. cos-sin alternes, cos pour m=0
Definition: type_parite.h:192
Lorene::Mg3d::nzone
int nzone
Number of domains (zones)
Definition: grilles.h:281
Lorene::Base_val::b
int * b
Array (size: nzone ) of the spectral basis in each domain.
Definition: base_val.h:334
Lorene::Mg3d::std_base_vect_spher
Base_val ** std_base_vect_spher() const
Returns the standard spectral bases for the spherical components of a vector.
Definition: mg3d_std_base.C:505
T_SIN_P
#define T_SIN_P
dev. sin seulement, harmoniques paires
Definition: type_parite.h:202
Lorene::Mg3d::get_nzone
int get_nzone() const
Returns the number of domains.
Definition: grilles.h:467
T_COSSIN_SI
#define T_COSSIN_SI
sin impair-cos pair alternes, sin pour m=0
Definition: type_parite.h:214
R_CHEBPIM_I
#define R_CHEBPIM_I
Cheb. pair-impair suivant m, impair pour m=0.
Definition: type_parite.h:178
R_CHEBPIM_P
#define R_CHEBPIM_P
Cheb. pair-impair suivant m, pair pour m=0.
Definition: type_parite.h:176
Lorene::Mg3d::type_r
int * type_r
Array (size: nzone) of type of sampling in r ( ) (RARE,FIN, UNSURR)
Definition: grilles.h:290
Lorene::Mg3d::colloc_r
int * colloc_r
Array (size: nzone) of type of collocation points in r ( ) and related decompoisition bases (BASE_CHE...
Definition: grilles.h:302
Lorene::Base_val
Bases of the spectral expansions.
Definition: base_val.h:325
Lorene::Mg3d::std_base_scal
Base_val std_base_scal() const
Returns the standard spectral bases for a scalar.
Definition: mg3d_std_base.C:107
R_CHEBPI_P
#define R_CHEBPI_P
Cheb. pair-impair suivant l pair pour l=0.
Definition: type_parite.h:172
T_COSSIN_CI
#define T_COSSIN_CI
cos impair-sin pair alternes, cos pour m=0
Definition: type_parite.h:212
P_COSSIN_I
#define P_COSSIN_I
dev. sur Phi = 2*phi, freq. impaires
Definition: type_parite.h:249
R_CHEBU
#define R_CHEBU
base de Chebychev ordinaire (fin), dev. en 1/r
Definition: type_parite.h:180
P_COSSIN_P
#define P_COSSIN_P
dev. sur Phi = 2*phi, freq. paires
Definition: type_parite.h:247
Lorene::Mg3d::get_type_r
int get_type_r(int l) const
Returns the type of sampling in the radial direction in domain no.
Definition: grilles.h:493
T_COSSIN_CP
#define T_COSSIN_CP
cos pair-sin impair alternes, cos pour m=0
Definition: type_parite.h:208
T_SIN_I
#define T_SIN_I
dev. sin seulement, harmoniques impaires
Definition: type_parite.h:206
T_COSSIN_S
#define T_COSSIN_S
dev. cos-sin alternes, sin pour m=0
Definition: type_parite.h:194
R_CHEB
#define R_CHEB
base de Chebychev ordinaire (fin)
Definition: type_parite.h:166