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