KADATH
bc_waves.cpp
1 /*
2  Copyright 2017 Philippe Grandclement
3 
4  This file is part of Kadath.
5 
6  Kadath 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 3 of the License, or
9  (at your option) any later version.
10 
11  Kadath 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 Kadath. If not, see <http://www.gnu.org/licenses/>.
18 */
19 
20 #include "headcpp.hpp"
21 
22 #include "utilities.hpp"
23 #include "spheric.hpp"
24 #include "scalar.hpp"
25 #include "tensor_impl.hpp"
26 #include "term_eq.hpp"
27 namespace Kadath {
28 Array<double> mat_inv_leg_even (int, int) ;
29 Array<double> mat_inv_leg_odd (int, int) ;
30 Array<double> mat_leg_even (int, int) ;
31 Array<double> mat_leg_odd (int, int) ;
32 
33 Term_eq Domain_shell::bc_waves (const Term_eq& gamma, const Term_eq& omega) const {
34 
35  // Free parameters for checking
36  //int kkmax = nbr_coefs(2)-1 ;
37  //int jjmax = nbr_coefs(1) ;
38  int kkmax = 10 ;
39  int jjmax = 5 ;
40  int dom = gamma.get_dom() ;
41 
42  // Check if gamma is a metric
43  if (gamma.type_data != TERM_T) {
44  cerr << "Domain_shell::bc_waves only defined for a tensor" << endl ;
45  abort() ;
46  }
47  int valence = gamma.val_t->get_valence() ;
48  if (valence!=2) {
49  cerr << "Domain_shell::bc_waves only defined with respect to second order tensor (i.e. valence must be 2)" << endl ;
50  abort() ;
51  }
52  if (gamma.val_t->get_basis().get_basis(dom) != CARTESIAN_BASIS) {
53  cerr << "Domain_shell::bc_waves only defined with respect to Cartesian tensorial basis" << endl ;
54  abort() ;
55  }
56 
57 
58  bool doder = ((gamma.der_t==0x0) || (omega.der_d==0x0)) ? false : true ;
59 
60  // Put rmax in a Term_eq
61  Index posr (nbr_points) ;
62  posr.set(0) = nbr_points(1)-1 ;
63  double rmax = get_radius()(posr) ;
64 
65  // Compute the term_eq for the BC
66  int nbrm = int(nbr_coefs(2)/2) + 2 ;
67  int nbrl = 2*nbr_coefs(1)-1 ;
68  // Real parts and Imaginar parts
69  Term_eq** Rsh = new Term_eq* [nbrm*nbrl] ;
70  Term_eq** Ish = new Term_eq* [nbrm*nbrl] ;
71  Term_eq** dRsh = new Term_eq* [nbrm*nbrl] ;
72  Term_eq** dIsh = new Term_eq* [nbrm*nbrl] ;
73 
74  for (int m=0 ; m<nbrm ; m++)
75  for (int l=0 ; l<nbrl ; l++) {
76  Rsh[m*nbrl+l] = (m==0) ? new Term_eq (dom, pow(rmax, -(l+1)), 0) : new Term_eq (bessel_jl(m*omega*rmax, l)) ;
77  Ish[m*nbrl+l] = (m==0) ? new Term_eq (dom, pow(rmax, -(l+1)), 0) : new Term_eq (bessel_yl(m*omega*rmax, l)) ;
78  dRsh[m*nbrl+l] = (m==0) ? new Term_eq (dom, -(l+1)*pow(rmax, -(l+2)), 0) :
79  new Term_eq (m*omega*bessel_djl(m*omega*rmax, l)) ;
80  dIsh[m*nbrl+l] = (m==0) ? new Term_eq (dom, -(l+1)*pow(rmax, -(l+2)), 0) :
81  new Term_eq (m*omega*bessel_dyl(m*omega*rmax, l)) ;
82  }
83 
84  // To store the result
85  Tensor valres (*gamma.val_t, false) ;
86  valres.std_base() ;
87  for (int i=0 ; i<valres.get_n_comp() ; i++) {
88  valres.set(valres.indices(i)).set_domain(dom).allocate_coef() ;
89  Index pcf (nbr_coefs) ;
90  do {
91  valres.set(valres.indices(i)).set_domain(dom).set_coef(pcf) = 0 ;
92  }
93  while (pcf.inc()) ;
94  }
95  Tensor derres (valres) ;
96 
97  // Spherical harmonics -> Standard basis
98  // Passage matrices :
99  Array<double> inv_even (mat_inv_leg_even(nbr_coefs(1), nbr_coefs(2))) ;
100  Array<double> inv_odd (mat_inv_leg_odd(nbr_coefs(1), nbr_coefs(2))) ;
101  Array<double> passage_even (mat_leg_even(nbr_coefs(1), nbr_coefs(2))) ;
102  Array<double> passage_odd (mat_leg_odd(nbr_coefs(1), nbr_coefs(2))) ;
103 
104  // Symetric part :
105  // Loop on phi :
106  Index posylm (nbr_coefs) ;
107  Index posradial (nbr_coefs) ;
108 
109  for (int k=0 ; k<kkmax ; k+=2) {
110 
111  posylm.set(2) = k ;
112 
113  int mm = int(k/2) ;
114 
115  // loop on theta
116  int jmin = (mm%2==0) ? int(mm/2) : int((mm-1)/2) ;
117  int jmax = (mm%2==0) ? jjmax : jjmax-1 ;
118  for (int j=jmin ; j<jmax ; j++) {
119 
120  int ll = (mm%2==0) ? 2*j : 2*j+1 ;
121 
122  // Radial derivatives
123  double Rvaldrxx = multipoles_sym (k, j, OUTER_BC, (*gamma.val_t)(1,1)(dom).der_r(), passage_even) ;
124  double Rvaldrxy = multipoles_sym (k, j, OUTER_BC, (*gamma.val_t)(1,2)(dom).der_r(), passage_even) ;
125  double Rvaldryy = multipoles_sym (k, j, OUTER_BC, (*gamma.val_t)(2,2)(dom).der_r(), passage_even) ;
126  double Rvaldrzz = multipoles_sym (k, j, OUTER_BC, (*gamma.val_t)(3,3)(dom).der_r(), passage_even) ;
127 
128  double Ivaldrxx = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_sym (k+1, j, OUTER_BC, (*gamma.val_t)(1,1)(dom).der_r(), passage_even) ;
129  double Ivaldrxy = ((k==kkmax-1) || (k==0))? 0 : multipoles_sym (k+1, j, OUTER_BC, (*gamma.val_t)(1,2)(dom).der_r(), passage_even) ;
130  double Ivaldryy = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_sym (k+1, j, OUTER_BC, (*gamma.val_t)(2,2)(dom).der_r(), passage_even) ;
131  double Ivaldrzz = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_sym (k+1, j, OUTER_BC, (*gamma.val_t)(3,3)(dom).der_r(), passage_even) ;
132 
133  Term_eq* RdV1 ;
134  Term_eq* RdV2 ;
135  Term_eq* RdV3 ;
136  Term_eq* RdV6 ;
137 
138  Term_eq* IdV1 ;
139  Term_eq* IdV2 ;
140  Term_eq* IdV3 ;
141  Term_eq* IdV6 ;
142 
143  if (doder) {
144 
145  double Rderdrxx = multipoles_sym (k, j, OUTER_BC, (*gamma.der_t)(1,1)(dom).der_r(), passage_even) ;
146  double Rderdrxy = multipoles_sym (k, j, OUTER_BC, (*gamma.der_t)(1,2)(dom).der_r(), passage_even) ;
147  double Rderdryy = multipoles_sym (k, j, OUTER_BC, (*gamma.der_t)(2,2)(dom).der_r(), passage_even) ;
148  double Rderdrzz = multipoles_sym (k, j, OUTER_BC, (*gamma.der_t)(3,3)(dom).der_r(), passage_even) ;
149 
150  double Iderdrxx = ((k==kkmax-1) || (k==0)) ? 0 :multipoles_sym (k+1, j, OUTER_BC, (*gamma.der_t)(1,1)(dom).der_r(), passage_even) ;
151  double Iderdrxy = ((k==kkmax-1) || (k==0)) ? 0 :multipoles_sym (k+1, j, OUTER_BC, (*gamma.der_t)(1,2)(dom).der_r(), passage_even) ;
152  double Iderdryy = ((k==kkmax-1) || (k==0)) ? 0 :multipoles_sym (k+1, j, OUTER_BC, (*gamma.der_t)(2,2)(dom).der_r(), passage_even) ;
153  double Iderdrzz = ((k==kkmax-1) || (k==0)) ? 0 :multipoles_sym (k+1, j, OUTER_BC, (*gamma.der_t)(3,3)(dom).der_r(), passage_even) ;
154 
155  RdV1 = new Term_eq (dom, Rvaldrxx-2*Ivaldrxy-Rvaldryy , Rderdrxx-2*Iderdrxy-Rderdryy) ;
156  RdV2 = new Term_eq (dom, Rvaldrxx+2*Ivaldrxy-Rvaldryy , Rderdrxx+2*Iderdrxy-Rderdryy) ;
157  RdV3 = new Term_eq (dom, Rvaldrxx+Rvaldryy, Rderdrxx+Rderdryy) ;
158  RdV6 = new Term_eq (dom, Rvaldrzz, Rderdrzz) ;
159 
160  IdV1 = new Term_eq (dom, Ivaldrxx+2*Rvaldrxy-Ivaldryy , Iderdrxx+2*Rderdrxy-Iderdryy) ;
161  IdV2 = new Term_eq (dom, Ivaldrxx-2*Rvaldrxy-Ivaldryy , Iderdrxx-2*Rderdrxy-Iderdryy) ;
162  IdV3 = new Term_eq (dom, Ivaldrxx+Ivaldryy, Iderdrxx+Iderdryy) ;
163  IdV6 = new Term_eq (dom, Ivaldrzz, Iderdrzz) ;
164 
165 
166  }
167  else {
168 
169 
170  RdV1 = new Term_eq (dom, Rvaldrxx-2*Ivaldrxy-Rvaldryy) ;
171  RdV2 = new Term_eq (dom, Rvaldrxx+2*Ivaldrxy-Rvaldryy) ;
172  RdV3 = new Term_eq (dom, Rvaldrxx+Rvaldryy) ;
173  RdV6 = new Term_eq (dom, Rvaldrzz) ;
174 
175  IdV1 = new Term_eq (dom, Ivaldrxx+2*Rvaldrxy-Ivaldryy) ;
176  IdV2 = new Term_eq (dom, Ivaldrxx-2*Rvaldrxy-Ivaldryy) ;
177  IdV3 = new Term_eq (dom, Ivaldrxx+Ivaldryy) ;
178  IdV6 = new Term_eq (dom, Ivaldrzz) ;
179  }
180 
181 
182  Term_eq RA1 ( *RdV1 / (*dRsh[(mm+2)*nbrl+ll])) ;
183  Term_eq RA2 ( *RdV2 / (*dRsh[abs(mm-2)*nbrl+ll])) ;
184  Term_eq RA3 ( *RdV3 / (*dRsh[mm*nbrl+ll])) ;
185  Term_eq RA6 ( *RdV6 / (*dRsh[mm*nbrl+ll])) ;
186 
187  Term_eq IA1 ( *IdV1 / (*dIsh[(mm+2)*nbrl+ll])) ;
188  Term_eq IA2 ( *IdV2 / (*dIsh[abs(mm-2)*nbrl+ll])) ;
189  Term_eq IA3 ( *IdV3 / (*dIsh[mm*nbrl+ll])) ;
190  Term_eq IA6 ( *IdV6 / (*dIsh[mm*nbrl+ll])) ;
191 
192  // Imaginary and real part of the eighenvectors
193  Term_eq Rxx (0.25*RA1*(*Rsh[(mm+2)*nbrl+ll]) + 0.25*RA2*(*Rsh[abs(mm-2)*nbrl+ll])
194  + 0.5*RA3*(*Rsh[mm*nbrl+ll])) ;
195 
196  Term_eq Ixx (0.25*IA1*(*Ish[(mm+2)*nbrl+ll]) + 0.25*IA2*(*Ish[abs(mm-2)*nbrl+ll])
197  + 0.5*IA3*(*Ish[mm*nbrl+ll])) ;
198 
199  Term_eq Rxy (0.25*IA1*(*Ish[(mm+2)*nbrl+ll]) - 0.25*IA2*(*Ish[abs(mm-2)*nbrl+ll])) ;
200 
201  Term_eq Ixy (-0.25*RA1*(*Rsh[(mm+2)*nbrl+ll]) + 0.25*RA2*(*Rsh[abs(mm-2)*nbrl+ll])) ;
202 
203  Term_eq Ryy (-0.25*RA1*(*Rsh[(mm+2)*nbrl+ll]) - 0.25*RA2*(*Rsh[abs(mm-2)*nbrl+ll])
204  + 0.5*RA3*(*Rsh[mm*nbrl+ll])) ;
205 
206  Term_eq Iyy (-0.25*IA1*(*Ish[(mm+2)*nbrl+ll]) - 0.25*IA2*(*Ish[abs(mm-2)*nbrl+ll])
207  + 0.5*IA3*(*Ish[mm*nbrl+ll])) ;
208 
209  Term_eq Rzz (RA6*(*Rsh[mm*nbrl+ll])) ;
210 
211  Term_eq Izz (IA6*(*Ish[mm*nbrl+ll])) ;
212 
213 
214 
215  // Put in the right component :
216  posylm.set(0) = 0 ;
217 
218  // Loop on theta for the matrix part :
219  for (int inds=0 ; inds<nbr_coefs(1) ; inds++) {
220 
221  posylm.set(1) = inds ;
222 
223  // Parts in cosines
224  valres.set(1,1).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Rxx.val_d) ;
225  valres.set(1,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Rxy.val_d) ;
226  valres.set(2,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Ryy.val_d) ;
227  valres.set(3,3).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Rzz.val_d) ;
228 
229  if (doder) {
230  derres.set(1,1).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Rxx.der_d) ;
231  derres.set(1,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Rxy.der_d) ;
232  derres.set(2,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Ryy.der_d) ;
233  derres.set(3,3).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Rzz.der_d) ;
234  }
235 
236  // Parts in sines
237  if ((k!=kkmax-1) && (k!=0)) {
238  posylm.set(2) ++ ;
239  valres.set(1,1).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Ixx.val_d) ;
240  valres.set(1,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Ixy.val_d) ;
241  valres.set(2,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Iyy.val_d) ;
242  valres.set(3,3).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Izz.val_d) ;
243 
244 
245  if (doder) {
246  derres.set(1,1).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Ixx.der_d) ;
247  derres.set(1,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Ixy.der_d) ;
248  derres.set(2,2).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Iyy.der_d) ;
249  derres.set(3,3).set_domain(dom).set_coef(posylm) += inv_even(mm, j, inds) * (*Izz.der_d) ;
250  }
251  posylm.set(2) -- ;
252  }
253  }
254 
255  delete RdV1 ;
256  delete RdV2 ;
257  delete RdV3 ;
258  delete RdV6 ;
259 
260  delete IdV1 ;
261  delete IdV2 ;
262  delete IdV3 ;
263  delete IdV6 ;
264  }
265  }
266 
267  // Antisymetric part :
268  // Loop on phi :
269  for (int k=0 ; k<kkmax ; k+=2)
270  if (k!=1) {
271 
272  posylm.set(2) = k ;
273 
274  int mm = int(k/2) ;
275 
276  // loop on theta
277  int jmin = (mm%2==0) ? int(mm/2) : int((mm+1)/2) ;
278  int jmax = jjmax-1 ;
279  for (int j=jmin ; j<jmax ; j++) {
280 
281  int ll = (mm%2==0) ? 2*j+1 : 2*j ;
282 
283  // Radial derivatives
284  double Rvaldrxz = multipoles_asym (k, j, OUTER_BC, (*gamma.val_t)(1,3)(dom).der_r(), passage_odd) ;
285  double Rvaldryz = multipoles_asym (k, j, OUTER_BC, (*gamma.val_t)(2,3)(dom).der_r(), passage_odd) ;
286 
287  double Ivaldrxz = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_asym (k+1, j, OUTER_BC, (*gamma.val_t)(1,3)(dom).der_r(), passage_odd) ;
288  double Ivaldryz = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_asym (k+1, j, OUTER_BC, (*gamma.val_t)(2,3)(dom).der_r(), passage_odd) ;
289 
290  Term_eq* RdV4 ;
291  Term_eq* RdV5 ;
292  Term_eq* IdV4 ;
293  Term_eq* IdV5 ;
294 
295  if (doder) {
296 
297  double Rderdrxz = multipoles_asym (k, j, OUTER_BC, (*gamma.der_t)(1,3)(dom).der_r(), passage_odd) ;
298  double Rderdryz = multipoles_asym (k, j, OUTER_BC, (*gamma.der_t)(2,3)(dom).der_r(), passage_odd) ;
299 
300  double Iderdrxz = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_asym (k+1, j, OUTER_BC, (*gamma.der_t)(1,3)(dom).der_r(), passage_odd) ;
301  double Iderdryz = ((k==kkmax-1) || (k==0)) ? 0 : multipoles_asym (k+1, j, OUTER_BC, (*gamma.der_t)(2,3)(dom).der_r(), passage_odd) ;
302 
303  RdV4 = new Term_eq (dom, Rvaldrxz - Ivaldryz, Rderdrxz - Iderdryz) ;
304  RdV5 = new Term_eq (dom, Rvaldrxz + Ivaldryz, Rderdrxz + Iderdryz) ;
305 
306  IdV4 = new Term_eq (dom, Ivaldrxz + Rvaldryz, Iderdrxz + Rderdryz) ;
307  IdV5 = new Term_eq (dom, Ivaldrxz - Rvaldryz, Iderdrxz - Rderdryz) ;
308  }
309  else {
310  RdV4 = new Term_eq (dom, Rvaldrxz - Ivaldryz) ;
311  RdV5 = new Term_eq (dom, Rvaldrxz + Ivaldryz) ;
312 
313  IdV4 = new Term_eq (dom, Ivaldrxz + Rvaldryz) ;
314  IdV5 = new Term_eq (dom, Ivaldrxz - Rvaldryz) ;
315  }
316 
317  Term_eq RA4 ( *RdV4 / (*dRsh[(mm+1)*nbrl+ll])) ;
318  Term_eq RA5 ( *RdV5 / (*dRsh[abs(mm-1)*nbrl+ll])) ;
319 
320  Term_eq IA4 ( *IdV4 / (*dIsh[(mm+1)*nbrl+ll])) ;
321  Term_eq IA5 ( *IdV5 / (*dIsh[abs(mm-1)*nbrl+ll])) ;
322 
323  // Case m==0 is different
324  // int signe = (mm==0) ? -1 : 1 ;
325 
326  // Imaginary and real part of the eighenvectors
327  Term_eq Rxz (0.5*RA4*(*Rsh[(mm+1)*nbrl+ll]) + 0.5*RA5*(*Rsh[abs(mm-1)*nbrl+ll])) ;
328  Term_eq Ixz (0.5*IA4*(*Ish[(mm+1)*nbrl+ll]) + 0.5*IA5*(*Ish[abs(mm-1)*nbrl+ll])) ;
329 
330  Term_eq Ryz (0.5*IA4*(*Ish[(mm+1)*nbrl+ll]) - 0.5*IA5*(*Ish[abs(mm-1)*nbrl+ll])) ;
331  Term_eq Iyz (-0.5*RA4*(*Rsh[(mm+1)*nbrl+ll]) + 0.5*RA5*(*Rsh[abs(mm-1)*nbrl+ll])) ;
332 
333  // Put in the right component :
334  posylm.set(0) = 0 ;
335 
336  // Loop on theta for the matrix part :
337 
338  for (int inds=0 ; inds<nbr_coefs(1) ; inds++) {
339 
340  posylm.set(1) = inds ;
341 
342  // Parts in cosines
343  valres.set(1,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Rxz.val_d) ;
344  valres.set(2,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Ryz.val_d) ;
345 
346  if (doder) {
347  derres.set(1,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Rxz.der_d) ;
348  derres.set(2,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Ryz.der_d) ;
349  }
350 
351  // Parts in sines
352  if ((k!=kkmax-1) && (k!=0)) {
353  posylm.set(2) ++ ;
354  valres.set(1,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Ixz.val_d) ;
355  valres.set(2,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Iyz.val_d) ;
356 
357  if (doder) {
358  derres.set(1,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Ixz.der_d) ;
359  derres.set(2,3).set_domain(dom).set_coef(posylm) += inv_odd(mm, j, inds) * (*Iyz.der_d) ;
360  }
361  posylm.set(2) -- ;
362  }
363  }
364 
365  delete RdV4 ;
366  delete RdV5 ;
367  delete IdV4 ;
368  delete IdV5 ;
369  }
370  }
371 
372  // Delete the shs
373  for (int i=0 ; i<nbrm*nbrl ; i++) {
374  delete Rsh[i] ;
375  delete Ish[i] ;
376  delete dRsh[i] ;
377  delete dIsh[i] ;
378  }
379  delete [] Rsh ;
380  delete [] Ish ;
381  delete [] dRsh ;
382  delete [] dIsh ;
383 
384  if (doder)
385  return Term_eq (dom, valres, derres) ;
386  else
387  return Term_eq (dom, valres) ;
388 }}
Kadath::Base_tensor::get_basis
int get_basis(int nd) const
Read only the basis in a given domain.
Definition: base_tensor.hpp:93
Kadath::Domain_shell::multipoles_asym
virtual double multipoles_asym(int, int, int, const Val_domain &, const Array< double > &) const
Extraction of a given multipole, at some boundary, for a anti-symmetric scalar function.
Definition: multipoles_valdomain.cpp:76
Kadath::Domain_shell::multipoles_sym
virtual double multipoles_sym(int, int, int, const Val_domain &, const Array< double > &) const
Extraction of a given multipole, at some boundary, for a symmetric scalar function.
Definition: multipoles_valdomain.cpp:38
Kadath::Domain_shell::bc_waves
Term_eq bc_waves(const Term_eq &gamma, const Term_eq &omega) const
Gives an matching of the spatial metric, based on homogeneous solutions of outgoing waves.
Definition: bc_waves.cpp:33
Kadath::Domain::nbr_coefs
Dim_array nbr_coefs
Number of coefficients.
Definition: space.hpp:66
Kadath::Domain::get_radius
Val_domain const & get_radius() const
Returns the generalized radius.
Definition: space.hpp:1465
Kadath::Domain::nbr_points
Dim_array nbr_points
Number of colocation points.
Definition: space.hpp:65
Kadath::Index
Class that gives the position inside a multi-dimensional Array.
Definition: index.hpp:38
Kadath::Index::set
int & set(int i)
Read/write of the position in a given dimension.
Definition: index.hpp:72
Kadath::Index::inc
bool inc(int increm, int var=0)
Increments the position of the Index.
Definition: index.hpp:99
Kadath::Scalar::set_domain
Val_domain & set_domain(int)
Read/write of a particular Val_domain.
Definition: scalar.hpp:555
Kadath::Tensor
Tensor handling.
Definition: tensor.hpp:149
Kadath::Tensor::std_base
virtual void std_base()
Sets the standard spectal bases of decomposition for each component.
Definition: tensor.cpp:385
Kadath::Tensor::set
Scalar & set(const Array< int > &ind)
Returns the value of a component (read/write version).
Definition: tensor_impl.hpp:91
Kadath::Tensor::get_basis
const Base_tensor & get_basis() const
Returns the vectorial basis (triad) on which the components are defined.
Definition: tensor.hpp:504
Kadath::Tensor::get_n_comp
int get_n_comp() const
Returns the number of stored components.
Definition: tensor.hpp:514
Kadath::Tensor::indices
virtual Array< int > indices(int pos) const
Gives the values of the indices corresponding to a location in the array used for storage of the comp...
Definition: tensor.hpp:484
Kadath::Tensor::get_valence
int get_valence() const
Returns the valence.
Definition: tensor.hpp:509
Kadath::Term_eq
This class is intended to describe the manage objects appearing in the equations.
Definition: term_eq.hpp:62
Kadath::Term_eq::der_t
Tensor * der_t
Pointer on the variation, if the Term_eq is a Tensor.
Definition: term_eq.hpp:69
Kadath::Term_eq::type_data
const int type_data
Flag describing the type of data :
Definition: term_eq.hpp:75
Kadath::Term_eq::val_d
double * val_d
Pointer on the value, if the Term_eq is a double.
Definition: term_eq.hpp:66
Kadath::Term_eq::get_dom
int get_dom() const
Definition: term_eq.hpp:135
Kadath::Term_eq::der_d
double * der_d
Pointer on the variation if the Term_eq is a double.
Definition: term_eq.hpp:67
Kadath::Term_eq::val_t
Tensor * val_t
Pointer on the value, if the Term_eq is a Tensor.
Definition: term_eq.hpp:68
Kadath::Val_domain::set_coef
double & set_coef(const Index &pos)
Read/write the value of the field in the coefficient space.
Definition: val_domain.cpp:177
Kadath::Val_domain::allocate_coef
void allocate_coef()
Allocates the values in the coefficient space and destroys the values in the configuration space.
Definition: val_domain.cpp:216