LORENE
map_et_poisson.C
1 /*
2  * Method of the class Map_et for the (iterative) resolution of the scalar
3  * Poisson equation.
4  *
5  * (see file map.h for the documentation).
6  *
7  */
8 
9 /*
10  * Copyright (c) 2004 Francois Limousin
11  * Copyright (c) 1999-2003 Eric Gourgoulhon
12  * Copyright (c) 2000-2001 Philippe Grandclement
13  *
14  * This file is part of LORENE.
15  *
16  * LORENE is free software; you can redistribute it and/or modify
17  * it under the terms of the GNU General Public License as published by
18  * the Free Software Foundation; either version 2 of the License, or
19  * (at your option) any later version.
20  *
21  * LORENE is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with LORENE; if not, write to the Free Software
28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29  *
30  */
31 
32 
33 
34 
35 
36 /*
37  * $Id: map_et_poisson.C,v 1.10 2024/06/24 14:10:51 j_novak Exp $
38  * $Log: map_et_poisson.C,v $
39  * Revision 1.10 2024/06/24 14:10:51 j_novak
40  * Back to previous version.
41  *
42  * Revision 1.9 2023/05/26 15:42:30 g_servignat
43  * Added c_est_pas_fait() to poisson_angu(Cmp)
44  *
45  * Revision 1.8 2016/12/05 16:17:58 j_novak
46  * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
47  *
48  * Revision 1.7 2014/10/13 08:53:05 j_novak
49  * Lorene classes and functions now belong to the namespace Lorene.
50  *
51  * Revision 1.6 2005/08/25 12:14:09 p_grandclement
52  * Addition of a new method to solve the scalar Poisson equation, based on a multi-domain Tau-method
53  *
54  * Revision 1.5 2005/04/04 21:31:31 e_gourgoulhon
55  * Added argument lambda to method poisson_angu
56  * to deal with the generalized angular Poisson equation:
57  * Lap_ang u + lambda u = source.
58  *
59  * Revision 1.4 2004/06/22 12:20:17 j_novak
60  * *** empty log message ***
61  *
62  * Revision 1.3 2004/05/25 14:28:01 f_limousin
63  * First version of method Map_et::poisson_angu().
64  *
65  * Revision 1.2 2003/10/15 21:11:26 e_gourgoulhon
66  * Added method poisson_angu.
67  *
68  * Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
69  * LORENE
70  *
71  * Revision 1.7 2000/05/22 14:55:30 phil
72  * ajout du cas dzpuis = 3
73  *
74  * Revision 1.6 2000/03/30 09:18:37 eric
75  * Modifs affichage.
76  *
77  * Revision 1.5 2000/03/29 12:01:38 eric
78  * *** empty log message ***
79  *
80  * Revision 1.4 2000/03/29 11:48:09 eric
81  * Modifs affichage.
82  *
83  * Revision 1.3 2000/03/10 15:48:25 eric
84  * MODIFS IMPORTANTES:
85  * ssj est desormais traitee comme un Cmp (et non plus une Valeur) ce qui
86  * permet un traitement automatique du dzpuis associe.
87  * Traitement de dzpuis.
88  *
89  * Revision 1.2 2000/03/07 16:50:57 eric
90  * Possibilite d'avoir une source avec dzpuis = 2.
91  *
92  * Revision 1.1 1999/12/22 17:11:24 eric
93  * Initial revision
94  *
95  *
96  * $Header: /cvsroot/Lorene/C++/Source/Map/map_et_poisson.C,v 1.10 2024/06/24 14:10:51 j_novak Exp $
97  *
98  */
99 
100 // Header Lorene:
101 #include "map.h"
102 #include "cmp.h"
103 #include "scalar.h"
104 #include "param.h"
105 #include "graphique.h"
106 
107 //*****************************************************************************
108 
109 namespace Lorene {
110 
111 void Map_et::poisson(const Cmp& source, Param& par, Cmp& uu) const {
112 
113  assert(source.get_etat() != ETATNONDEF) ;
114  assert(source.get_mp() == this) ;
115 
116  assert( source.check_dzpuis(2) || source.check_dzpuis(4)
117  || source.check_dzpuis(3)) ;
118 
119  assert(uu.get_mp() == this) ;
120  assert(uu.check_dzpuis(0)) ;
121 
122  int nz = mg->get_nzone() ;
123  int nzm1 = nz - 1 ;
124 
125  // Indicator of existence of a compactified external domain
126  bool zec = false ;
127  if (mg->get_type_r(nzm1) == UNSURR) {
128  zec = true ;
129  }
130 
131  //-------------------------------
132  // Computation of the prefactor a ---> Cmp apre
133  //-------------------------------
134 
135  Mtbl unjj = 1 + srdrdt*srdrdt + srstdrdp*srstdrdp ;
136 
137  Mtbl apre1(*mg) ;
138  apre1.set_etat_qcq() ;
139  for (int l=0; l<nz; l++) {
140  *(apre1.t[l]) = alpha[l]*alpha[l] ;
141  }
142 
143  apre1 = apre1 * dxdr * dxdr * unjj ;
144 
145  Cmp apre(*this) ;
146  apre = apre1 ;
147 
148  Tbl amax0 = max(apre1) ; // maximum values in each domain
149 
150  // The maximum values of a in each domain are put in a Mtbl
151  Mtbl amax1(*mg) ;
152  amax1.set_etat_qcq() ;
153  for (int l=0; l<nz; l++) {
154  *(amax1.t[l]) = amax0(l) ;
155  }
156 
157  Cmp amax(*this) ;
158  amax = amax1 ;
159 
160 
161  //-------------------
162  // Initializations
163  //-------------------
164 
165  int nitermax = par.get_int() ;
166  int& niter = par.get_int_mod() ;
167  double lambda = par.get_double() ;
168  double unmlambda = 1. - lambda ;
169  double precis = par.get_double(1) ;
170 
171  Cmp& ssj = par.get_cmp_mod() ;
172 
173  Cmp ssjm1 = ssj ;
174  Cmp ssjm2 = ssjm1 ;
175 
176  Valeur& vuu = uu.va ;
177 
178  Valeur vuujm1(*mg) ;
179  if (uu.get_etat() == ETATZERO) {
180  vuujm1 = 1 ; // to take relative differences
181  vuujm1.set_base( vuu.base ) ;
182  }
183  else{
184  vuujm1 = vuu ;
185  }
186 
187  // Affine mapping for the Laplacian-tilde
188 
189  Map_af mpaff(*this) ;
190  Param par_nul ;
191 
192  cout << "Map_et::poisson : relat. diff. u^J <-> u^{J-1} : " << endl ;
193 
194 //==========================================================================
195 //==========================================================================
196 // Start of iteration
197 //==========================================================================
198 //==========================================================================
199 
200  Tbl tdiff(nz) ;
201  double diff ;
202  niter = 0 ;
203 
204  do {
205 
206  //====================================================================
207  // Computation of R(u) (the result is put in uu)
208  //====================================================================
209 
210 
211  //-----------------------
212  // First operations on uu
213  //-----------------------
214 
215  Valeur duudx = (uu.va).dsdx() ; // d/dx
216 
217  const Valeur& d2uudtdx = duudx.dsdt() ; // d^2/dxdtheta
218 
219  const Valeur& std2uudpdx = duudx.stdsdp() ; // 1/sin(theta) d^2/dxdphi
220 
221  //------------------
222  // Angular Laplacian
223  //------------------
224 
225  Valeur sxlapang = uu.va ;
226 
227  sxlapang.ylm() ;
228 
229  sxlapang = sxlapang.lapang() ;
230 
231  sxlapang = sxlapang.sx() ; // Lap_ang(uu) /x in the nucleus
232  // Lap_ang(uu) in the shells
233  // Lap_ang(uu) /(x-1) in the ZEC
234 
235  //---------------------------------------------------------------
236  // Computation of
237  // [ 2 /(dRdx) ( A - 1 ) duu/dx + 1/R (B - 1) Lap_ang(uu) ] / x
238  //
239  // with A = 1/(dRdx) R/(x+beta_l/alpha_l) unjj
240  // B = [1/(dRdx) R/(x+beta_l/alpha_l)]^2 unjj
241  //
242  // The result is put in uu (via vuu)
243  //---------------------------------------------------------------
244 
245  Valeur varduudx = duudx ;
246 
247  if (zec) {
248  varduudx.annule(nzm1) ; // term in d/dx set to zero in the ZEC
249  }
250 
251  uu.set_etat_qcq() ;
252 
253  Base_val sauve_base = varduudx.base ;
254 
255  vuu = 2. * dxdr * ( rsxdxdr * unjj - 1.) * varduudx
256  + ( rsxdxdr*rsxdxdr * unjj - 1.) * xsr * sxlapang ;
257 
258  vuu.set_base(sauve_base) ;
259 
260  vuu = vuu.sx() ;
261 
262  //---------------------------------------
263  // Computation of R(u)
264  //
265  // The result is put in uu (via vuu)
266  //---------------------------------------
267 
268 
269  sauve_base = vuu.base ;
270 
271  vuu = xsr * vuu
272  + 2. * dxdr * ( sr2drdt * d2uudtdx
273  + sr2stdrdp * std2uudpdx ) ;
274 
275  vuu += dxdr * ( lapr_tp + dxdr * (
276  dxdr* unjj * d2rdx2
277  - 2. * ( sr2drdt * d2rdtdx + sr2stdrdp * sstd2rdpdx ) )
278  ) * duudx ;
279 
280  vuu.set_base(sauve_base) ;
281 
282  // Since the assignment is performed on vuu (uu.va), the treatment
283  // of uu.dzpuis must be performed by hand:
284 
285  uu.set_dzpuis(4) ;
286 
287  if (source.get_dzpuis() == 2) {
288  uu.dec2_dzpuis() ; // uu.dzpuis: 4 -> 2
289  }
290 
291  if (source.get_dzpuis() == 3) {
292  uu.dec_dzpuis() ; //uu.dzpuis 4 -> 3
293  }
294 
295  //====================================================================
296  // Computation of the effective source s^J of the ``affine''
297  // Poisson equation
298  //====================================================================
299 
300  ssj = lambda * ssjm1 + unmlambda * ssjm2 ;
301 
302  ssj = ( source + uu + (amax - apre) * ssj ) / amax ;
303 
304  (ssj.va).set_base((source.va).base) ;
305 
306  //====================================================================
307  // Resolution of the ``affine'' Poisson equation
308  //====================================================================
309 
310  if ( source.get_dzpuis() == 0 ){
311  ssj.set_dzpuis( 4 ) ;
312  }
313  else {
314  ssj.set_dzpuis( source.get_dzpuis() ) ; // Choice of the resolution
315  // dzpuis = 2, 3 or 4
316  }
317 
318  assert( uu.check_dzpuis( ssj.get_dzpuis() ) ) ;
319 
320  mpaff.poisson(ssj, par_nul, uu) ;
321 
322  tdiff = diffrel(vuu, vuujm1) ;
323 
324  diff = max(tdiff) ;
325 
326 
327  cout << " step " << niter << " : " ;
328  for (int l=0; l<nz; l++) {
329  cout << tdiff(l) << " " ;
330  }
331  cout << endl ;
332 
333  //=================================
334  // Updates for the next iteration
335  //=================================
336 
337  ssjm2 = ssjm1 ;
338  ssjm1 = ssj ;
339  vuujm1 = vuu ;
340 
341  niter++ ;
342 
343  } // End of iteration
344  while ( (diff > precis) && (niter < nitermax) ) ;
345 
346 //==========================================================================
347 //==========================================================================
348 // End of iteration
349 //==========================================================================
350 //==========================================================================
351 
352 }
353 
354 
355 
356 //*****************************************************************************
357 // VERSION WITH A TAU METHOD
358 //*****************************************************************************
359 
360 void Map_et::poisson_tau(const Cmp& source, Param& par, Cmp& uu) const {
361 
362  assert(source.get_etat() != ETATNONDEF) ;
363  assert(source.get_mp() == this) ;
364 
365  assert( source.check_dzpuis(2) || source.check_dzpuis(4)
366  || source.check_dzpuis(3)) ;
367 
368  assert(uu.get_mp() == this) ;
369  assert(uu.check_dzpuis(0)) ;
370 
371  int nz = mg->get_nzone() ;
372  int nzm1 = nz - 1 ;
373 
374  // Indicator of existence of a compactified external domain
375  bool zec = false ;
376  if (mg->get_type_r(nzm1) == UNSURR) {
377  zec = true ;
378  }
379 
380  //-------------------------------
381  // Computation of the prefactor a ---> Cmp apre
382  //-------------------------------
383 
384  Mtbl unjj = 1 + srdrdt*srdrdt + srstdrdp*srstdrdp ;
385 
386  Mtbl apre1(*mg) ;
387  apre1.set_etat_qcq() ;
388  for (int l=0; l<nz; l++) {
389  *(apre1.t[l]) = alpha[l]*alpha[l] ;
390  }
391 
392  apre1 = apre1 * dxdr * dxdr * unjj ;
393 
394  Cmp apre(*this) ;
395  apre = apre1 ;
396 
397  Tbl amax0 = max(apre1) ; // maximum values in each domain
398 
399  // The maximum values of a in each domain are put in a Mtbl
400  Mtbl amax1(*mg) ;
401  amax1.set_etat_qcq() ;
402  for (int l=0; l<nz; l++) {
403  *(amax1.t[l]) = amax0(l) ;
404  }
405 
406  Cmp amax(*this) ;
407  amax = amax1 ;
408 
409 
410  //-------------------
411  // Initializations
412  //-------------------
413 
414  int nitermax = par.get_int() ;
415  int& niter = par.get_int_mod() ;
416  double lambda = par.get_double() ;
417  double unmlambda = 1. - lambda ;
418  double precis = par.get_double(1) ;
419 
420  Cmp& ssj = par.get_cmp_mod() ;
421 
422  Cmp ssjm1 = ssj ;
423  Cmp ssjm2 = ssjm1 ;
424 
425  Valeur& vuu = uu.va ;
426 
427  Valeur vuujm1(*mg) ;
428  if (uu.get_etat() == ETATZERO) {
429  vuujm1 = 1 ; // to take relative differences
430  vuujm1.set_base( vuu.base ) ;
431  }
432  else{
433  vuujm1 = vuu ;
434  }
435 
436  // Affine mapping for the Laplacian-tilde
437 
438  Map_af mpaff(*this) ;
439  Param par_nul ;
440 
441  cout << "Map_et::poisson_tau : relat. diff. u^J <-> u^{J-1} : " << endl ;
442 
443 //==========================================================================
444 //==========================================================================
445 // Start of iteration
446 //==========================================================================
447 //==========================================================================
448 
449  Tbl tdiff(nz) ;
450  double diff ;
451  niter = 0 ;
452 
453  do {
454 
455  //====================================================================
456  // Computation of R(u) (the result is put in uu)
457  //====================================================================
458 
459 
460  //-----------------------
461  // First operations on uu
462  //-----------------------
463 
464  Valeur duudx = (uu.va).dsdx() ; // d/dx
465 
466  const Valeur& d2uudtdx = duudx.dsdt() ; // d^2/dxdtheta
467 
468  const Valeur& std2uudpdx = duudx.stdsdp() ; // 1/sin(theta) d^2/dxdphi
469 
470  //------------------
471  // Angular Laplacian
472  //------------------
473 
474  Valeur sxlapang = uu.va ;
475 
476  sxlapang.ylm() ;
477 
478  sxlapang = sxlapang.lapang() ;
479 
480  sxlapang = sxlapang.sx() ; // Lap_ang(uu) /x in the nucleus
481  // Lap_ang(uu) in the shells
482  // Lap_ang(uu) /(x-1) in the ZEC
483 
484  //---------------------------------------------------------------
485  // Computation of
486  // [ 2 /(dRdx) ( A - 1 ) duu/dx + 1/R (B - 1) Lap_ang(uu) ] / x
487  //
488  // with A = 1/(dRdx) R/(x+beta_l/alpha_l) unjj
489  // B = [1/(dRdx) R/(x+beta_l/alpha_l)]^2 unjj
490  //
491  // The result is put in uu (via vuu)
492  //---------------------------------------------------------------
493 
494  Valeur varduudx = duudx ;
495 
496  if (zec) {
497  varduudx.annule(nzm1) ; // term in d/dx set to zero in the ZEC
498  }
499 
500  uu.set_etat_qcq() ;
501 
502  Base_val sauve_base = varduudx.base ;
503 
504  vuu = 2. * dxdr * ( rsxdxdr * unjj - 1.) * varduudx
505  + ( rsxdxdr*rsxdxdr * unjj - 1.) * xsr * sxlapang ;
506 
507  vuu.set_base(sauve_base) ;
508 
509  vuu = vuu.sx() ;
510 
511  //---------------------------------------
512  // Computation of R(u)
513  //
514  // The result is put in uu (via vuu)
515  //---------------------------------------
516 
517 
518  sauve_base = vuu.base ;
519 
520  vuu = xsr * vuu
521  + 2. * dxdr * ( sr2drdt * d2uudtdx
522  + sr2stdrdp * std2uudpdx ) ;
523 
524  vuu += dxdr * ( lapr_tp + dxdr * (
525  dxdr* unjj * d2rdx2
526  - 2. * ( sr2drdt * d2rdtdx + sr2stdrdp * sstd2rdpdx ) )
527  ) * duudx ;
528 
529  vuu.set_base(sauve_base) ;
530 
531  // Since the assignment is performed on vuu (uu.va), the treatment
532  // of uu.dzpuis must be performed by hand:
533 
534  uu.set_dzpuis(4) ;
535 
536  if (source.get_dzpuis() == 2) {
537  uu.dec2_dzpuis() ; // uu.dzpuis: 4 -> 2
538  }
539 
540  if (source.get_dzpuis() == 3) {
541  uu.dec_dzpuis() ; //uu.dzpuis 4 -> 3
542  }
543 
544  //====================================================================
545  // Computation of the effective source s^J of the ``affine''
546  // Poisson equation
547  //====================================================================
548 
549  ssj = lambda * ssjm1 + unmlambda * ssjm2 ;
550 
551  ssj = ( source + uu + (amax - apre) * ssj ) / amax ;
552 
553  (ssj.va).set_base((source.va).base) ;
554 
555  //====================================================================
556  // Resolution of the ``affine'' Poisson equation
557  //====================================================================
558 
559  if ( source.get_dzpuis() == 0 ){
560  ssj.set_dzpuis( 4 ) ;
561  }
562  else {
563  ssj.set_dzpuis( source.get_dzpuis() ) ; // Choice of the resolution
564  // dzpuis = 2, 3 or 4
565  }
566 
567  assert( uu.check_dzpuis( ssj.get_dzpuis() ) ) ;
568 
569  mpaff.poisson_tau(ssj, par_nul, uu) ;
570 
571  tdiff = diffrel(vuu, vuujm1) ;
572 
573  diff = max(tdiff) ;
574 
575 
576  cout << " step " << niter << " : " ;
577  for (int l=0; l<nz; l++) {
578  cout << tdiff(l) << " " ;
579  }
580  cout << endl ;
581 
582  //=================================
583  // Updates for the next iteration
584  //=================================
585 
586  ssjm2 = ssjm1 ;
587  ssjm1 = ssj ;
588  vuujm1 = vuu ;
589 
590  niter++ ;
591 
592  } // End of iteration
593  while ( (diff > precis) && (niter < nitermax) ) ;
594 
595 //==========================================================================
596 //==========================================================================
597 // End of iteration
598 //==========================================================================
599 //==========================================================================
600 }
601 
602 void Map_et::poisson_angu(const Scalar& source, Param& par, Scalar& uu,
603  double lambda) const {
604 
605  if (lambda != double(0)) {
606  cout <<
607  "Map_et::poisson_angu : the case lambda != 0 is not treated yet !"
608  << endl ;
609  abort() ;
610  }
611 
612  assert(source.get_mp() == *this) ;
613  assert(uu.get_mp() == *this) ;
614 
615  int nz = mg->get_nzone() ;
616  int nzm1 = nz - 1 ;
617 
618  int* nrm6 = new int[nz];
619  for (int l=0; l<=nzm1; l++)
620  nrm6[l] = mg->get_nr(l) - 6 ;
621 
622 //## // Indicator of existence of a compactified external domain
623 // bool zec = false ;
624 // if (mg->get_type_r(nzm1) == UNSURR) {
625 // zec = true ;
626 // }
627 
628  //-------------------
629  // Initializations
630  //-------------------
631 
632  int nitermax = par.get_int() ;
633  int& niter = par.get_int_mod() ;
634  double relax = par.get_double() ;
635  double precis = par.get_double(1) ;
636 
637  Cmp& ssjcmp = par.get_cmp_mod() ;
638 
639  Scalar ssj (ssjcmp) ;
640  Scalar ssjm1 (ssj) ;
641 
642  int dzpuis = source.get_dzpuis() ;
643  ssj.set_dzpuis(dzpuis) ;
644  uu.set_dzpuis(dzpuis) ;
645  ssjm1.set_dzpuis(dzpuis) ;
646 
647  Valeur& vuu = uu.set_spectral_va() ;
648 
649  Valeur vuujm1(*mg) ;
650  if (uu.get_etat() == ETATZERO) {
651  vuujm1 = 1 ; // to take relative differences
652  vuujm1.set_base( vuu.base ) ;
653  }
654  else{
655  vuujm1 = vuu ;
656  }
657 
658  // Affine mapping for the Laplacian-tilde
659 
660  Map_af mpaff(*this) ;
661  Param par_nul ;
662 
663  cout << "Map_et::poisson angu : relat. diff. u^J <-> u^{J-1} : " << endl ;
664 
665 //==========================================================================
666 //==========================================================================
667 // Start of iteration
668 //==========================================================================
669 //==========================================================================
670 
671 
672  Tbl tdiff(nz) ;
673  double diff ;
674  niter = 0 ;
675 
676  do {
677 
678  //====================================================================
679  // Computation of R(u) (the result is put in uu)
680  //====================================================================
681 
682  //-----------------------
683  // First operations on uu
684  //-----------------------
685 
686  Valeur duudx = (uu.set_spectral_va()).dsdx() ; // d/dx
687 
688  const Valeur& d2uudxdx = duudx.dsdx() ; // d^2/dxdx
689 
690 
691  const Valeur& d2uudtdx = duudx.dsdt() ; // d^2/dxdtheta
692 
693  const Valeur& std2uudpdx = duudx.stdsdp() ; // 1/sin(theta) d^2/dxdphi
694 
695  //---------------------------------------
696  // Computation of R(u)
697  //
698  // The result is put in uu (via vuu)
699  //---------------------------------------
700 
701  Mtbl unjj = srdrdt*srdrdt + srstdrdp*srstdrdp ;
702 
703  Base_val sauve_base = vuu.base ;
704 
705  vuu = - d2uudxdx * dxdr * dxdr * unjj
706  + 2. * dxdr * ( sr2drdt * d2uudtdx
707  + sr2stdrdp * std2uudpdx ) ;
708 
709  vuu.set_base(sauve_base) ;
710 
711  vuu += dxdr * ( lapr_tp + dxdr * (
712  dxdr * unjj * d2rdx2
713  - 2. * ( sr2drdt * d2rdtdx + sr2stdrdp * sstd2rdpdx ) )
714  ) * duudx ;
715 
716  vuu.set_base(sauve_base) ;
717 
718  uu.mult_r() ;
719  uu.mult_r() ;
720 
721  //====================================================================
722  // Computation of the effective source s^J of the ``affine''
723  // Poisson equation
724  //====================================================================
725 
726  uu.filtre_r(nrm6) ;
727 // uu.filtre_phi(1) ;
728 // uu.filtre_theta(1) ;
729 
730  ssj = source + uu ;
731 
732  ssj = (1-relax) * ssj + relax * ssjm1 ;
733 
734  (ssj.set_spectral_va()).set_base((source.get_spectral_va()).base) ;
735 
736 
737  //====================================================================
738  // Resolution of the ``affine'' Poisson equation
739  //====================================================================
740 
741  mpaff.poisson_angu(ssj, par_nul, uu) ;
742 
743  tdiff = diffrel(vuu, vuujm1) ;
744 
745  diff = max(tdiff) ;
746 
747 
748  cout << " step " << niter << " : " ;
749  for (int l=0; l<nz; l++) {
750  cout << tdiff(l) << " " ;
751  }
752  cout << endl ;
753 
754  //=================================
755  // Updates for the next iteration
756  //=================================
757 
758  vuujm1 = vuu ;
759  ssjm1 = ssj ;
760 
761  niter++ ;
762 
763  } // End of iteration
764  while ( (diff > precis) && (niter < nitermax) ) ;
765 
766 //==========================================================================
767 //==========================================================================
768 // End of iteration
769 //==========================================================================
770 //==========================================================================
771 
772  uu.set_dzpuis( source.get_dzpuis() ) ; // dzpuis unchanged
773 
774 }
775 
776 void Map_et::poisson_angu(const Cmp& , Param&, Cmp&, double) const {
777  cout << "Map_et::poisson_angu(const Cmp&, Param&, Cmp&, double) pas fait" << endl; abort() ;
778  }
779 
780 
781 }
const Map * get_mp() const
Returns the mapping.
Definition: cmp.h:901
Coord d2rdx2
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1640
const Valeur & dsdt() const
Returns of *this.
Definition: valeur_dsdt.C:115
Coord sr2stdrdp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1629
const Valeur & dsdx() const
Returns of *this.
Definition: valeur_dsdx.C:114
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition: cmp.h:446
void filtre_r(int *nn)
Sets the n lasts coefficients in r to 0 in all domains.
Definition: scalar_manip.C:186
void mult_r()
Multiplication by r everywhere; dzpuis is not changed.
const Valeur & lapang() const
Returns the angular Laplacian of *this.
Definition: valeur_lapang.C:75
void dec_dzpuis()
Decreases by 1 the value of dzpuis and changes accordingly the values of the Cmp in the external comp...
Definition: cmp_r_manip.C:157
Multi-domain array.
Definition: mtbl.h:118
double * alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition: map.h:2789
Lorene prototypes.
Definition: app_hor.h:67
void ylm()
Computes the coefficients of *this.
Definition: valeur_ylm.C:141
int get_etat() const
Returns the logical state.
Definition: cmp.h:899
Coord sr2drdt
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1621
Tensor field of valence 0 (or component of a tensorial field).
Definition: scalar.h:393
const Valeur & sx() const
Returns (r -sampling = RARE ) \ Id (r sampling = FIN ) \ (r -sampling = UNSURR ) ...
Definition: valeur_sx.C:113
Values and coefficients of a (real-value) function.
Definition: valeur.h:297
int get_etat() const
Returns the logical state ETATNONDEF (undefined), ETATZERO (null) or ETATQCQ (ordinary).
Definition: scalar.h:560
void annule(int l)
Sets the Valeur to zero in a given domain.
Definition: valeur.C:747
void set_base(const Base_val &)
Sets the bases for spectral expansions (member base )
Definition: valeur.C:813
Tbl diffrel(const Cmp &a, const Cmp &b)
Relative difference between two Cmp (norme version).
Definition: cmp_math.C:507
Coord srstdrdp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1613
void set_dzpuis(int)
Modifies the dzpuis flag.
Definition: scalar.C:814
Cmp & get_cmp_mod(int position=0) const
Returns the reference of a modifiable Cmp stored in the list.
Definition: param.C:1052
virtual void poisson(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation.
const int & get_int(int position=0) const
Returns the reference of a int stored in the list.
Definition: param.C:295
virtual void poisson(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation.
Coord dxdr
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1581
Base_val base
Bases on which the spectral expansion is performed.
Definition: valeur.h:315
int get_dzpuis() const
Returns dzpuis.
Definition: scalar.h:563
Parameter storage.
Definition: param.h:125
const Valeur & stdsdp() const
Returns of *this.
Definition: valeur_stdsdp.C:63
int get_nzone() const
Returns the number of domains.
Definition: grilles.h:465
int & get_int_mod(int position=0) const
Returns the reference of a modifiable int stored in the list.
Definition: param.C:433
Tbl max(const Cmp &)
Maximum values of a Cmp in each domain.
Definition: cmp_math.C:438
Coord sstd2rdpdx
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1669
void dec2_dzpuis()
Decreases by 2 the value of dzpuis and changes accordingly the values of the Cmp in the external comp...
Definition: cmp_r_manip.C:183
Coord xsr
in the nucleus; \ 1/R in the non-compactified shells; \ in the compactified outer domain...
Definition: map.h:1570
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: cmp.C:307
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: mtbl.C:302
Coord rsxdxdr
in the nucleus; \ in the shells; \ in the outermost compactified domain.
Definition: map.h:2865
virtual void poisson_tau(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation using a Tau method.
int get_nr(int l) const
Returns the number of points in the radial direction ( ) in domain no. l.
Definition: grilles.h:469
virtual void poisson_angu(const Scalar &source, Param &par, Scalar &uu, double lambda=0) const
Computes the solution of the generalized angular Poisson equation.
const Mg3d * mg
Pointer on the multi-grid Mgd3 on which this is defined.
Definition: map.h:694
Bases of the spectral expansions.
Definition: base_val.h:325
Affine radial mapping.
Definition: map.h:2048
virtual void poisson_angu(const Scalar &source, Param &par, Scalar &uu, double lambda=0) const
Computes the solution of the generalized angular Poisson equation.
int get_dzpuis() const
Returns dzpuis.
Definition: cmp.h:903
Coord lapr_tp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1652
bool check_dzpuis(int dzi) const
Returns false if the last domain is compactified and *this is not zero in this domain and dzpuis is n...
Definition: cmp.C:718
void set_dzpuis(int)
Set a value to dzpuis.
Definition: cmp.C:657
const double & get_double(int position=0) const
Returns the reference of a double stored in the list.
Definition: param.C:364
Basic array class.
Definition: tbl.h:164
Valeur & set_spectral_va()
Returns va (read/write version)
Definition: scalar.h:610
int get_type_r(int l) const
Returns the type of sampling in the radial direction in domain no.
Definition: grilles.h:491
Tbl ** t
Array (size nzone ) of pointers on the Tbl &#39;s.
Definition: mtbl.h:132
Coord srdrdt
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1605
const Map & get_mp() const
Returns the mapping.
Definition: tensor.h:874
Valeur va
The numerical value of the Cmp.
Definition: cmp.h:464
const Valeur & get_spectral_va() const
Returns va (read only version)
Definition: scalar.h:607
Coord d2rdtdx
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition: map.h:1661
virtual void poisson_tau(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation with a Tau method.