LORENE
map_af_fait.C
1 /*
2  * Copyright (c) 1999-2000 Jean-Alain Marck
3  * Copyright (c) 1999-2003 Eric Gourgoulhon
4  *
5  * This file is part of LORENE.
6  *
7  * LORENE is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * LORENE is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with LORENE; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  *
21  */
22 
23 
24 char map_af_fait_C[] = "$Header: /cvsroot/Lorene/C++/Source/Map/map_af_fait.C,v 1.13 2014/10/13 08:53:02 j_novak Exp $" ;
25 
26 /*
27  * $Id: map_af_fait.C,v 1.13 2014/10/13 08:53:02 j_novak Exp $
28  * $Log: map_af_fait.C,v $
29  * Revision 1.13 2014/10/13 08:53:02 j_novak
30  * Lorene classes and functions now belong to the namespace Lorene.
31  *
32  * Revision 1.12 2014/10/06 15:13:12 j_novak
33  * Modified #include directives to use c++ syntax.
34  *
35  * Revision 1.11 2013/06/05 15:10:42 j_novak
36  * Suppression of FINJAC sampling in r. This Jacobi(0,2) base is now
37  * available by setting colloc_r to BASE_JAC02 in the Mg3d constructor.
38  *
39  * Revision 1.10 2012/01/24 14:59:12 j_novak
40  * Removed functions XXX_fait_xi()
41  *
42  * Revision 1.9 2012/01/17 10:33:02 j_penner
43  * added a routine to construct the computational coordinate xi
44  *
45  * Revision 1.8 2008/10/03 09:05:29 j_novak
46  * Improved the treatment of angular mapping in the computation of xsr
47  *
48  * Revision 1.7 2007/12/20 09:11:04 jl_cornou
49  * Correction of an error in op_sxpun about Jacobi(0,2) polynomials
50  *
51  * Revision 1.6 2007/12/14 10:19:30 jl_cornou
52  * *** empty log message ***
53  *
54  * Revision 1.5 2007/12/11 15:28:14 jl_cornou
55  * Jacobi(0,2) polynomials partially implemented
56  *
57  * Revision 1.4 2006/06/09 14:58:48 j_novak
58  * Added a hack in the case of pure angular grid for the Coord xsr in the shells.
59  *
60  * Revision 1.3 2003/10/15 10:34:46 e_gourgoulhon
61  * Added new Coord's: drdt and stdrdp.
62  *
63  * Revision 1.2 2002/10/16 14:36:41 j_novak
64  * Reorganization of #include instructions of standard C++, in order to
65  * use experimental version 3 of gcc.
66  *
67  * Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
68  * LORENE
69  *
70  * Revision 2.6 1999/10/15 09:16:38 eric
71  * Changement prototypes: const.
72  *
73  * Revision 2.5 1999/10/14 14:27:26 eric
74  * const.
75  *
76  * Revision 2.4 1999/09/30 12:56:10 eric
77  * const Grille3d*
78  *
79  * Revision 2.3 1999/04/09 12:59:21 phil
80  * correction de map_af_fait_dxdr
81  *
82  * Revision 2.2 1999/03/04 15:22:53 eric
83  * *** empty log message ***
84  *
85  * Revision 2.1 1999/03/04 13:12:03 eric
86  * Ajout des derivees du changement de variable
87  *
88  * Revision 2.0 1999/02/15 10:42:45 hyc
89  * *** empty log message ***
90  *
91  * Revision 2.1 1999/02/15 09:59:50 hyc
92  * *** empty log message ***
93  *
94  * Revision 2.0 1999/01/15 09:10:39 hyc
95  * *** empty log message ***
96  *
97  *
98  * $Header: /cvsroot/Lorene/C++/Source/Map/map_af_fait.C,v 1.13 2014/10/13 08:53:02 j_novak Exp $
99  *
100  */
101 
102 // Includes
103 #include <cassert>
104 #include <cstdlib>
105 #include <cmath>
106 
107 #include "mtbl.h"
108 #include "map.h"
109 #include "proto.h"
110 
111  //----------------//
112  // Coord. radiale //
113  //----------------//
114 
115 namespace Lorene {
116 Mtbl* map_af_fait_r(const Map* cvi) {
117 
118  // recup du changement de variable
119  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
120  const Mg3d* mg = cv->get_mg() ;
121  int nz = mg->get_nzone() ;
122 
123  // Le resultat
124  Mtbl* mti = new Mtbl(mg) ;
125  mti->set_etat_qcq() ;
126 
127  // Pour le confort
128  double* alpha = cv->alpha ;
129  double* beta = cv->beta ;
130 
131  int i, j, k ;
132  for (int l=0 ; l<nz ; l++) {
133  int ir = mg->get_nr(l);
134  int it = mg->get_nt(l) ;
135  int ip = mg->get_np(l) ;
136  const Grille3d* g = mg->get_grille3d(l) ;
137  Tbl* tb = (mti->t)[l] ;
138  tb->set_etat_qcq() ;
139  double* p_r = tb->t ;
140 
141  switch(mg->get_type_r(l)) {
142  case FIN: case RARE:
143  for (k=0 ; k<ip ; k++) {
144  for (j=0 ; j<it ; j++) {
145  for (i=0 ; i<ir ; i++) {
146  *p_r = alpha[l] * (g->x)[i] + beta[l] ;
147  p_r++ ;
148  } // Fin de boucle sur r
149  } // Fin de boucle sur theta
150  } // Fin de boucle sur phi
151  break ;
152 
153  case UNSURR:
154  for (k=0 ; k<ip ; k++) {
155  for (j=0 ; j<it ; j++) {
156  for (i=0 ; i<ir ; i++) {
157  *p_r = 1./(alpha[l] * (g->x)[i] + beta[l]) ;
158  p_r++ ;
159  } // Fin de boucle sur r
160  } // Fin de boucle sur theta
161  } // Fin de boucle sur phi
162  break ;
163 
164  default:
165  cout << "Map_af_fait_r: unknown type_r !\n" ;
166  abort () ;
167  exit(-1) ;
168 
169  } // Fin du switch
170  } // Fin de boucle sur zone
171 
172  // Termine
173  return mti ;
174 }
175 
176  //--------------//
177  // Coord. Theta //
178  //--------------//
179 
180 Mtbl* map_af_fait_tet(const Map* cvi) {
181 
182  // recup du changement de variable
183  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
184  const Mg3d* mg = cv->get_mg() ;
185  int nz = mg->get_nzone() ;
186 
187  // Le resultat
188  Mtbl* mti = new Mtbl(mg) ;
189  mti->set_etat_qcq() ;
190 
191  int i, j, k ;
192  for (int l=0 ; l<nz ; l++) {
193  int ir = mg->get_nr(l);
194  int it = mg->get_nt(l);
195  int ip = mg->get_np(l);
196  const Grille3d* g = mg->get_grille3d(l) ;
197  Tbl* tb = (mti->t)[l] ;
198  tb->set_etat_qcq() ;
199  double* p_r = tb->t ;
200  for (k=0 ; k<ip ; k++) {
201  for (j=0 ; j<it ; j++) {
202  for (i=0 ; i<ir ; i++) {
203  *p_r = (g->tet)[j] ;
204  p_r++ ;
205  } // Fin de boucle sur r
206  } // Fin de boucle sur theta
207  } // Fin de boucle sur phi
208  } // Fin de boucle sur zone
209 
210  // Termine
211  return mti ;
212 }
213 
214  //------------//
215  // Coord. Phi //
216  //------------//
217 
218 Mtbl* map_af_fait_phi(const Map* cvi) {
219 
220  // recup du changement de variable
221  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
222  const Mg3d* mg = cv->get_mg() ;
223  int nz = mg->get_nzone() ;
224 
225  // Le resultat
226  Mtbl* mti = new Mtbl(mg) ;
227  mti->set_etat_qcq() ;
228 
229  int i, j, k ;
230  for (int l=0 ; l<nz ; l++) {
231  int ir = mg->get_nr(l);
232  int it = mg->get_nt(l);
233  int ip = mg->get_np(l);
234  const Grille3d* g = mg->get_grille3d(l) ;
235  Tbl* tb = (mti->t)[l] ;
236  tb->set_etat_qcq() ;
237  double* p_r = tb->t ;
238  for (k=0 ; k<ip ; k++) {
239  for (j=0 ; j<it ; j++) {
240  for (i=0 ; i<ir ; i++) {
241  *p_r = (g->phi)[k] ;
242  p_r++ ;
243  } // Fin de boucle sur r
244  } // Fin de boucle sur theta
245  } // Fin de boucle sur phi
246  } // Fin de boucle sur zone
247 
248  // Termine
249  return mti ;
250 }
251 
252  //----------//
253  // Coord. X //
254  //----------//
255 
256 Mtbl* map_af_fait_x(const Map* cvi) {
257 
258  // recup de la grille
259  const Mg3d* mg = cvi->get_mg() ;
260 
261  // Le resultat
262  Mtbl* mti = new Mtbl(mg) ;
263 
264  *mti = (cvi->r) * (cvi->sint) * (cvi->cosp) ;
265 
266  // Termine
267  return mti ;
268 }
269 
270  //----------//
271  // Coord. Y //
272  //----------//
273 
274 Mtbl* map_af_fait_y(const Map* cvi) {
275 
276  // recup de la grille
277  const Mg3d* mg = cvi->get_mg() ;
278 
279  // Le resultat
280  Mtbl* mti = new Mtbl(mg) ;
281 
282  *mti = (cvi->r) * (cvi->sint) * (cvi->sinp) ;
283 
284  // Termine
285  return mti ;
286 }
287 
288  //----------//
289  // Coord. Z //
290  //----------//
291 
292 Mtbl* map_af_fait_z(const Map* cvi) {
293 
294  // recup de la grille
295  const Mg3d* mg = cvi->get_mg() ;
296 
297  // Le resultat
298  Mtbl* mti = new Mtbl(mg) ;
299 
300  *mti = (cvi->r) * (cvi->cost) ;
301 
302  // Termine
303  return mti ;
304 }
305 
306  //--------------------//
307  // Coord. X "absolue" //
308  //--------------------//
309 
310 Mtbl* map_af_fait_xa(const Map* cvi) {
311 
312  // recup de la grille
313  const Mg3d* mg = cvi->get_mg() ;
314 
315  // Le resultat
316  Mtbl* mti = new Mtbl(mg) ;
317 
318  double r_phi = cvi->get_rot_phi() ;
319  double t_x = cvi->get_ori_x() ;
320 
321  if ( fabs(r_phi) < 1.e-14 ) {
322  *mti = (cvi->x) + t_x ;
323  }
324  else if ( fabs(r_phi - M_PI) < 1.e-14 ) {
325  *mti = - (cvi->x) + t_x ;
326  }
327  else {
328  Mtbl phi = cvi->phi + r_phi ;
329  *mti = (cvi->r) * (cvi->sint) * cos(phi) + t_x ;
330  }
331 
332  // Termine
333  return mti ;
334 }
335 
336  //--------------------//
337  // Coord. Y "absolue" //
338  //--------------------//
339 
340 Mtbl* map_af_fait_ya(const Map* cvi) {
341 
342  // recup de la grille
343  const Mg3d* mg = cvi->get_mg() ;
344 
345  // Le resultat
346  Mtbl* mti = new Mtbl(mg) ;
347 
348  double r_phi = cvi->get_rot_phi() ;
349  double t_y = cvi->get_ori_y() ;
350 
351  if ( fabs(r_phi) < 1.e-14 ) {
352  *mti = (cvi->y) + t_y ;
353  }
354  else if ( fabs(r_phi - M_PI) < 1.e-14 ) {
355  *mti = - (cvi->y) + t_y ;
356  }
357  else {
358  Mtbl phi = cvi->phi + r_phi ;
359  *mti = (cvi->r) * (cvi->sint) * sin(phi) + t_y ;
360  }
361 
362  // Termine
363  return mti ;
364 }
365 
366  //--------------------//
367  // Coord. Z "absolue" //
368  //--------------------//
369 
370 Mtbl* map_af_fait_za(const Map* cvi) {
371 
372  // recup de la grille
373  const Mg3d* mg = cvi->get_mg() ;
374 
375  double t_z = cvi->get_ori_z() ;
376 
377  // Le resultat
378  Mtbl* mti = new Mtbl(mg) ;
379 
380  *mti = (cvi->r) * (cvi->cost) + t_z ;
381 
382  // Termine
383  return mti ;
384 }
385 
386  //---------------//
387  // Trigonometrie //
388  //---------------//
389 
390 Mtbl* map_af_fait_sint(const Map* cvi) {
391 
392  // recup du changement de variable
393  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
394  const Mg3d* mg = cv->get_mg() ;
395  int nz = mg->get_nzone() ;
396 
397  // Le resultat
398  Mtbl* mti = new Mtbl(mg) ;
399  mti->set_etat_qcq() ;
400 
401  int i, j, k ;
402  for (int l=0 ; l<nz ; l++) {
403  int ir = mg->get_nr(l);
404  int it = mg->get_nt(l);
405  int ip = mg->get_np(l);
406  const Grille3d* g = mg->get_grille3d(l) ;
407  Tbl* tb = (mti->t)[l] ;
408  tb->set_etat_qcq() ;
409  double* p_r = tb->t ;
410  for (k=0 ; k<ip ; k++) {
411  for (j=0 ; j<it ; j++) {
412  for (i=0 ; i<ir ; i++) {
413  *p_r = sin(g->tet[j]) ;
414  p_r++ ;
415  } // Fin de boucle sur r
416  } // Fin de boucle sur theta
417  } // Fin de boucle sur phi
418  } // Fin de boucle sur zone
419 
420  // Termine
421  return mti ;
422 }
423 
424 Mtbl* map_af_fait_cost(const Map* cvi) {
425 
426  // recup du changement de variable
427  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
428  const Mg3d* mg = cv->get_mg() ;
429  int nz = mg->get_nzone() ;
430 
431  // Le resultat
432  Mtbl* mti = new Mtbl(mg) ;
433  mti->set_etat_qcq() ;
434 
435  int i, j, k ;
436  for (int l=0 ; l<nz ; l++) {
437  int ir = mg->get_nr(l);
438  int it = mg->get_nt(l);
439  int ip = mg->get_np(l);
440  const Grille3d* g = mg->get_grille3d(l) ;
441  Tbl* tb = (mti->t)[l] ;
442  tb->set_etat_qcq() ;
443  double* p_r = tb->t ;
444  for (k=0 ; k<ip ; k++) {
445  for (j=0 ; j<it ; j++) {
446  for (i=0 ; i<ir ; i++) {
447  *p_r = cos(g->tet[j]) ;
448  p_r++ ;
449  } // Fin de boucle sur r
450  } // Fin de boucle sur theta
451  } // Fin de boucle sur phi
452  } // Fin de boucle sur zone
453 
454  // Termine
455  return mti ;
456 }
457 
458 Mtbl* map_af_fait_sinp(const Map* cvi) {
459 
460  // recup du changement de variable
461  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
462  const Mg3d* mg = cv->get_mg() ;
463  int nz = mg->get_nzone() ;
464 
465  // Le resultat
466  Mtbl* mti = new Mtbl(mg) ;
467  mti->set_etat_qcq() ;
468 
469  int i, j, k ;
470  for (int l=0 ; l<nz ; l++) {
471  int ir = mg->get_nr(l);
472  int it = mg->get_nt(l);
473  int ip = mg->get_np(l);
474  const Grille3d* g = mg->get_grille3d(l) ;
475  Tbl* tb = (mti->t)[l] ;
476  tb->set_etat_qcq() ;
477  double* p_r = tb->t ;
478  for (k=0 ; k<ip ; k++) {
479  for (j=0 ; j<it ; j++) {
480  for (i=0 ; i<ir ; i++) {
481  *p_r = sin(g->phi[k]) ;
482  p_r++ ;
483  } // Fin de boucle sur r
484  } // Fin de boucle sur theta
485  } // Fin de boucle sur phi
486  } // Fin de boucle sur zone
487 
488  // Termine
489  return mti ;
490 }
491 
492 Mtbl* map_af_fait_cosp(const Map* cvi) {
493 
494  // recup du changement de variable
495  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
496  const Mg3d* mg = cv->get_mg() ;
497  int nz = mg->get_nzone() ;
498 
499  // Le resultat
500  Mtbl* mti = new Mtbl(mg) ;
501  mti->set_etat_qcq() ;
502 
503  int i, j, k ;
504  for (int l=0 ; l<nz ; l++) {
505  int ir = mg->get_nr(l);
506  int it = mg->get_nt(l);
507  int ip = mg->get_np(l);
508  const Grille3d* g = mg->get_grille3d(l) ;
509  Tbl* tb = (mti->t)[l] ;
510  tb->set_etat_qcq() ;
511  double* p_r = tb->t ;
512  for (k=0 ; k<ip ; k++) {
513  for (j=0 ; j<it ; j++) {
514  for (i=0 ; i<ir ; i++) {
515  *p_r = cos(g->phi[k]) ;
516  p_r++ ;
517  } // Fin de boucle sur r
518  } // Fin de boucle sur theta
519  } // Fin de boucle sur phi
520  } // Fin de boucle sur zone
521 
522  // Termine
523  return mti ;
524 }
525 
526 /*
527  ************************************************************************
528  * x/R dans le noyau, 1/R dans les coquilles, (x-1)/U dans la ZEC
529  ************************************************************************
530  */
531 
532 Mtbl* map_af_fait_xsr(const Map* cvi) {
533 
534  // recup du changement de variable
535  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
536  const Mg3d* mg = cv->get_mg() ;
537  int nz = mg->get_nzone() ;
538 
539  // Le resultat
540  Mtbl* mti = new Mtbl(mg) ;
541  mti->set_etat_qcq() ;
542 
543  // Pour le confort
544  double* alpha = cv->alpha ;
545  double* beta = cv->beta ;
546 
547  int i, j, k ;
548  for (int l=0 ; l<nz ; l++) {
549  int ir = mg->get_nr(l);
550  int it = mg->get_nt(l) ;
551  int ip = mg->get_np(l) ;
552  const Grille3d* g = mg->get_grille3d(l) ;
553  Tbl* tb = (mti->t)[l] ;
554  tb->set_etat_qcq() ;
555  double* p_r = tb->t ;
556 
557  switch(mg->get_type_r(l)) {
558 
559  case RARE:
560  assert(beta[l]==0) ;
561  for (k=0 ; k<ip ; k++) {
562  for (j=0 ; j<it ; j++) {
563  for (i=0 ; i<ir ; i++) {
564  *p_r = 1. / alpha[l] ;
565  p_r++ ;
566  } // Fin de boucle sur r
567  } // Fin de boucle sur theta
568  } // Fin de boucle sur phi
569  break ;
570 
571  case FIN:
572  for (k=0 ; k<ip ; k++) {
573  for (j=0 ; j<it ; j++) {
574  if (ir == 1) { //Some hack for angular grid case...
575  *p_r = 1. / beta[l] ;
576  p_r++ ;
577  }
578  else
579  for (i=0 ; i<ir ; i++) {
580  *p_r = 1. / ( alpha[l] * (g->x)[i] + beta[l] ) ;
581  p_r++ ;
582  } // Fin de boucle sur r
583  } // Fin de boucle sur theta
584  } // Fin de boucle sur phi
585  break ;
586 
587  case UNSURR:
588  assert(beta[l] == - alpha[l]) ;
589  for (k=0 ; k<ip ; k++) {
590  for (j=0 ; j<it ; j++) {
591  for (i=0 ; i<ir ; i++) {
592  *p_r = 1. / alpha[l] ;
593  p_r++ ;
594  } // Fin de boucle sur r
595  } // Fin de boucle sur theta
596  } // Fin de boucle sur phi
597  break ;
598 
599  default:
600  cout << "map_af_fait_xsr: unknown type_r !" << endl ;
601  abort() ;
602 
603  } // Fin du switch
604  } // Fin de boucle sur zone
605 
606  // Termine
607  return mti ;
608 
609 }
610 
611 /*
612  ************************************************************************
613  * 1/(dR/dx) ( -1/(dU/dx) ds la ZEC )
614  ************************************************************************
615  */
616 
617 Mtbl* map_af_fait_dxdr(const Map* cvi) {
618 
619  // recup du changement de variable
620  const Map_af* cv = static_cast<const Map_af*>(cvi) ;
621  const Mg3d* mg = cv->get_mg() ;
622  int nz = mg->get_nzone() ;
623 
624  // Le resultat
625  Mtbl* mti = new Mtbl(mg) ;
626  mti->set_etat_qcq() ;
627 
628  // Pour le confort
629  double* alpha = cv->alpha ;
630 
631  int i, j, k ;
632  for (int l=0 ; l<nz ; l++) {
633  int ir = mg->get_nr(l);
634  int it = mg->get_nt(l) ;
635  int ip = mg->get_np(l) ;
636  Tbl* tb = (mti->t)[l] ;
637  tb->set_etat_qcq() ;
638  double* p_r = tb->t ;
639 
640  switch(mg->get_type_r(l)) {
641 
642  case FIN: case RARE:
643  for (k=0 ; k<ip ; k++) {
644  for (j=0 ; j<it ; j++) {
645  for (i=0 ; i<ir ; i++) {
646  *p_r = 1. / alpha[l] ;
647  p_r++ ;
648  } // Fin de boucle sur r
649  } // Fin de boucle sur theta
650  } // Fin de boucle sur phi
651  break ;
652 
653  case UNSURR:
654  for (k=0 ; k<ip ; k++) {
655  for (j=0 ; j<it ; j++) {
656  for (i=0 ; i<ir ; i++) {
657  *p_r = - 1. / alpha[l] ;
658  p_r++ ;
659  } // Fin de boucle sur r
660  } // Fin de boucle sur theta
661  } // Fin de boucle sur phi
662  break ;
663 
664 
665  default:
666  cout << "map_af_fait_dxdr: unknown type_r !" << endl ;
667  abort() ;
668  } // Fin du switch
669  } // Fin de boucle sur zone
670 
671  // Termine
672  return mti ;
673 }
674 
675 /*
676  ************************************************************************
677  * dR/dtheta
678  ************************************************************************
679  */
680 
681 Mtbl* map_af_fait_drdt(const Map* cvi) {
682 
683  // recup de la grille
684  const Mg3d* mg = cvi->get_mg() ;
685 
686  // Le resultat est nul :
687  Mtbl* mti = new Mtbl(mg) ;
688  mti->set_etat_zero() ;
689 
690  return mti ;
691 }
692 
693 /*
694  ************************************************************************
695  * 1/sin(theta) dR/dphi
696  ************************************************************************
697  */
698 
699 Mtbl* map_af_fait_stdrdp(const Map* cvi) {
700 
701  // recup de la grille
702  const Mg3d* mg = cvi->get_mg() ;
703 
704  // Le resultat est nul :
705  Mtbl* mti = new Mtbl(mg) ;
706  mti->set_etat_zero() ;
707 
708  return mti ;
709 }
710 
711 /*
712  ************************************************************************
713  * 1/R dR/dtheta
714  ************************************************************************
715  */
716 
717 Mtbl* map_af_fait_srdrdt(const Map* cvi) {
718 
719  // recup de la grille
720  const Mg3d* mg = cvi->get_mg() ;
721 
722  // Le resultat est nul :
723  Mtbl* mti = new Mtbl(mg) ;
724  mti->set_etat_zero() ;
725 
726  return mti ;
727 }
728 
729 /*
730  ************************************************************************
731  * 1/(R sin(theta)) dR/dphi
732  ************************************************************************
733  */
734 
735 Mtbl* map_af_fait_srstdrdp(const Map* cvi) {
736 
737  // recup de la grille
738  const Mg3d* mg = cvi->get_mg() ;
739 
740  // Le resultat est nul :
741  Mtbl* mti = new Mtbl(mg) ;
742  mti->set_etat_zero() ;
743 
744  return mti ;
745 }
746 
747 /*
748  ************************************************************************
749  * 1/R^2 dR/dtheta
750  ************************************************************************
751  */
752 
753 Mtbl* map_af_fait_sr2drdt(const Map* cvi) {
754 
755  // recup de la grille
756  const Mg3d* mg = cvi->get_mg() ;
757 
758  // Le resultat est nul :
759  Mtbl* mti = new Mtbl(mg) ;
760  mti->set_etat_zero() ;
761 
762  return mti ;
763 }
764 
765 /*
766  ************************************************************************
767  * 1/(R^2 sin(theta)) dR/dphi
768  ************************************************************************
769  */
770 
771 Mtbl* map_af_fait_sr2stdrdp(const Map* cvi) {
772 
773  // recup de la grille
774  const Mg3d* mg = cvi->get_mg() ;
775 
776  // Le resultat est nul :
777  Mtbl* mti = new Mtbl(mg) ;
778  mti->set_etat_zero() ;
779 
780  return mti ;
781 }
782 
783 /*
784  ************************************************************************
785  * d^2R/dx^2
786  ************************************************************************
787  */
788 
789 Mtbl* map_af_fait_d2rdx2(const Map* cvi) {
790 
791  // recup de la grille
792  const Mg3d* mg = cvi->get_mg() ;
793 
794  // Le resultat est nul :
795  Mtbl* mti = new Mtbl(mg) ;
796  mti->set_etat_zero() ;
797 
798  return mti ;
799 }
800 
801 /*
802  *****************************************************************************
803  * 1/R^2 ( 1/sin(th) d/dth( sin(th) dR/dth ) + 1/sin(th)^2 d^2R/dphi^2 )
804  *****************************************************************************
805  */
806 
807 Mtbl* map_af_fait_lapr_tp(const Map* cvi) {
808 
809  // recup de la grille
810  const Mg3d* mg = cvi->get_mg() ;
811 
812  // Le resultat est nul :
813  Mtbl* mti = new Mtbl(mg) ;
814  mti->set_etat_zero() ;
815 
816  return mti ;
817 }
818 
819 /*
820  ************************************************************************
821  * d^2R/dthdx
822  ************************************************************************
823  */
824 
825 Mtbl* map_af_fait_d2rdtdx(const Map* cvi) {
826 
827  // recup de la grille
828  const Mg3d* mg = cvi->get_mg() ;
829 
830  // Le resultat est nul :
831  Mtbl* mti = new Mtbl(mg) ;
832  mti->set_etat_zero() ;
833 
834  return mti ;
835 }
836 
837 /*
838  ************************************************************************
839  * 1/sin(th) d^2R/dphidx
840  ************************************************************************
841  */
842 
843 Mtbl* map_af_fait_sstd2rdpdx(const Map* cvi) {
844 
845  // recup de la grille
846  const Mg3d* mg = cvi->get_mg() ;
847 
848  // Le resultat est nul :
849  Mtbl* mti = new Mtbl(mg) ;
850  mti->set_etat_zero() ;
851 
852  return mti ;
853 }
854 
855 /*
856  ************************************************************************
857  * d^2R/dtheta^2
858  ************************************************************************
859  */
860 
861 Mtbl* map_af_fait_sr2d2rdt2(const Map* cvi) {
862 
863  // recup de la grille
864  const Mg3d* mg = cvi->get_mg() ;
865 
866  // Le resultat est nul :
867  Mtbl* mti = new Mtbl(mg) ;
868  mti->set_etat_zero() ;
869 
870  return mti ;
871 }
872 
873 }
int get_nzone() const
Returns the number of domains.
Definition: grilles.h:448
const Mg3d * get_mg() const
Gives the Mg3d on which the Mtbl is defined.
Definition: mtbl.h:274
Cmp sin(const Cmp &)
Sine.
Definition: cmp_math.C:69
Cmp cos(const Cmp &)
Cosine.
Definition: cmp_math.C:94
Lorene prototypes.
Definition: app_hor.h:64