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 
59 namespace Lorene {
60 Mtbl* 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 
158 Mtbl* 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 
196 Mtbl* 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 
234 Mtbl* 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 
252 Mtbl* 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 
270 Mtbl* 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 
288 Mtbl* 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 
318 Mtbl* 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 
348 Mtbl* 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 
368 Mtbl* 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 
402 Mtbl* 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 
436 Mtbl* 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 
470 Mtbl* 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 
510 Mtbl* 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 
619 Mtbl* 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 
717 Mtbl* 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 
735 Mtbl* 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 
753 Mtbl* 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 
771 Mtbl* 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 
789 Mtbl* 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 
807 Mtbl* 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 
825 Mtbl* 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 
908 Mtbl* 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 
926 Mtbl* 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 
944 Mtbl* 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 
962 Mtbl* 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 
980 Mtbl* 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::Map_log::beta
Tbl beta
Array (size: mg->nzone ) of the values of in each domain.
Definition: map.h:3611
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::exp
Cmp exp(const Cmp &)
Exponential.
Definition: cmp_math.C:273
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::Mtbl
Multi-domain array.
Definition: mtbl.h:118
Lorene
Lorene prototypes.
Definition: app_hor.h:67
Lorene::Map::get_mg
const Mg3d * get_mg() const
Gives the Mg3d on which the mapping is defined.
Definition: map.h:777
Lorene::Map
Base class for coordinate mappings.
Definition: map.h:682
Lorene::Itbl
Basic integer array class.
Definition: itbl.h:122
Lorene::Grille3d::x
double * x
Array of values of at the nr collocation points.
Definition: grilles.h:215
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::cos
Cmp cos(const Cmp &)
Cosine.
Definition: cmp_math.C:97
Lorene::Tbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: tbl.C:364
Lorene::Map_log
Logarithmic radial mapping.
Definition: map.h:3603
Lorene::Tbl::t
double * t
The array of double.
Definition: tbl.h:176
Lorene::Grille3d::tet
double * tet
Array of values of at the nt collocation points.
Definition: grilles.h:217
Lorene::Map_log::alpha
Tbl alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition: map.h:3609
Lorene::Mg3d::get_nzone
int get_nzone() const
Returns the number of domains.
Definition: grilles.h:465
Lorene::Mtbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: mtbl.C:302
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
Multi-domain grid.
Definition: grilles.h:279
Lorene::sin
Cmp sin(const Cmp &)
Sine.
Definition: cmp_math.C:72
Lorene::Tbl
Basic array class.
Definition: tbl.h:164
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_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::t
Tbl ** t
Array (size nzone ) of pointers on the Tbl &#39;s.
Definition: mtbl.h:132
Lorene::Mtbl::get_mg
const Mg3d * get_mg() const
Gives the Mg3d on which the Mtbl is defined.
Definition: mtbl.h:274
Lorene::Grille3d
3D grid class in one domain.
Definition: grilles.h:200