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