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 char 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 
56 namespace Lorene {
57 Mtbl* 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 
155 Mtbl* 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 
193 Mtbl* 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 
231 Mtbl* 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 
249 Mtbl* 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 
267 Mtbl* 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 
285 Mtbl* 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 
315 Mtbl* 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 
345 Mtbl* 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 
365 Mtbl* 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 
399 Mtbl* 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 
433 Mtbl* 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 
467 Mtbl* 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 
507 Mtbl* 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 
616 Mtbl* 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 
714 Mtbl* 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 
732 Mtbl* 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 
750 Mtbl* 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 
768 Mtbl* 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 
786 Mtbl* 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 
804 Mtbl* 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 
822 Mtbl* 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 
905 Mtbl* 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 
923 Mtbl* 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 
941 Mtbl* 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 
959 Mtbl* 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 
977 Mtbl* 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::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::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::exp
Cmp exp(const Cmp &)
Exponential.
Definition: cmp_math.C:270
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
Lorene prototypes.
Definition: app_hor.h:64
Lorene::Mtbl
Multi-domain array.
Definition: mtbl.h:118
Lorene::Map::get_mg
const Mg3d * get_mg() const
Gives the Mg3d on which the mapping is defined.
Definition: map.h:765
Lorene::Mtbl::get_mg
const Mg3d * get_mg() const
Gives the Mg3d on which the Mtbl is defined.
Definition: mtbl.h:274
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::Itbl
Basic integer array class.
Definition: itbl.h:122
Lorene::Grille3d::tet
double * tet
Array of values of at the nt collocation points.
Definition: grilles.h:211
Lorene::Tbl::t
double * t
The array of double.
Definition: tbl.h:173
Lorene::Tbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: tbl.C:361
Lorene::Map_log::alpha
Tbl alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition: map.h:3589
Lorene::Tbl
Basic array class.
Definition: tbl.h:161
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_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::cos
Cmp cos(const Cmp &)
Cosine.
Definition: cmp_math.C:94
Lorene::Mtbl::t
Tbl ** t
Array (size nzone ) of pointers on the Tbl 's.
Definition: mtbl.h:132
Lorene::Grille3d::x
double * x
Array of values of at the nr collocation points.
Definition: grilles.h:209
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
Base class for coordinate mappings.
Definition: map.h:670
Lorene::Map_log
Logarithmic radial mapping.
Definition: map.h:3583
Lorene::Mtbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: mtbl.C:299
Lorene::sin
Cmp sin(const Cmp &)
Sine.
Definition: cmp_math.C:69