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
24char 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
115namespace Lorene {
116Mtbl* 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
180Mtbl* 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
218Mtbl* 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
256Mtbl* 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
274Mtbl* 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
292Mtbl* 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
310Mtbl* 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
340Mtbl* 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
370Mtbl* 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
390Mtbl* 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
424Mtbl* 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
458Mtbl* 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
492Mtbl* 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
532Mtbl* 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
617Mtbl* 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
681Mtbl* 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
699Mtbl* 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
717Mtbl* 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
735Mtbl* 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
753Mtbl* 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
771Mtbl* 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
789Mtbl* 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
807Mtbl* 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
825Mtbl* 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
843Mtbl* 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
861Mtbl* 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