LORENE
map_log_fait.C
1/*
2 * Copyright (c) 2004 Philippe Granclement
3 *
4 * This file is part of LORENE.
5 *
6 * LORENE is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * LORENE is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with LORENE; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22
23
24
25/*
26 * $Id: map_log_fait.C,v 1.4 2016/12/05 16:17:58 j_novak Exp $
27 * $Log: map_log_fait.C,v $
28 * Revision 1.4 2016/12/05 16:17:58 j_novak
29 * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
30 *
31 * Revision 1.3 2014/10/13 08:53:05 j_novak
32 * Lorene classes and functions now belong to the namespace Lorene.
33 *
34 * Revision 1.2 2014/10/06 15:13:13 j_novak
35 * Modified #include directives to use c++ syntax.
36 *
37 * Revision 1.1 2004/06/22 08:49:58 p_grandclement
38 * Addition of everything needed for using the logarithmic mapping
39 *
40 *
41 *
42 * $Header: /cvsroot/Lorene/C++/Source/Map/map_log_fait.C,v 1.4 2016/12/05 16:17:58 j_novak Exp $
43 *
44 */
45
46// Includes
47#include <cassert>
48#include <cstdlib>
49#include <cmath>
50
51#include "mtbl.h"
52#include "map.h"
53#include "proto.h"
54
55 //----------------//
56 // Coord. radiale //
57 //----------------//
58
59namespace Lorene {
60Mtbl* map_log_fait_r(const Map* cvi) {
61
62 // recup du changement de variable
63 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
64 const Mg3d* mg = cv->get_mg() ;
65 int nz = mg->get_nzone() ;
66
67 // Le resultat
68 Mtbl* mti = new Mtbl(mg) ;
69 mti->set_etat_qcq() ;
70
71 // Pour le confort
72 Tbl alpha = cv->alpha ;
73 Tbl beta = cv->beta ;
74 Itbl type_var = cv->type_var ;
75
76 int i, j, k ;
77 for (int l=0 ; l<nz ; l++) {
78 int ir = mg->get_nr(l);
79 int it = mg->get_nt(l) ;
80 int ip = mg->get_np(l) ;
81 const Grille3d* g = mg->get_grille3d(l) ;
82 Tbl* tb = (mti->t)[l] ;
83 tb->set_etat_qcq() ;
84 double* p_r = tb->t ;
85
86 switch (type_var(l)) {
87 case AFFINE : {
88
89 switch(mg->get_type_r(l)) {
90 case FIN: case RARE:
91 for (k=0 ; k<ip ; k++) {
92 for (j=0 ; j<it ; j++) {
93 for (i=0 ; i<ir ; i++) {
94 *p_r = alpha(l) * (g->x)[i] + beta(l) ;
95 p_r++ ;
96 } // Fin de boucle sur r
97 } // Fin de boucle sur theta
98 } // Fin de boucle sur phi
99 break ;
100
101 case UNSURR:
102 for (k=0 ; k<ip ; k++) {
103 for (j=0 ; j<it ; j++) {
104 for (i=0 ; i<ir ; i++) {
105 *p_r = 1./(alpha(l) * (g->x)[i] + beta(l)) ;
106 p_r++ ;
107 } // Fin de boucle sur r
108 } // Fin de boucle sur theta
109 } // Fin de boucle sur phi
110 break ;
111
112 default:
113 cout << "Map_log_fait_r: unknown type_r !\n" ;
114 abort () ;
115 exit(-1) ;
116
117 } // Fin du switch 1
118 break ;
119 }
120
121 case LOG : {
122 switch(mg->get_type_r(l)) {
123 case FIN:
124 for (k=0 ; k<ip ; k++) {
125 for (j=0 ; j<it ; j++) {
126 for (i=0 ; i<ir ; i++) {
127 *p_r = exp(alpha(l) * (g->x)[i] + beta(l)) ;
128 p_r++ ;
129 } // Fin de boucle sur r
130 } // Fin de boucle sur theta
131 } // Fin de boucle sur phi
132 break ;
133 default: {
134 cout << "Map_log_fait_r: unknown type_r !\n" ;
135 abort () ;
136 exit(-1) ;
137 }
138 } // Fin du switch 2
139 break ;
140 }
141 default: {
142 cout << "Map_log_fait_r: unknown type_r !\n" ;
143 abort () ;
144 exit(-1) ;
145 }
146 }
147
148 } // Fin de boucle sur zone
149
150 // Termine
151 return mti ;
152}
153
154 //--------------//
155 // Coord. Theta //
156 //--------------//
157
158Mtbl* map_log_fait_tet(const Map* cvi) {
159
160 // recup du changement de variable
161 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
162 const Mg3d* mg = cv->get_mg() ;
163 int nz = mg->get_nzone() ;
164
165 // Le resultat
166 Mtbl* mti = new Mtbl(mg) ;
167 mti->set_etat_qcq() ;
168
169 int i, j, k ;
170 for (int l=0 ; l<nz ; l++) {
171 int ir = mg->get_nr(l);
172 int it = mg->get_nt(l);
173 int ip = mg->get_np(l);
174 const Grille3d* g = mg->get_grille3d(l) ;
175 Tbl* tb = (mti->t)[l] ;
176 tb->set_etat_qcq() ;
177 double* p_r = tb->t ;
178 for (k=0 ; k<ip ; k++) {
179 for (j=0 ; j<it ; j++) {
180 for (i=0 ; i<ir ; i++) {
181 *p_r = (g->tet)[j] ;
182 p_r++ ;
183 } // Fin de boucle sur r
184 } // Fin de boucle sur theta
185 } // Fin de boucle sur phi
186 } // Fin de boucle sur zone
187
188 // Termine
189 return mti ;
190}
191
192 //------------//
193 // Coord. Phi //
194 //------------//
195
196Mtbl* map_log_fait_phi(const Map* cvi) {
197
198 // recup du changement de variable
199 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
200 const Mg3d* mg = cv->get_mg() ;
201 int nz = mg->get_nzone() ;
202
203 // Le resultat
204 Mtbl* mti = new Mtbl(mg) ;
205 mti->set_etat_qcq() ;
206
207 int i, j, k ;
208 for (int l=0 ; l<nz ; l++) {
209 int ir = mg->get_nr(l);
210 int it = mg->get_nt(l);
211 int ip = mg->get_np(l);
212 const Grille3d* g = mg->get_grille3d(l) ;
213 Tbl* tb = (mti->t)[l] ;
214 tb->set_etat_qcq() ;
215 double* p_r = tb->t ;
216 for (k=0 ; k<ip ; k++) {
217 for (j=0 ; j<it ; j++) {
218 for (i=0 ; i<ir ; i++) {
219 *p_r = (g->phi)[k] ;
220 p_r++ ;
221 } // Fin de boucle sur r
222 } // Fin de boucle sur theta
223 } // Fin de boucle sur phi
224 } // Fin de boucle sur zone
225
226 // Termine
227 return mti ;
228}
229
230 //----------//
231 // Coord. X //
232 //----------//
233
234Mtbl* map_log_fait_x(const Map* cvi) {
235
236 // recup de la grille
237 const Mg3d* mg = cvi->get_mg() ;
238
239 // Le resultat
240 Mtbl* mti = new Mtbl(mg) ;
241
242 *mti = (cvi->r) * (cvi->sint) * (cvi->cosp) ;
243
244 // Termine
245 return mti ;
246}
247
248 //----------//
249 // Coord. Y //
250 //----------//
251
252Mtbl* map_log_fait_y(const Map* cvi) {
253
254 // recup de la grille
255 const Mg3d* mg = cvi->get_mg() ;
256
257 // Le resultat
258 Mtbl* mti = new Mtbl(mg) ;
259
260 *mti = (cvi->r) * (cvi->sint) * (cvi->sinp) ;
261
262 // Termine
263 return mti ;
264}
265
266 //----------//
267 // Coord. Z //
268 //----------//
269
270Mtbl* map_log_fait_z(const Map* cvi) {
271
272 // recup de la grille
273 const Mg3d* mg = cvi->get_mg() ;
274
275 // Le resultat
276 Mtbl* mti = new Mtbl(mg) ;
277
278 *mti = (cvi->r) * (cvi->cost) ;
279
280 // Termine
281 return mti ;
282}
283
284 //--------------------//
285 // Coord. X "absolue" //
286 //--------------------//
287
288Mtbl* map_log_fait_xa(const Map* cvi) {
289
290 // recup de la grille
291 const Mg3d* mg = cvi->get_mg() ;
292
293 // Le resultat
294 Mtbl* mti = new Mtbl(mg) ;
295
296 double r_phi = cvi->get_rot_phi() ;
297 double t_x = cvi->get_ori_x() ;
298
299 if ( fabs(r_phi) < 1.e-14 ) {
300 *mti = (cvi->x) + t_x ;
301 }
302 else if ( fabs(r_phi - M_PI) < 1.e-14 ) {
303 *mti = - (cvi->x) + t_x ;
304 }
305 else {
306 Mtbl phi = cvi->phi + r_phi ;
307 *mti = (cvi->r) * (cvi->sint) * cos(phi) + t_x ;
308 }
309
310 // Termine
311 return mti ;
312}
313
314 //--------------------//
315 // Coord. Y "absolue" //
316 //--------------------//
317
318Mtbl* map_log_fait_ya(const Map* cvi) {
319
320 // recup de la grille
321 const Mg3d* mg = cvi->get_mg() ;
322
323 // Le resultat
324 Mtbl* mti = new Mtbl(mg) ;
325
326 double r_phi = cvi->get_rot_phi() ;
327 double t_y = cvi->get_ori_y() ;
328
329 if ( fabs(r_phi) < 1.e-14 ) {
330 *mti = (cvi->y) + t_y ;
331 }
332 else if ( fabs(r_phi - M_PI) < 1.e-14 ) {
333 *mti = - (cvi->y) + t_y ;
334 }
335 else {
336 Mtbl phi = cvi->phi + r_phi ;
337 *mti = (cvi->r) * (cvi->sint) * sin(phi) + t_y ;
338 }
339
340 // Termine
341 return mti ;
342}
343
344 //--------------------//
345 // Coord. Z "absolue" //
346 //--------------------//
347
348Mtbl* map_log_fait_za(const Map* cvi) {
349
350 // recup de la grille
351 const Mg3d* mg = cvi->get_mg() ;
352
353 double t_z = cvi->get_ori_z() ;
354
355 // Le resultat
356 Mtbl* mti = new Mtbl(mg) ;
357
358 *mti = (cvi->r) * (cvi->cost) + t_z ;
359
360 // Termine
361 return mti ;
362}
363
364 //---------------//
365 // Trigonometrie //
366 //---------------//
367
368Mtbl* map_log_fait_sint(const Map* cvi) {
369
370 // recup du changement de variable
371 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
372 const Mg3d* mg = cv->get_mg() ;
373 int nz = mg->get_nzone() ;
374
375 // Le resultat
376 Mtbl* mti = new Mtbl(mg) ;
377 mti->set_etat_qcq() ;
378
379 int i, j, k ;
380 for (int l=0 ; l<nz ; l++) {
381 int ir = mg->get_nr(l);
382 int it = mg->get_nt(l);
383 int ip = mg->get_np(l);
384 const Grille3d* g = mg->get_grille3d(l) ;
385 Tbl* tb = (mti->t)[l] ;
386 tb->set_etat_qcq() ;
387 double* p_r = tb->t ;
388 for (k=0 ; k<ip ; k++) {
389 for (j=0 ; j<it ; j++) {
390 for (i=0 ; i<ir ; i++) {
391 *p_r = sin(g->tet[j]) ;
392 p_r++ ;
393 } // Fin de boucle sur r
394 } // Fin de boucle sur theta
395 } // Fin de boucle sur phi
396 } // Fin de boucle sur zone
397
398 // Termine
399 return mti ;
400}
401
402Mtbl* map_log_fait_cost(const Map* cvi) {
403
404 // recup du changement de variable
405 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
406 const Mg3d* mg = cv->get_mg() ;
407 int nz = mg->get_nzone() ;
408
409 // Le resultat
410 Mtbl* mti = new Mtbl(mg) ;
411 mti->set_etat_qcq() ;
412
413 int i, j, k ;
414 for (int l=0 ; l<nz ; l++) {
415 int ir = mg->get_nr(l);
416 int it = mg->get_nt(l);
417 int ip = mg->get_np(l);
418 const Grille3d* g = mg->get_grille3d(l) ;
419 Tbl* tb = (mti->t)[l] ;
420 tb->set_etat_qcq() ;
421 double* p_r = tb->t ;
422 for (k=0 ; k<ip ; k++) {
423 for (j=0 ; j<it ; j++) {
424 for (i=0 ; i<ir ; i++) {
425 *p_r = cos(g->tet[j]) ;
426 p_r++ ;
427 } // Fin de boucle sur r
428 } // Fin de boucle sur theta
429 } // Fin de boucle sur phi
430 } // Fin de boucle sur zone
431
432 // Termine
433 return mti ;
434}
435
436Mtbl* map_log_fait_sinp(const Map* cvi) {
437
438 // recup du changement de variable
439 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
440 const Mg3d* mg = cv->get_mg() ;
441 int nz = mg->get_nzone() ;
442
443 // Le resultat
444 Mtbl* mti = new Mtbl(mg) ;
445 mti->set_etat_qcq() ;
446
447 int i, j, k ;
448 for (int l=0 ; l<nz ; l++) {
449 int ir = mg->get_nr(l);
450 int it = mg->get_nt(l);
451 int ip = mg->get_np(l);
452 const Grille3d* g = mg->get_grille3d(l) ;
453 Tbl* tb = (mti->t)[l] ;
454 tb->set_etat_qcq() ;
455 double* p_r = tb->t ;
456 for (k=0 ; k<ip ; k++) {
457 for (j=0 ; j<it ; j++) {
458 for (i=0 ; i<ir ; i++) {
459 *p_r = sin(g->phi[k]) ;
460 p_r++ ;
461 } // Fin de boucle sur r
462 } // Fin de boucle sur theta
463 } // Fin de boucle sur phi
464 } // Fin de boucle sur zone
465
466 // Termine
467 return mti ;
468}
469
470Mtbl* map_log_fait_cosp(const Map* cvi) {
471
472 // recup du changement de variable
473 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
474 const Mg3d* mg = cv->get_mg() ;
475 int nz = mg->get_nzone() ;
476
477 // Le resultat
478 Mtbl* mti = new Mtbl(mg) ;
479 mti->set_etat_qcq() ;
480
481 int i, j, k ;
482 for (int l=0 ; l<nz ; l++) {
483 int ir = mg->get_nr(l);
484 int it = mg->get_nt(l);
485 int ip = mg->get_np(l);
486 const Grille3d* g = mg->get_grille3d(l) ;
487 Tbl* tb = (mti->t)[l] ;
488 tb->set_etat_qcq() ;
489 double* p_r = tb->t ;
490 for (k=0 ; k<ip ; k++) {
491 for (j=0 ; j<it ; j++) {
492 for (i=0 ; i<ir ; i++) {
493 *p_r = cos(g->phi[k]) ;
494 p_r++ ;
495 } // Fin de boucle sur r
496 } // Fin de boucle sur theta
497 } // Fin de boucle sur phi
498 } // Fin de boucle sur zone
499
500 // Termine
501 return mti ;
502}
503
504/*
505 ************************************************************************
506 * x/R dans le noyau, 1/R dans les coquilles, (x-1)/U dans la ZEC
507 ************************************************************************
508 */
509
510Mtbl* map_log_fait_xsr(const Map* cvi) {
511
512 // recup du changement de variable
513 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
514 const Mg3d* mg = cv->get_mg() ;
515 int nz = mg->get_nzone() ;
516
517 // Le resultat
518 Mtbl* mti = new Mtbl(mg) ;
519 mti->set_etat_qcq() ;
520
521 // Pour le confort
522 Tbl alpha = cv->alpha ;
523 Tbl beta = cv->beta ;
524 Itbl type_var = cv->type_var ;
525
526 int i, j, k ;
527 for (int l=0 ; l<nz ; l++) {
528 int ir = mg->get_nr(l);
529 int it = mg->get_nt(l) ;
530 int ip = mg->get_np(l) ;
531 const Grille3d* g = mg->get_grille3d(l) ;
532 Tbl* tb = (mti->t)[l] ;
533 tb->set_etat_qcq() ;
534 double* p_r = tb->t ;
535
536 switch (type_var(l)) {
537 case AFFINE : {
538
539 switch(mg->get_type_r(l)) {
540
541 case RARE: {
542 for (k=0 ; k<ip ; k++) {
543 for (j=0 ; j<it ; j++) {
544 for (i=0 ; i<ir ; i++) {
545 *p_r = 1. / alpha(l) ;
546 p_r++ ;
547 } // Fin de boucle sur r
548 } // Fin de boucle sur theta
549 } // Fin de boucle sur phi
550 break ;
551 }
552 case FIN: {
553 for (k=0 ; k<ip ; k++) {
554 for (j=0 ; j<it ; j++) {
555 for (i=0 ; i<ir ; i++) {
556 *p_r = 1. / ( alpha(l) * (g->x)[i] + beta(l) ) ;
557 p_r++ ;
558 } // Fin de boucle sur r
559 } // Fin de boucle sur theta
560 } // Fin de boucle sur phi
561 break ;
562 }
563 case UNSURR: {
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 default: {
575 cout << "map_log_fait_xsr: unknown type_r !" << endl ;
576 abort() ;
577 }
578 } // Fin du switch 1
579 break ;
580 }
581
582 case LOG: {
583 switch (mg->get_type_r(l)) {
584 case FIN: {
585 for (k=0 ; k<ip ; k++) {
586 for (j=0 ; j<it ; j++) {
587 for (i=0 ; i<ir ; i++) {
588 *p_r = 1. / exp( alpha(l) * (g->x)[i] + beta(l) ) ;
589 p_r++ ;
590 } // Fin de boucle sur r
591 } // Fin de boucle sur theta
592 } // Fin de boucle sur phi
593 break ;
594 }
595 default: {
596 cout << "map_log_fait_xsr: unknown type_r !" << endl ;
597 abort() ;
598 }
599 }
600 break ;
601 }
602
603 default:
604 cout << "map_log_fait_xsr: unknown type_r !" << endl ;
605 abort() ;
606 } // Fin de boucle sur zone
607 }
608 // Termine
609 return mti ;
610
611}
612
613/*
614 ************************************************************************
615 * 1/(dR/dx) ( -1/(dU/dx) ds la ZEC )
616 ************************************************************************
617 */
618
619Mtbl* map_log_fait_dxdr(const Map* cvi) {
620
621 // recup du changement de variable
622 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
623 const Mg3d* mg = cv->get_mg() ;
624 int nz = mg->get_nzone() ;
625
626 // Le resultat
627 Mtbl* mti = new Mtbl(mg) ;
628 mti->set_etat_qcq() ;
629
630 // Pour le confort
631 Tbl alpha = cv->alpha ;
632 Tbl beta = cv->beta ;
633 Itbl type_var = cv->type_var ;
634
635 int i, j, k ;
636 for (int l=0 ; l<nz ; l++) {
637 int ir = mg->get_nr(l);
638 int it = mg->get_nt(l) ;
639 int ip = mg->get_np(l) ;
640 const Grille3d* g = mg->get_grille3d(l) ;
641 Tbl* tb = (mti->t)[l] ;
642 tb->set_etat_qcq() ;
643 double* p_r = tb->t ;
644
645 switch (type_var(l)) {
646 case AFFINE : {
647 switch(mg->get_type_r(l)) {
648
649 case RARE: case FIN:
650 for (k=0 ; k<ip ; k++) {
651 for (j=0 ; j<it ; j++) {
652 for (i=0 ; i<ir ; i++) {
653 *p_r = 1. / alpha(l) ;
654 p_r++ ;
655 } // Fin de boucle sur r
656 } // Fin de boucle sur theta
657 } // Fin de boucle sur phi
658 break ;
659
660
661 case UNSURR:
662 for (k=0 ; k<ip ; k++) {
663 for (j=0 ; j<it ; j++) {
664 for (i=0 ; i<ir ; i++) {
665 *p_r = - 1. / alpha(l) ;
666 p_r++ ;
667 } // Fin de boucle sur r
668 } // Fin de boucle sur theta
669 } // Fin de boucle sur phi
670 break ;
671
672 default:
673 cout << "map_log_fait_dxdr: unknown type_r !" << endl ;
674 abort() ;
675
676 } // Fin du switch 1
677 break ;
678 }
679 case LOG : {
680 switch(mg->get_type_r(l)) {
681 case FIN:
682 for (k=0 ; k<ip ; k++) {
683 for (j=0 ; j<it ; j++) {
684 for (i=0 ; i<ir ; i++) {
685 *p_r = 1./ (alpha(l) * exp(alpha(l) * (g->x)[i] + beta(l))) ;
686 p_r++ ;
687 } // Fin de boucle sur r
688 } // Fin de boucle sur theta
689 } // Fin de boucle sur phi
690 break ;
691
692 default:
693 cout << "map_log_fait_dxdr: unknown type_r !" << endl ;
694 abort() ;
695 }
696 break ;
697 }
698
699 default:
700 cout << "map_log_fait_dxdr: unknown type_r !" << endl ;
701 abort() ;
702 } // Fin de boucle sur zone
703 }
704 // Termine
705 return mti ;
706
707}
708
709
710
711/*
712 ************************************************************************
713 * dR/dtheta
714 ************************************************************************
715 */
716
717Mtbl* map_log_fait_drdt(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/sin(theta) dR/dphi
732 ************************************************************************
733 */
734
735Mtbl* map_log_fait_stdrdp(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 dR/dtheta
750 ************************************************************************
751 */
752
753Mtbl* map_log_fait_srdrdt(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 sin(theta)) dR/dphi
768 ************************************************************************
769 */
770
771Mtbl* map_log_fait_srstdrdp(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 * 1/R^2 dR/dtheta
786 ************************************************************************
787 */
788
789Mtbl* map_log_fait_sr2drdt(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 sin(theta)) dR/dphi
804 ************************************************************************
805 */
806
807Mtbl* map_log_fait_sr2stdrdp(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/dx^2
822 ************************************************************************
823 */
824
825Mtbl* map_log_fait_d2rdx2(const Map* cvi) {
826 // recup du changement de variable
827 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
828 const Mg3d* mg = cv->get_mg() ;
829 int nz = mg->get_nzone() ;
830
831 // Le resultat
832 Mtbl* mti = new Mtbl(mg) ;
833 mti->set_etat_qcq() ;
834
835 // Pour le confort
836 Tbl alpha = cv->alpha ;
837 Tbl beta = cv->beta ;
838 Itbl type_var = cv->type_var ;
839
840 int i, j, k ;
841 for (int l=0 ; l<nz ; l++) {
842 int ir = mg->get_nr(l);
843 int it = mg->get_nt(l) ;
844 int ip = mg->get_np(l) ;
845 const Grille3d* g = mg->get_grille3d(l) ;
846 Tbl* tb = (mti->t)[l] ;
847 tb->set_etat_qcq() ;
848 double* p_r = tb->t ;
849
850 switch (type_var(l)) {
851 case AFFINE : {
852 switch(mg->get_type_r(l)) {
853
854 case RARE: case FIN : case UNSURR:
855 for (k=0 ; k<ip ; k++) {
856 for (j=0 ; j<it ; j++) {
857 for (i=0 ; i<ir ; i++) {
858 *p_r = 0. ;
859 p_r++ ;
860 } // Fin de boucle sur r
861 } // Fin de boucle sur theta
862 } // Fin de boucle sur phi
863 break ;
864
865 default:
866 cout << "map_log_fait_d2rdx2: unknown type_r !" << endl ;
867 abort() ;
868
869 } // Fin du switch 1
870 break ;
871 }
872 case LOG : {
873 switch(mg->get_type_r(l)) {
874 case FIN:
875 for (k=0 ; k<ip ; k++) {
876 for (j=0 ; j<it ; j++) {
877 for (i=0 ; i<ir ; i++) {
878 *p_r = exp (alpha(l) * (g->x)[i] + beta(l)) *
879 alpha(l)*alpha(l) ;
880 p_r++ ;
881 } // Fin de boucle sur r
882 } // Fin de boucle sur theta
883 } // Fin de boucle sur phi
884 break ;
885
886 default:
887 cout << "map_log_fait_d2rdx2: unknown type_r !" << endl ;
888 abort() ;
889 }
890 break ;
891 }
892 default:
893 cout << "map_log_fait_d2rdx2: unknown type_r !" << endl ;
894 abort() ;
895 } // Fin de boucle sur zone
896 }
897 // Termine
898 return mti ;
899
900}
901
902/*
903 *****************************************************************************
904 * 1/R^2 ( 1/sin(th) d/dth( sin(th) dR/dth ) + 1/sin(th)^2 d^2R/dphi^2 )
905 *****************************************************************************
906 */
907
908Mtbl* map_log_fait_lapr_tp(const Map* cvi) {
909
910 // recup de la grille
911 const Mg3d* mg = cvi->get_mg() ;
912
913 // Le resultat est nul :
914 Mtbl* mti = new Mtbl(mg) ;
915 mti->set_etat_zero() ;
916
917 return mti ;
918}
919
920/*
921 ************************************************************************
922 * d^2R/dthdx
923 ************************************************************************
924 */
925
926Mtbl* map_log_fait_d2rdtdx(const Map* cvi) {
927
928 // recup de la grille
929 const Mg3d* mg = cvi->get_mg() ;
930
931 // Le resultat est nul :
932 Mtbl* mti = new Mtbl(mg) ;
933 mti->set_etat_zero() ;
934
935 return mti ;
936}
937
938/*
939 ************************************************************************
940 * 1/sin(th) d^2R/dphidx
941 ************************************************************************
942 */
943
944Mtbl* map_log_fait_sstd2rdpdx(const Map* cvi) {
945
946 // recup de la grille
947 const Mg3d* mg = cvi->get_mg() ;
948
949 // Le resultat est nul :
950 Mtbl* mti = new Mtbl(mg) ;
951 mti->set_etat_zero() ;
952
953 return mti ;
954}
955
956/*
957 ************************************************************************
958 * d^2R/dtheta^2
959 ************************************************************************
960 */
961
962Mtbl* map_log_fait_sr2d2rdt2(const Map* cvi) {
963
964 // recup de la grille
965 const Mg3d* mg = cvi->get_mg() ;
966
967 // Le resultat est nul :
968 Mtbl* mti = new Mtbl(mg) ;
969 mti->set_etat_zero() ;
970
971 return mti ;
972}
973
974/*
975 ************************************************************************
976 * 1/(dR/dx) ( -1/(dU/dx) ds la ZEC )
977 ************************************************************************
978 */
979
980Mtbl* map_log_fait_dxdlnr(const Map* cvi) {
981
982 // recup du changement de variable
983 const Map_log* cv = static_cast<const Map_log*>(cvi) ;
984 const Mg3d* mg = cv->get_mg() ;
985 int nz = mg->get_nzone() ;
986
987 // Le resultat
988 Mtbl* mti = new Mtbl(mg) ;
989 mti->set_etat_qcq() ;
990
991 // Pour le confort
992 Tbl alpha = cv->alpha ;
993 Tbl beta = cv->beta ;
994 Itbl type_var = cv->type_var ;
995
996 int i, j, k ;
997 for (int l=0 ; l<nz ; l++) {
998 int ir = mg->get_nr(l);
999 int it = mg->get_nt(l) ;
1000 int ip = mg->get_np(l) ;
1001 Tbl* tb = (mti->t)[l] ;
1002 tb->set_etat_qcq() ;
1003 double* p_r = tb->t ;
1004
1005 switch (type_var(l)) {
1006 case AFFINE : {
1007 switch(mg->get_type_r(l)) {
1008
1009 case RARE: case FIN:
1010 for (k=0 ; k<ip ; k++) {
1011 for (j=0 ; j<it ; j++) {
1012 for (i=0 ; i<ir ; i++) {
1013 *p_r = 1. / alpha(l) ;
1014 p_r++ ;
1015 } // Fin de boucle sur r
1016 } // Fin de boucle sur theta
1017 } // Fin de boucle sur phi
1018 break ;
1019
1020
1021 case UNSURR:
1022 for (k=0 ; k<ip ; k++) {
1023 for (j=0 ; j<it ; j++) {
1024 for (i=0 ; i<ir ; i++) {
1025 *p_r = - 1. / alpha(l) ;
1026 p_r++ ;
1027 } // Fin de boucle sur r
1028 } // Fin de boucle sur theta
1029 } // Fin de boucle sur phi
1030 break ;
1031
1032 default:
1033 cout << "map_log_fait_dxdr: unknown type_r !" << endl ;
1034 abort() ;
1035
1036 } // Fin du switch 1
1037 break ;
1038 }
1039 case LOG : {
1040 switch(mg->get_type_r(l)) {
1041 case FIN:
1042 for (k=0 ; k<ip ; k++) {
1043 for (j=0 ; j<it ; j++) {
1044 for (i=0 ; i<ir ; i++) {
1045 *p_r = 1./ alpha(l) ;
1046 p_r++ ;
1047 } // Fin de boucle sur r
1048 } // Fin de boucle sur theta
1049 } // Fin de boucle sur phi
1050 break ;
1051
1052 default:
1053 cout << "map_log_fait_dxdr: unknown type_r !" << endl ;
1054 abort() ;
1055 }
1056 break ;
1057 }
1058
1059 default:
1060 cout << "map_log_fait_dxdr: unknown type_r !" << endl ;
1061 abort() ;
1062 } // Fin de boucle sur zone
1063 }
1064 // Termine
1065 return mti ;
1066
1067}
1068}
Lorene::Grille3d
3D grid class in one domain.
Definition grilles.h:200
Lorene::Grille3d::x
double * x
Array of values of at the nr collocation points.
Definition grilles.h:215
Lorene::Grille3d::tet
double * tet
Array of values of at the nt collocation points.
Definition grilles.h:217
Lorene::Itbl
Basic integer array class.
Definition itbl.h:122
Lorene::Map_log
Logarithmic radial mapping.
Definition map.h:3603
Lorene::Map_log::type_var
Itbl type_var
Array (size: mg->nzone ) of the type of variable in each domain.
Definition map.h:3615
Lorene::Map_log::alpha
Tbl alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:3609
Lorene::Map_log::Map_log
Map_log(const Mg3d &mgrille, const Tbl &r_limits, const Itbl &typevar)
Standard Constructor.
Definition map_log.C:70
Lorene::Map_log::map_log_fait_r
friend Mtbl * map_log_fait_r(const Map *)
< Not implemented
Definition map_log_fait.C:60
Lorene::Map_log::beta
Tbl beta
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:3611
Lorene::Mg3d
Multi-domain grid.
Definition grilles.h:279
Lorene::Mg3d::get_grille3d
const Grille3d * get_grille3d(int l) const
Returns a pointer on the 3D mono-grid for domain no. l.
Definition grilles.h:517
Lorene::Mg3d::get_np
int get_np(int l) const
Returns the number of points in the azimuthal direction ( ) in domain no. l.
Definition grilles.h:479
Lorene::Mg3d::get_nt
int get_nt(int l) const
Returns the number of points in the co-latitude direction ( ) in domain no. l.
Definition grilles.h:474
Lorene::Mg3d::get_nzone
int get_nzone() const
Returns the number of domains.
Definition grilles.h:465
Lorene::Mg3d::get_nr
int get_nr(int l) const
Returns the number of points in the radial direction ( ) in domain no. l.
Definition grilles.h:469
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:491
Lorene::Mtbl
Multi-domain array.
Definition mtbl.h:118
Lorene::Mtbl::t
Tbl ** t
Array (size nzone ) of pointers on the Tbl 's.
Definition mtbl.h:132
Lorene::Mtbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition mtbl.C:302
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::Tbl::t
double * t
The array of double.
Definition tbl.h:173
Lorene::exp
Cmp exp(const Cmp &)
Exponential.
Definition cmp_math.C:273
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