LORENE
cmp_import_asymy.C
1 /*
2  * Member function of the Cmp class for initiating a Cmp from a Cmp defined
3  * on another mapping.
4  * Case where both Cmp's are antisymmetric with respect to their y=0 plane.
5  */
6 
7 /*
8  * Copyright (c) 1999-2001 Eric Gourgoulhon
9  *
10  * This file is part of LORENE.
11  *
12  * LORENE is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * LORENE is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with LORENE; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  *
26  */
27 
28 
29 char cmp_import_asymy_C[] = "$Header: /cvsroot/Lorene/C++/Source/Cmp/cmp_import_asymy.C,v 1.3 2014/10/13 08:52:47 j_novak Exp $" ;
30 
31 
32 /*
33  * $Id: cmp_import_asymy.C,v 1.3 2014/10/13 08:52:47 j_novak Exp $
34  * $Log: cmp_import_asymy.C,v $
35  * Revision 1.3 2014/10/13 08:52:47 j_novak
36  * Lorene classes and functions now belong to the namespace Lorene.
37  *
38  * Revision 1.2 2014/10/06 15:13:03 j_novak
39  * Modified #include directives to use c++ syntax.
40  *
41  * Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
42  * LORENE
43  *
44  * Revision 2.0 2000/03/06 10:56:07 eric
45  * *** empty log message ***
46  *
47  *
48  * $Header: /cvsroot/Lorene/C++/Source/Cmp/cmp_import_asymy.C,v 1.3 2014/10/13 08:52:47 j_novak Exp $
49  *
50  */
51 
52 
53 
54 // Headers C
55 #include <cmath>
56 
57 // Headers Lorene
58 #include "cmp.h"
59 #include "param.h"
60 #include "nbr_spx.h"
61 
62  //-------------------------------//
63  // Importation in all domains //
64  //-------------------------------//
65 
66 namespace Lorene {
67 void Cmp::import_asymy(const Cmp& ci) {
68 
69  int nz = mp->get_mg()->get_nzone() ;
70 
71  import_asymy(nz, ci) ;
72 
73 }
74 
75  //--------------------------------------//
76  // Importation in inner domains only //
77  //--------------------------------------//
78 
79 void Cmp::import_asymy(int nzet, const Cmp& cm_d) {
80 
81  const Map* mp_d = cm_d.mp ; // Departure mapping
82 
83  // Trivial case : mappings identical !
84  // -----------------------------------
85 
86  if (mp_d == mp) {
87  *this = cm_d ;
88  return ;
89  }
90 
91  // Relative orientation of the two mappings
92  // ----------------------------------------
93 
94  int align_rel = (mp->get_bvect_cart()).get_align()
95  * (mp_d->get_bvect_cart()).get_align() ;
96 
97  switch (align_rel) {
98 
99  case 1 : { // the two mappings have aligned Cartesian axis
100  import_align_asymy(nzet, cm_d) ;
101  break ;
102  }
103 
104  case -1 : { // the two mappings have anti-aligned Cartesian axis
105  import_anti_asymy(nzet, cm_d) ;
106  break ;
107  }
108 
109  default : {
110  cout << "Cmp::import_asymy : unexpected value of align_rel : "
111  << align_rel << endl ;
112  abort() ;
113  break ;
114  }
115 
116  }
117 
118 }
119 
120 
121  //-----------------------------------------//
122  // Case of Cartesian axis anti-aligned //
123  //-----------------------------------------//
124 
125 
126 void Cmp::import_anti_asymy(int nzet, const Cmp& cm_d) {
127 
128  // Trivial case : null Cmp
129  // ------------------------
130 
131  if (cm_d.etat == ETATZERO) {
132  set_etat_zero() ;
133  return ;
134  }
135 
136  const Map* mp_d = cm_d.mp ; // Departure mapping
137 
138  // Protections
139  // -----------
140  int align = (mp->get_bvect_cart()).get_align() ;
141 
142  assert( align * (mp_d->get_bvect_cart()).get_align() == -1 ) ;
143 
144  assert(cm_d.etat == ETATQCQ) ;
145 
146  if (cm_d.dzpuis != 0) {
147  cout <<
148  "Cmp::import_anti_asymy : the dzpuis of the Cmp to be imported"
149  << " must be zero !" << endl ;
150  abort() ;
151  }
152 
153 
154  const Mg3d* mg_a = mp->get_mg() ;
155  assert(mg_a->get_type_p() == NONSYM) ;
156 
157 
158  int nz_a = mg_a->get_nzone() ;
159  assert(nzet <= nz_a) ;
160 
161  const Valeur& va_d = cm_d.va ;
162  va_d.coef() ; // The coefficients are required
163 
164 
165  // Preparations for storing the result in *this
166  // --------------------------------------------
167  del_t() ; // delete all previously computed derived quantities
168 
169  set_etat_qcq() ; // Set the state to ETATQCQ
170 
171  va.set_etat_c_qcq() ; // Allocates the memory for the Mtbl va.c
172  // if it does not exist already
173  va.c->set_etat_qcq() ; // Allocates the memory for the Tbl's in each
174  // domain if they do not exist already
175 
176 
177  // Departure (x,y,z) coordinates of the origin of the Arrival mapping :
178 
179  double xx_a, yy_a, zz_a ;
180  if (align == 1) {
181  xx_a = mp_d->get_ori_x() - mp->get_ori_x() ;
182  yy_a = mp_d->get_ori_y() - mp->get_ori_y() ;
183  }
184  else {
185  xx_a = mp->get_ori_x() - mp_d->get_ori_x() ;
186  yy_a = mp->get_ori_y() - mp_d->get_ori_y() ;
187  }
188  zz_a = mp->get_ori_z() - mp_d->get_ori_z() ;
189 
190 
191  // r, theta, phi, x, y and z on the Arrival mapping
192  // update of the corresponding Coord's if necessary
193 
194  if ( (mp->r).c == 0x0 ) (mp->r).fait() ;
195  if ( (mp->tet).c == 0x0 ) (mp->tet).fait() ;
196  if ( (mp->phi).c == 0x0 ) (mp->phi).fait() ;
197  if ( (mp->x).c == 0x0 ) (mp->x).fait() ;
198  if ( (mp->y).c == 0x0 ) (mp->y).fait() ;
199  if ( (mp->z).c == 0x0 ) (mp->z).fait() ;
200 
201  const Mtbl* mr_a = (mp->r).c ;
202  const Mtbl* mtet_a = (mp->tet).c ;
203  const Mtbl* mphi_a = (mp->phi).c ;
204  const Mtbl* mx_a = (mp->x).c ;
205  const Mtbl* my_a = (mp->y).c ;
206  const Mtbl* mz_a = (mp->z).c ;
207 
208  Param par_precis ; // Required precision in the method Map::val_lx
209  int nitermax = 100 ; // Maximum number of iteration in the secant method
210  int niter ;
211  double precis = 1e-15 ; // Absolute precision in the secant method
212  par_precis.add_int(nitermax) ;
213  par_precis.add_int_mod(niter) ;
214  par_precis.add_double(precis) ;
215 
216 
217  // Loop of the Arrival domains where the computation is to be performed
218  // --------------------------------------------------------------------
219 
220  for (int l=0; l < nzet; l++) {
221 
222  int nr = mg_a->get_nr(l) ;
223  int nt = mg_a->get_nt(l) ;
224  int np = mg_a->get_np(l) ;
225  int ntnr = nt*nr ;
226 
227  const double* pr_a = mr_a->t[l]->t ; // Pointer on the values of r
228  const double* ptet_a = mtet_a->t[l]->t ; // Pointer on the values of theta
229  const double* pphi_a = mphi_a->t[l]->t ; // Pointer on the values of phi
230  const double* px_a = mx_a->t[l]->t ; // Pointer on the values of X
231  const double* py_a = my_a->t[l]->t ; // Pointer on the values of Y
232  const double* pz_a = mz_a->t[l]->t ; // Pointer on the values of Z
233 
234  (va.c->t[l])->set_etat_qcq() ; // Allocates the array of double to
235  // store the result
236  double* ptx = (va.c->t[l])->t ; // Pointer on the allocated array
237 
238 
239  // Loop on half the grid points in the considered arrival domain
240  // (the other half will be obtained by antisymmetry with respect to
241  // the y=0 plane).
242 
243  // Case k=0 (phi=0) : the function is zero (by antisymmetry)
244  for (int i=0; i<ntnr; i++) {
245  *ptx = 0 ;
246  ptx++ ; // next point
247  }
248 
249  // Go to k=1 :
250  pr_a += ntnr ;
251  ptet_a += ntnr ;
252  pphi_a += ntnr ;
253  px_a += ntnr ;
254  py_a += ntnr ;
255  pz_a += ntnr ;
256 
257  for (int k=1 ; k<np/2 ; k++) { // np/2 : ~ half the grid
258  for (int j=0 ; j<nt ; j++) {
259  for (int i=0 ; i<nr ; i++) {
260 
261  double r = *pr_a ;
262  double rd, tetd, phid ;
263  if (r == __infinity) {
264  rd = r ;
265  tetd = *ptet_a ;
266  phid = *pphi_a + M_PI ;
267  if (phid < 0) phid += 2*M_PI ;
268  }
269  else {
270 
271  // Cartesian coordinates on the Departure mapping
272  double xd = - *px_a + xx_a ;
273  double yd = - *py_a + yy_a ;
274  double zd = *pz_a + zz_a ;
275 
276  // Spherical coordinates on the Departure mapping
277  double rhod2 = xd*xd + yd*yd ;
278  double rhod = sqrt( rhod2 ) ;
279  rd = sqrt(rhod2 + zd*zd) ;
280  tetd = atan2(rhod, zd) ;
281  phid = atan2(yd, xd) ;
282  if (phid < 0) phid += 2*M_PI ;
283  }
284 
285 
286  // NB: to increase the efficiency, the method Cmp::val_point
287  // is not invoked; the method Mtbl_cf::val_point is
288  // called directly instead.
289 
290  // Value of the grid coordinates (l,xi) corresponding to
291  // (rd,tetd,phid) :
292 
293  int ld ; // domain index
294  double xxd ; // radial coordinate xi in [0,1] or [-1,1]
295  mp_d->val_lx(rd, tetd, phid, par_precis, ld, xxd) ;
296 
297  // Value of the Departure Cmp at the obtained point:
298  *ptx = va_d.c_cf->val_point_asymy(ld, xxd, tetd, phid) ;
299 
300  // Next point :
301  ptx++ ;
302  pr_a++ ;
303  ptet_a++ ;
304  pphi_a++ ;
305  px_a++ ;
306  py_a++ ;
307  pz_a++ ;
308 
309  }
310  }
311  }
312 
313  // Case k=np/2 (phi=pi) : the function is zero (by antisymmetry)
314  for (int i=0; i<ntnr; i++) {
315  *ptx = 0 ;
316  ptx++ ; // next point
317  }
318 
319  // Go to k=np/2+1 :
320  pr_a += ntnr ;
321  ptet_a += ntnr ;
322  pphi_a += ntnr ;
323  px_a += ntnr ;
324  py_a += ntnr ;
325  pz_a += ntnr ;
326 
327  // The remaining points are obtained by antisymmetry with rspect to the
328  // y=0 plane
329 
330  for (int k=np/2+1 ; k<np ; k++) {
331 
332  // pointer on the value (already computed) at the point symmetric
333  // with respect to the plane y=0
334  double* ptx_symy = (va.c->t[l])->t + (np-k)*nt*nr ;
335 
336  // copy :
337  for (int j=0 ; j<nt ; j++) {
338  for (int i=0 ; i<nr ; i++) {
339  *ptx = - (*ptx_symy) ;
340  ptx++ ;
341  ptx_symy++ ;
342  }
343  }
344  }
345 
346 
347  } // End of the loop on the Arrival domains
348 
349  // In the remaining domains, *this is set to zero:
350  // ----------------------------------------------
351 
352  if (nzet < nz_a) {
353  annule(nzet, nz_a - 1) ;
354  }
355 
356  // Treatment of dzpuis
357  // -------------------
358 
359  set_dzpuis(0) ;
360 
361 }
362 
363 
364  //-------------------------------------//
365  // Case of aligned Cartesian axis //
366  //-------------------------------------//
367 
368 
369 void Cmp::import_align_asymy(int nzet, const Cmp& cm_d) {
370 
371  // Trivial case : null Cmp
372  // ------------------------
373 
374  if (cm_d.etat == ETATZERO) {
375  set_etat_zero() ;
376  return ;
377  }
378 
379  const Map* mp_d = cm_d.mp ; // Departure mapping
380 
381  // Protections
382  // -----------
383  int align = (mp->get_bvect_cart()).get_align() ;
384 
385  assert( align * (mp_d->get_bvect_cart()).get_align() == 1 ) ;
386 
387  assert(cm_d.etat == ETATQCQ) ;
388 
389  if (cm_d.dzpuis != 0) {
390  cout <<
391  "Cmp::import_align_asymy : the dzpuis of the Cmp to be imported"
392  << " must be zero !" << endl ;
393  abort() ;
394  }
395 
396 
397  const Mg3d* mg_a = mp->get_mg() ;
398  assert(mg_a->get_type_p() == NONSYM) ;
399 
400  int nz_a = mg_a->get_nzone() ;
401  assert(nzet <= nz_a) ;
402 
403  const Valeur& va_d = cm_d.va ;
404  va_d.coef() ; // The coefficients are required
405 
406 
407  // Preparations for storing the result in *this
408  // --------------------------------------------
409  del_t() ; // delete all previously computed derived quantities
410 
411  set_etat_qcq() ; // Set the state to ETATQCQ
412 
413  va.set_etat_c_qcq() ; // Allocates the memory for the Mtbl va.c
414  // if it does not exist already
415  va.c->set_etat_qcq() ; // Allocates the memory for the Tbl's in each
416  // domain if they do not exist already
417 
418 
419  // Departure (x,y,z) coordinates of the origin of the Arrival mapping :
420 
421  double xx_a, yy_a, zz_a ;
422  if (align == 1) {
423  xx_a = mp->get_ori_x() - mp_d->get_ori_x() ;
424  yy_a = mp->get_ori_y() - mp_d->get_ori_y() ;
425  }
426  else {
427  xx_a = mp_d->get_ori_x() - mp->get_ori_x() ;
428  yy_a = mp_d->get_ori_y() - mp->get_ori_y() ;
429  }
430  zz_a = mp->get_ori_z() - mp_d->get_ori_z() ;
431 
432 
433  // r, theta, phi, x, y and z on the Arrival mapping
434  // update of the corresponding Coord's if necessary
435 
436  if ( (mp->r).c == 0x0 ) (mp->r).fait() ;
437  if ( (mp->tet).c == 0x0 ) (mp->tet).fait() ;
438  if ( (mp->phi).c == 0x0 ) (mp->phi).fait() ;
439  if ( (mp->x).c == 0x0 ) (mp->x).fait() ;
440  if ( (mp->y).c == 0x0 ) (mp->y).fait() ;
441  if ( (mp->z).c == 0x0 ) (mp->z).fait() ;
442 
443  const Mtbl* mr_a = (mp->r).c ;
444  const Mtbl* mtet_a = (mp->tet).c ;
445  const Mtbl* mphi_a = (mp->phi).c ;
446  const Mtbl* mx_a = (mp->x).c ;
447  const Mtbl* my_a = (mp->y).c ;
448  const Mtbl* mz_a = (mp->z).c ;
449 
450  Param par_precis ; // Required precision in the method Map::val_lx
451  int nitermax = 100 ; // Maximum number of iteration in the secant method
452  int niter ;
453  double precis = 1e-15 ; // Absolute precision in the secant method
454  par_precis.add_int(nitermax) ;
455  par_precis.add_int_mod(niter) ;
456  par_precis.add_double(precis) ;
457 
458 
459  // Loop of the Arrival domains where the computation is to be performed
460  // --------------------------------------------------------------------
461 
462  for (int l=0; l < nzet; l++) {
463 
464  int nr = mg_a->get_nr(l) ;
465  int nt = mg_a->get_nt(l) ;
466  int np = mg_a->get_np(l) ;
467  int ntnr = nt*nr ;
468 
469  const double* pr_a = mr_a->t[l]->t ; // Pointer on the values of r
470  const double* ptet_a = mtet_a->t[l]->t ; // Pointer on the values of theta
471  const double* pphi_a = mphi_a->t[l]->t ; // Pointer on the values of phi
472  const double* px_a = mx_a->t[l]->t ; // Pointer on the values of X
473  const double* py_a = my_a->t[l]->t ; // Pointer on the values of Y
474  const double* pz_a = mz_a->t[l]->t ; // Pointer on the values of Z
475 
476  (va.c->t[l])->set_etat_qcq() ; // Allocates the array of double to
477  // store the result
478  double* ptx = (va.c->t[l])->t ; // Pointer on the allocated array
479 
480 
481 
482  // Loop on half the grid points in the considered arrival domain
483  // (the other half will be obtained by antisymmetry with respect to
484  // the y=0 plane).
485 
486  // Case k=0 (phi=0) : the function is zero (by antisymmetry)
487  for (int i=0; i<ntnr; i++) {
488  *ptx = 0 ;
489  ptx++ ; // next point
490  }
491 
492  // Go to k=1 :
493  pr_a += ntnr ;
494  ptet_a += ntnr ;
495  pphi_a += ntnr ;
496  px_a += ntnr ;
497  py_a += ntnr ;
498  pz_a += ntnr ;
499 
500  for (int k=1 ; k<np/2 ; k++) { // np/2 : ~ half the grid
501  for (int j=0 ; j<nt ; j++) {
502  for (int i=0 ; i<nr ; i++) {
503 
504  double r = *pr_a ;
505  double rd, tetd, phid ;
506  if (r == __infinity) {
507  rd = r ;
508  tetd = *ptet_a ;
509  phid = *pphi_a ;
510  }
511  else {
512 
513  // Cartesian coordinates on the Departure mapping
514  double xd = *px_a + xx_a ;
515  double yd = *py_a + yy_a ;
516  double zd = *pz_a + zz_a ;
517 
518  // Spherical coordinates on the Departure mapping
519  double rhod2 = xd*xd + yd*yd ;
520  double rhod = sqrt( rhod2 ) ;
521  rd = sqrt(rhod2 + zd*zd) ;
522  tetd = atan2(rhod, zd) ;
523  phid = atan2(yd, xd) ;
524  if (phid < 0) phid += 2*M_PI ;
525  }
526 
527 
528  // NB: to increase the efficiency, the method Cmp::val_point
529  // is not invoked; the method Mtbl_cf::val_point is
530  // called directly instead.
531 
532  // Value of the grid coordinates (l,xi) corresponding to
533  // (rd,tetd,phid) :
534 
535  int ld ; // domain index
536  double xxd ; // radial coordinate xi in [0,1] or [-1,1]
537  mp_d->val_lx(rd, tetd, phid, par_precis, ld, xxd) ;
538 
539  // Value of the Departure Cmp at the obtained point:
540  *ptx = va_d.c_cf->val_point_asymy(ld, xxd, tetd, phid) ;
541 
542  // Next point :
543  ptx++ ;
544  pr_a++ ;
545  ptet_a++ ;
546  pphi_a++ ;
547  px_a++ ;
548  py_a++ ;
549  pz_a++ ;
550 
551  }
552  }
553  }
554 
555 
556  // Case k=np/2 (phi=pi) : the function is zero (by antisymmetry)
557  for (int i=0; i<ntnr; i++) {
558  *ptx = 0 ;
559  ptx++ ; // next point
560  }
561 
562  // Go to k=np/2+1 :
563  pr_a += ntnr ;
564  ptet_a += ntnr ;
565  pphi_a += ntnr ;
566  px_a += ntnr ;
567  py_a += ntnr ;
568  pz_a += ntnr ;
569 
570  // The remaining points are obtained by antisymmetry with respect to the
571  // y=0 plane
572 
573  for (int k=np/2+1 ; k<np ; k++) {
574 
575  // pointer on the value (already computed) at the point symmetric
576  // with respect to the plane y=0
577  double* ptx_symy = (va.c->t[l])->t + (np-k)*nt*nr ;
578 
579  // copy :
580  for (int j=0 ; j<nt ; j++) {
581  for (int i=0 ; i<nr ; i++) {
582  *ptx = - (*ptx_symy) ;
583  ptx++ ;
584  ptx_symy++ ;
585  }
586  }
587  }
588 
589  } // End of the loop on the Arrival domains
590 
591  // In the remaining domains, *this is set to zero:
592  // ----------------------------------------------
593 
594  if (nzet < nz_a) {
595  annule(nzet, nz_a - 1) ;
596  }
597 
598  // Treatment of dzpuis
599  // -------------------
600 
601  set_dzpuis(0) ;
602 
603 }
604 }
int get_type_p() const
Returns the type of sampling in the direction: SYM : : symmetry with respect to the transformatio...
Definition: grilles.h:495
void del_t()
Logical destructor.
Definition: cmp.C:259
Mtbl_cf * c_cf
Coefficients of the spectral expansion of the function.
Definition: valeur.h:302
void import_anti_asymy(int nzet, const Cmp &ci)
Assignment to another Cmp defined on a different mapping, when the two mappings have anti-aligned Car...
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition: cmp.h:443
void add_int(const int &n, int position=0)
Adds the address of a new int to the list.
Definition: param.C:246
int get_np(int l) const
Returns the number of points in the azimuthal direction ( ) in domain no. l.
Definition: grilles.h:462
void coef() const
Computes the coeffcients of *this.
Definition: valeur_coef.C:148
Cmp sqrt(const Cmp &)
Square root.
Definition: cmp_math.C:220
void annule(int l)
Sets the Cmp to zero in a given domain.
Definition: cmp.C:348
Multi-domain array.
Definition: mtbl.h:118
double get_ori_y() const
Returns the y coordinate of the origin.
Definition: map.h:770
Lorene prototypes.
Definition: app_hor.h:64
const Mg3d * get_mg() const
Gives the Mg3d on which the mapping is defined.
Definition: map.h:765
int etat
Logical state (ETATNONDEF , ETATQCQ or ETATZERO ).
Definition: cmp.h:451
Base class for coordinate mappings.
Definition: map.h:670
double get_ori_x() const
Returns the x coordinate of the origin.
Definition: map.h:768
Values and coefficients of a (real-value) function.
Definition: valeur.h:287
Coord tet
coordinate centered on the grid
Definition: map.h:719
Coord phi
coordinate centered on the grid
Definition: map.h:720
void set_etat_zero()
Sets the logical state to ETATZERO (zero).
Definition: cmp.C:289
int dzpuis
Power of r by which the quantity represented by this must be divided in the external compactified zon...
Definition: cmp.h:458
double * t
The array of double.
Definition: tbl.h:173
Mtbl * c
Values of the function at the points of the multi-grid.
Definition: valeur.h:299
Parameter storage.
Definition: param.h:125
int get_nzone() const
Returns the number of domains.
Definition: grilles.h:448
void import_align_asymy(int nzet, const Cmp &ci)
Assignment to another Cmp defined on a different mapping, when the two mappings have aligned Cartesia...
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: cmp.C:304
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: mtbl.C:299
int get_nr(int l) const
Returns the number of points in the radial direction ( ) in domain no. l.
Definition: grilles.h:452
Multi-domain grid.
Definition: grilles.h:273
const Map * mp
Reference mapping.
Definition: cmp.h:448
const Base_vect_cart & get_bvect_cart() const
Returns the Cartesian basis associated with the coordinates (x,y,z) of the mapping, i.e.
Definition: map.h:791
Coord y
y coordinate centered on the grid
Definition: map.h:727
void add_double(const double &x, int position=0)
Adds the the address of a new double to the list.
Definition: param.C:315
Coord x
x coordinate centered on the grid
Definition: map.h:726
void set_etat_c_qcq()
Sets the logical state to ETATQCQ (ordinary state) for values in the configuration space (Mtbl c )...
Definition: valeur.C:701
double get_ori_z() const
Returns the z coordinate of the origin.
Definition: map.h:772
void set_dzpuis(int)
Set a value to dzpuis.
Definition: cmp.C:654
int get_nt(int l) const
Returns the number of points in the co-latitude direction ( ) in domain no. l.
Definition: grilles.h:457
Tbl ** t
Array (size nzone ) of pointers on the Tbl &#39;s.
Definition: mtbl.h:132
void import_asymy(const Cmp &ci)
Assignment to another Cmp defined on a different mapping.
Coord z
z coordinate centered on the grid
Definition: map.h:728
Valeur va
The numerical value of the Cmp.
Definition: cmp.h:461
double val_point_asymy(int l, double x, double theta, double phi) const
Computes the value of the field represented by *this at an arbitrary point, by means of the spectral ...
void add_int_mod(int &n, int position=0)
Adds the address of a new modifiable int to the list.
Definition: param.C:385
Coord r
r coordinate centered on the grid
Definition: map.h:718
virtual void val_lx(double rr, double theta, double pphi, int &l, double &xi) const =0
Computes the domain index l and the value of corresponding to a point given by its physical coordina...