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
29char 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
66namespace Lorene {
67void 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
79void 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
126void 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
369void 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}
Lorene::Cmp::mp
const Map * mp
Reference mapping.
Definition cmp.h:451
Lorene::Cmp::Cmp
Cmp(const Map &map)
Constructor from mapping.
Definition cmp.C:208
Lorene::Cmp::dzpuis
int dzpuis
Power of r by which the quantity represented by this must be divided in the external compactified z...
Definition cmp.h:461
Lorene::Cmp::va
Valeur va
The numerical value of the Cmp.
Definition cmp.h:464
Lorene::Cmp::etat
int etat
Logical state (ETATNONDEF , ETATQCQ or ETATZERO ).
Definition cmp.h:454
Lorene::Cmp::annule
void annule(int l)
Sets the Cmp to zero in a given domain.
Definition cmp.C:348
Lorene::Cmp::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition cmp.C:304
Lorene::Cmp::set_etat_zero
void set_etat_zero()
Sets the logical state to ETATZERO (zero).
Definition cmp.C:289
Lorene::Cmp::import_anti_asymy
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...
Definition cmp_import_asymy.C:126
Lorene::Cmp::set_dzpuis
void set_dzpuis(int)
Set a value to dzpuis.
Definition cmp.C:654
Lorene::Cmp::import_align_asymy
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...
Definition cmp_import_asymy.C:369
Lorene::Cmp::del_t
void del_t()
Logical destructor.
Definition cmp.C:259
Lorene::Cmp::import_asymy
void import_asymy(const Cmp &ci)
Assignment to another Cmp defined on a different mapping.
Definition cmp_import_asymy.C:67
Lorene::Mg3d
Multi-domain grid.
Definition grilles.h: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:462
Lorene::Mg3d::get_type_p
int get_type_p() const
Returns the type of sampling in the direction: SYM : : symmetry with respect to the transformatio...
Definition grilles.h:495
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::Mtbl_cf::val_point_asymy
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 ...
Definition mtbl_cf_vp_asymy.C:71
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::Param
Parameter storage.
Definition param.h:125
Lorene::Param::add_double
void add_double(const double &x, int position=0)
Adds the the address of a new double to the list.
Definition param.C:315
Lorene::Param::add_int_mod
void add_int_mod(int &n, int position=0)
Adds the address of a new modifiable int to the list.
Definition param.C:385
Lorene::Param::add_int
void add_int(const int &n, int position=0)
Adds the address of a new int to the list.
Definition param.C:246
Lorene::Tbl::t
double * t
The array of double.
Definition tbl.h:173
Lorene::Valeur
Values and coefficients of a (real-value) function.
Definition valeur.h:287
Lorene::Valeur::c_cf
Mtbl_cf * c_cf
Coefficients of the spectral expansion of the function.
Definition valeur.h:302
Lorene::Valeur::coef
void coef() const
Computes the coeffcients of *this.
Definition valeur_coef.C:148
Lorene::sqrt
Cmp sqrt(const Cmp &)
Square root.
Definition cmp_math.C:220
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::r
Coord r
r coordinate centered on the grid
Definition map.h:718