Memosa-FVM  0.2
Quadrature.h
Go to the documentation of this file.
1 // This file os part of FVM
2 // Copyright (c) 2012 FVM Authors
3 // See LICENSE file for terms.
4 
5 #ifndef _QUADRATURE_H_
6 #define _QUADRATURE_H_
7 
8 #include <math.h>
9 #include "Array.h"
10 #include "Array2D.h"
11 #include "Vector.h"
12 #include <stdio.h>
13 
14 template<class T>
23 class Quadrature
24 {
25  public:
30  typedef Array<T> TArray;
31  typedef Array2D<T> TArray2D;
32  typedef Quadrature<T> TQuad;
37  TArray* cxPtr;
42  TArray* cyPtr;
47  TArray* czPtr;
52  TArray* dcxyzPtr;
53  TArray2D* malphaBGKPtr;
54  TArray2D* malphaESBGKPtr;
55 
56  int getDirCount() const {return N123;}
57  int getNVCount()const {return _NV;}
58  int getNthetaCount()const {return _Ntheta;}
59  int getNphiCount()const {return _Nphi;}
60  T get_dcx()const{return _dcx;}
61  T get_dcy()const{return _dcy;}
62  T get_dcz() const{return _dcz;}
63  TArray& get_absci1()const{return *absci1Ptr;}
64  TArray& get_absci2()const{return *absci2Ptr;}
65  TArray& get_absci3()const{return *absci3Ptr;}
66  TArray& get_cx()const{return *cxPtr;}
67  TArray& get_cy()const{return *cyPtr;}
68  TArray& get_cz()const{return *czPtr;}
69  TArray& get_wts1()const{return *wts1Ptr;}
70  TArray& get_wts2()const{return *wts2Ptr;}
71  TArray& get_wts3()const{return *wts3Ptr;}
72  TArray& get_dcxyz()const{return *dcxyzPtr;}
73 
74  // bool printCx;
83 Quadrature(int N1, int N2, int N3, double clim, double T2)
84  {
85  absci1Ptr=new TArray(N1);
86  TArray & absci1= *absci1Ptr;
87  absci2Ptr=new TArray(N2);
88  TArray & absci2= *absci2Ptr;
89  absci3Ptr=new TArray(N3);
90  TArray & absci3= *absci3Ptr;
91  wts1Ptr=new TArray(N1);
92  TArray & wts1= *wts1Ptr;
93  wts2Ptr=new TArray(N2);
94  TArray & wts2= *wts2Ptr;
95  wts3Ptr=new TArray(N3);
96  TArray & wts3= *wts3Ptr;
101  N123=N1*N2*N3;
102  // BGK and ESBGK Equilibrium distribution functions
103  malphaBGKPtr=new TArray2D(N123,5);
104  TArray2D & malphaBGK= *malphaBGKPtr;
105 
106  malphaESBGKPtr=new TArray2D(N123,10);
107  TArray2D & malphaESBGK= *malphaESBGKPtr;
108 
109  _NV=N1;_Ntheta=N2;_Nphi=N3;
110 
111 
112  cxPtr= new TArray(N123); cyPtr= new TArray(N123); czPtr= new TArray(N123);
113  dcxyzPtr= new TArray(N123);
114  TArray & cx= *cxPtr;TArray & cy= *cyPtr;TArray & cz= *czPtr;
115  TArray & dcxyz= *dcxyzPtr;
116  //Array<Vector<double,3>> * cxyz;// Cxyz Vector pointer. /* Pointer to discrete velocity in xyz-directions. cxyz= (cx,cy,cz)*/
117  T cxmin,cxmax,cymin,cymax,czmin,czmax;
118  T dcx,dcy,dcz;
119  //const T clim (5.5);
120  cxmin=-clim*sqrt(0.5*T2);cxmax=clim*sqrt(0.5*T2);
121  cymin=-clim*sqrt(0.5*T2);cymax=clim*sqrt(0.5*T2);
122  czmin=-clim*sqrt(0.5*T2);czmax=clim*sqrt(0.5*T2);
123  dcx=(cxmax-cxmin)/(N1-1.0);
124  dcy=(cymax-cymin)/(N2-1.0);
125  dcz=(czmax-czmin)/(N3-1.0);
126 
127  _dcx=dcx;_dcy=dcy;_dcz=dcz;
128  absci1[0]=cxmin;absci2[0]=cymin; absci3[0]=czmin;
129  wts1[0]=dcx; wts2[0]=dcy; wts3[0]=dcz;
130  for (int j3=1;j3<N3;j3++){
131  absci3[j3]=absci3[j3-1]+dcz;
132  wts3[j3]=dcz;
133  //printf("%4.2f", absci3[j3]);
134  }
135  //printf("\n");
136  for (int j2=1;j2<N2;j2++){
137  absci2[j2]=absci2[j2-1]+dcy;
138  wts2[j2]=dcy;
139  //printf("%4.2f", absci2[j2]);
140  }
141  //printf("\n");
142  for (int j1=1;j1<N1;j1++){
143  absci1[j1]=absci1[j1-1]+dcx;
144  wts1[j1]=dcx;
145  //printf("%4.2f", absci1[j1]);
146  }
147  //printf("\n");
148 
149  int j;
150  j=0;
151  for(int j1=0;j1<N1;j1++){
152  for (int j2=0;j2<N2;j2++){
153  for (int j3=0;j3<N3;j3++){
154  cx[j]=absci1[j1];
155  cy[j]=absci2[j2];
156  cz[j]=absci3[j3];
157  dcxyz[j]=wts1[j1]*wts2[j2]*wts3[j3];
158 
159  malphaBGK(j,0)=1.0;
160  malphaBGK(j,1)=cx[j];
161  malphaBGK(j,2)=cy[j];
162  malphaBGK(j,3)=cz[j];
163  malphaBGK(j,4)=pow(cx[j],2)+pow(cy[j],2)+pow(cz[j],2);
164 
165  malphaESBGK(j,0)=1.0;
166  malphaESBGK(j,1)=cx[j];
167  malphaESBGK(j,2)=cy[j];
168  malphaESBGK(j,3)=cz[j];
169  malphaESBGK(j,4)=pow(cx[j],2);
170  malphaESBGK(j,5)=pow(cy[j],2);
171  malphaESBGK(j,6)=pow(cz[j],2);
172  malphaESBGK(j,7)=cx[j]*cy[j];
173  malphaESBGK(j,8)=cy[j]*cz[j];
174  malphaESBGK(j,9)=cz[j]*cx[j];
175 
176  j++;
177  }
178  }
179  }
180 
181  /*
182  FILE * pFile;
183  pFile = fopen ("cxyz.txt","w");
184  for(int j=0;j<N123;j++){
185  fprintf(pFile,"%12.6f %12.6f %12.6f %12.6f \n", cx[j],cy[j],cz[j],dcxyz[j]);}
186  fclose (pFile);
187  */
188  }
189 
200  Quadrature(int option_ur, int Nr, int option_theta, int n_int, int option_phi, int nphi_int)
201  {
202  int N1,N2,N3;
203  if(option_ur ==0){
204  N1=Nr;}
205  else{N1=option_ur;}
206  if(option_theta ==0){
207  N2=n_int;}
208  else{N2=3*n_int;}
209  if(option_phi ==0){
210  N3=nphi_int;}
211  else{N3=3*nphi_int+1;}
212  _NV=N1;_Ntheta=N2;_Nphi=N3;
213  absci1Ptr=new TArray(N1);
214  TArray & absci1= *absci1Ptr;
215  absci2Ptr=new TArray(N2);
216  TArray & absci2= *absci2Ptr;
217  absci3Ptr=new TArray(N3);
218  TArray & absci3= *absci3Ptr;
219  wts1Ptr=new TArray(N1);
220  TArray & wts1= *wts1Ptr;
221  wts2Ptr=new TArray(N2);
222  TArray & wts2= *wts2Ptr;
223  wts3Ptr=new TArray(N3);
224  TArray & wts3= *wts3Ptr;
225 
226  N123=N1*N2*N3;
227  cxPtr= new TArray(N123); cyPtr= new TArray(N123); czPtr= new TArray(N123);
228  dcxyzPtr= new TArray(N123);
229  TArray & cx= *cxPtr;TArray & cy= *cyPtr;TArray & cz= *czPtr;
230  TArray & dcxyz= *dcxyzPtr;
231 
232  // BGK and ESBGK Equilibrium distribution functions
233  malphaBGKPtr=new TArray2D(N123,5);
234  TArray2D & malphaBGK= *malphaBGKPtr;
235 
236  malphaESBGKPtr=new TArray2D(N123,10);
237  TArray2D & malphaESBGK= *malphaESBGKPtr;
238  _NV=N1;_Ntheta=N2;_Nphi=N3;
239 
240  switch(option_ur){
241  int j1;
242  case 0: // constant difference for Ur
243  {double dh1=sqrt(3.0)*3.889/(N1); //neglect ur=.0;
244  for (j1=0;j1<N1;j1++){
245  absci1[j1]=(j1+1)*dh1;
246  wts1[j1]=dh1*pow(absci1[j1],2.0);
247  }
248  }break;
249  case 2:{
250  absci1[0]=0.7539869079898871;
251  absci1[1]=0.1734055298879163E+1;
252  wts1[0]=0.2738413467266824;
253  wts1[1]=0.1692721159996965;
254  for (j1=0;j1<N1;j1++){
255  wts1[j1]=wts1[j1]*exp(pow(absci1[j1],2.0));
256  }
257  }break;
258  case 4: //4-gaussian for y^2*exp(-y^2)
259  { absci1[0]=0.4238628193900528;
260  absci1[1]=0.1014332104566760E+1;
261  absci1[2]=0.1742437375162050E+1;
262  absci1[3]=0.2639813333635586E+1;
263  wts1[0]=0.7649092266787873E-1;
264  wts1[1]= 0.2435439494642453;
265  wts1[2]= 0.1162953035510695;
266  wts1[3]= 0.6783287043185401E-2;
267  for (j1=0;j1<N1;j1++){
268  wts1[j1]=wts1[j1]*exp(pow(absci1[j1],2.0));
269  }
270  }break;
271  case 8: //8-gaussian for y^2*exp(-y^2)
272  { absci1[0]=0.1990000637984294;
273  absci1[1]=0.5059526450205794;
274  absci1[2]=0.9041682182040568;
275  absci1[3]=0.1372615723971598E+1;
276  absci1[4]=0.1900969572329702E+1;
277  absci1[5]=0.2490479841967435E+1;
278  absci1[6]=0.3158780677105240E+1;
279  absci1[7]=0.3966720403265353E+1;
280 
281  wts1[0]=0.9599144336400067E-2;
282  wts1[1]=0.7072944976303661E-1;
283  wts1[2]=0.157366887003943;
284  wts1[3]=0.1429322724003870;
285  wts1[4]=0.5431444004253597E-1;
286  wts1[5]=0.7835224153141577E-2;
287  wts1[6]=0.3338952597020048E-3;
288  wts1[7]=0.2149767232664775E-5;
289  for(j1=0;j1<N1;j1++){
290  wts1[j1]=wts1[j1]*exp(pow(absci1[j1],2.0));
291  }
292  }break;
293  case 16: //weights & absci for y^2 exp(-y^2)
294  { absci1[0]= 0.8174913389984520E-1;
295  absci1[1]=0.2154761962759740;
296  absci1[2]=0.4003530517087630;
297  absci1[3]=0.6298538771405607;
298  absci1[4]=0.8976124329697087;
299  absci1[5]=0.1198149260240153E+1;
300  absci1[6]=0.1527188184719962E+1;
301  absci1[7]=0.1881745606015598E+1;
302  absci1[8]=0.2260132964654088E+1;
303  absci1[9]=0.2661980315279350E+1;
304  absci1[10]=0.3088376381635592E+1;
305  absci1[11]=0.3542256017930265E+1;
306  absci1[12]=0.4029312272760483E+1;
307  absci1[13]=0.4560203031431090E+1;
308  absci1[14]=0.5156826768007481E+1;
309  absci1[15]=0.58781144889155572E+1;
310 
311  wts1[0]=0.7050727473210895E-3;
312  wts1[1]=0.7107111654073120E-2;
313  wts1[2]=0.2844188515941899E-1;
314  wts1[3]=0.6660235171398239E-1;
315  wts1[4]=0.1025785712747278;
316  wts1[5]=0.1077502032531791;
317  wts1[6]=0.7747156370638879E-1;
318  wts1[7]=0.3763106373385135E-1;
319  wts1[8]=0.1204873635560290E-1;
320  wts1[9]=0.2453208613776865E-2;
321  wts1[10]=0.3020309847850189E-3;
322  wts1[11]=0.2092121075871870E-4;
323  wts1[12]=0.7314637349679360E-6;
324  wts1[13]=0.1080646863902574E-7;
325  wts1[14]=0.4828081616137754E-10;
326  wts1[15]=0.2840126937112534E-13;
327  for (j1=0;j1<N1;j1++){
328  wts1[j1]=wts1[j1]*exp(pow(absci1[j1],2.0));
329  }
330  }break;
331  }
332  switch(option_theta){
333 
334  case 0: //constant difference for Theta
335  { double pi=3.14159;
336  double dh2=2*pi/(N2); //number of intervals=no. of ordinates
337  for (int j2=0;j2<N2;j2++){
338  absci2[j2]= dh2*j2+dh2/2.0; //no points on axes
339  wts2[j2]=dh2;
340  //cout<<"j2= "<<j2<<" absci2= "<<absci2[j2]<<endl;
341  }
342  }break;
343  case 1: //three-eights for theta
344  { double pi=3.14159;
345  double h=pi; //the range of quadrature from [-h,h];
346  double dh=2*h/n_int; //anglular increment
347  for (int i=0;i<n_int;i++){
348  absci2[3*i]=-h+dh/3.0*(3.0*i);
349  absci2[3*i+1]=-h+dh/3.0*(3.0*i+1);
350  absci2[3*i+2]=-h+dh/3.0*(3.0*i+2);
351  if (i == 0){
352  wts2[i]=dh/4.0; //here 0 -pi and pi are the same number
353  }
354  else {
355  wts2[3*i]=dh/4.0;
356  }
357  wts2[3*i+1]=dh/8.0*3.0;
358  wts2[3*i+2]=dh/8.0*3.0;
359  }
360  //absci2(N2)=h;wts2(N2)=dh/8.0;
361  }break;
362  }
363 
364  switch(option_phi){
365 
366  case 0: //constant difference for Phi
367  {
368  double pi=3.14159;
369  //double dh3=pi/(N3-1); //number of intervals < number of ordinates (old)
370  double dh3=pi/N3;
371  for (int j3=0;j3<N3;j3++){
372  //absci3[j3]= dh3*(j3); //old
373  absci3[j3]= dh3*(j3+0.5); //no points on axes
374  wts3[j3]=dh3*sin(absci3[j3]);
375 
376  }
377  }break;
378  case 1: //three-eights for phi
379  { double pi=3.14159;
380  double dh_phi=pi/nphi_int; //anglular increment
381  for (int i=0;i<nphi_int;i++){
382  absci3[3*i]=dh_phi/3.0*(3.0*i);
383  absci3[3*i+1]=dh_phi/3.0*(3.0*i+1);
384  absci3[3*i+2]=dh_phi/3.0*(3.0*i+2);
385  if (i == 0){
386  wts3[i]=dh_phi/8.0*sin(absci3[i]);
387  }
388  else{
389  wts3[3*i]=dh_phi/4.0*sin(absci3[3*i]);
390  }
391  wts3[3*i+1]=dh_phi/8.0*3.0*sin(absci3[3*i+1]);
392  wts3[3*i+2]=dh_phi/8.0*3.0*sin(absci3[3*i+2]);
393  }
394  absci3[N3-1]=pi;
395  wts3[N3-1]=dh_phi/8.0*sin(absci3[N3-1]);
396  }break;
397  }
398  int j;
399  j=0;
400  for (int j1=0;j1<N1;j1++){ //Ur
401  for (int j2=0;j2<N2;j2++){ //theta
402  for (int j3=0;j3<N3;j3++){ //phi
403  cx[j]=absci1[j1]*cos(absci2[j2])*sin(absci3[j3]); //cx=Ur*cos(theta)*sin(phi)
404  cy[j]=absci1[j1]*sin(absci2[j2])*sin(absci3[j3]); //cy=Ur*sin(theta)*sin(phi)
405  cz[j]=absci1[j1]*cos(absci3[j3]); //Ur*cos(phi)
406  dcxyz[j]=wts1[j1]*wts2[j2]*wts3[j3];
407  malphaBGK(j,0)=1.0;
408  malphaBGK(j,1)=cx[j];
409  malphaBGK(j,2)=cy[j];
410  malphaBGK(j,3)=cz[j];
411  malphaBGK(j,4)=pow(cx[j],2)+pow(cy[j],2)+pow(cz[j],2);
412 
413  malphaESBGK(j,0)=1.0;
414  malphaESBGK(j,1)=cx[j];
415  malphaESBGK(j,2)=cy[j];
416  malphaESBGK(j,3)=cz[j];
417  malphaESBGK(j,4)=pow(cx[j],2);
418  malphaESBGK(j,5)=pow(cy[j],2);
419  malphaESBGK(j,6)=pow(cz[j],2);
420  malphaESBGK(j,7)=cx[j]*cy[j];
421  malphaESBGK(j,8)=cy[j]*cz[j];
422  malphaESBGK(j,9)=cz[j]*cx[j];
423 
424 
425  j++;
426  }
427  }
428  }
429  // for (int j=10;j<21;j++){cout << j <<" : "<<cx[j] << " , " << dcxyz[j] <<endl; };cout<<endl;
430 
431  FILE * pFile;
432  pFile = fopen ("cxyz.txt","w");
433  for(int j=0;j<N123;j++){
434  fprintf(pFile,"%d %12.6E %12.6E %12.6E %12.6E \n", j,cx[j],cy[j],cz[j],dcxyz[j]);}
435  fclose (pFile);
436 
437  }
438 
439  Quadrature()
440  {}
441 
442  void CopyQuad(TQuad& copyFromQuad)
443  {
444  N123=copyFromQuad.getDirCount();
445  _NV=copyFromQuad.getNVCount();
446  _Ntheta=copyFromQuad.getNthetaCount();
447  _Nphi=copyFromQuad.getNphiCount();
448  _dcx=copyFromQuad.get_dcx();
449  _dcy=copyFromQuad.get_dcy();
450  _dcz=copyFromQuad.get_dcz();
451 
452  absci1Ptr=new TArray(_NV);
453  TArray& absci1= *absci1Ptr;
454  absci2Ptr=new TArray(_Ntheta);
455  TArray& absci2= *absci2Ptr;
456  absci3Ptr=new TArray(_Nphi);
457  TArray& absci3= *absci3Ptr;
458 
459  cxPtr=new TArray(N123);
460  TArray& cx= *cxPtr;
461  cyPtr=new TArray(N123);
462  TArray& cy= *cyPtr;
463  czPtr=new TArray(N123);
464  TArray& cz= *czPtr;
465 
466  wts1Ptr=new TArray(_NV);
467  TArray& wts1= *wts1Ptr;
468  wts2Ptr=new TArray(_Ntheta);
469  TArray& wts2= *wts2Ptr;
470  wts3Ptr=new TArray(_Nphi);
471  TArray& wts3= *wts3Ptr;
472 
473  dcxyzPtr=new TArray(N123);
474  TArray& dcxyz= *dcxyzPtr;
475 
476  malphaBGKPtr=new TArray2D(N123,5);
477  TArray2D& malphaBGK= *malphaBGKPtr;
478  malphaESBGKPtr=new TArray2D(N123,10);
479  TArray2D& malphaESBGK= *malphaESBGKPtr;
480 
481  absci1=copyFromQuad.get_absci1();
482  absci2=copyFromQuad.get_absci2();
483  absci3=copyFromQuad.get_absci3();
484 
485  cx=copyFromQuad.get_cx();
486  cy=copyFromQuad.get_cy();
487  cz=copyFromQuad.get_cz();
488 
489  wts1=copyFromQuad.get_wts1();
490  wts2=copyFromQuad.get_wts2();
491  wts3=copyFromQuad.get_wts3();
492 
493  dcxyz=copyFromQuad.get_dcxyz();
494 
495  int j;
496  j=0;
497  for(int j1=0;j1<_NV;j1++){
498  for (int j2=0;j2<_Ntheta;j2++){
499  for (int j3=0;j3<_Nphi;j3++){
500  malphaBGK(j,0)=1.0;
501  malphaBGK(j,1)=cx[j];
502  malphaBGK(j,2)=cy[j];
503  malphaBGK(j,3)=cz[j];
504  malphaBGK(j,4)=pow(cx[j],2)+pow(cy[j],2)+pow(cz[j],2);
505 
506  malphaESBGK(j,0)=1.0;
507  malphaESBGK(j,1)=cx[j];
508  malphaESBGK(j,2)=cy[j];
509  malphaESBGK(j,3)=cz[j];
510  malphaESBGK(j,4)=pow(cx[j],2);
511  malphaESBGK(j,5)=pow(cy[j],2);
512  malphaESBGK(j,6)=pow(cz[j],2);
513  malphaESBGK(j,7)=cx[j]*cy[j];
514  malphaESBGK(j,8)=cy[j]*cz[j];
515  malphaESBGK(j,9)=cz[j]*cx[j];
516 
517  j++;
518  }
519  }
520  }
521  }
522 
523  virtual ~Quadrature() {}
524 
525  private:
526  TArray* absci1Ptr;
527  TArray* absci2Ptr;
528  TArray* absci3Ptr;
529  TArray* wts1Ptr;
530  TArray* wts2Ptr;
531  TArray* wts3Ptr;
532  int N123;
533  int _NV;
534  int _Ntheta;
535  int _Nphi;
536  T _dcx;
537  T _dcy;
538  T _dcz;
539 };
540 
541 
542 #endif
Quadrature::absci1Ptr
TArray * absci1Ptr
Definition: Quadrature.h:526
Quadrature::malphaESBGKPtr
TArray2D * malphaESBGKPtr
Definition: Quadrature.h:54
Quadrature::CopyQuad
void CopyQuad(TQuad &copyFromQuad)
Definition: Quadrature.h:442
Quadrature::get_dcy
T get_dcy() const
Definition: Quadrature.h:61
Quadrature::getNVCount
int getNVCount() const
Definition: Quadrature.h:57
Quadrature::getNphiCount
int getNphiCount() const
Definition: Quadrature.h:59
Quadrature::~Quadrature
virtual ~Quadrature()
Definition: Quadrature.h:523
Quadrature::get_dcxyz
TArray & get_dcxyz() const
Definition: Quadrature.h:72
Quadrature::TArray
Array< T > TArray
Definition: Quadrature.h:30
Quadrature::malphaBGKPtr
TArray2D * malphaBGKPtr
Definition: Quadrature.h:53
Quadrature::cyPtr
TArray * cyPtr
Definition: Quadrature.h:42
Quadrature::Quadrature
Quadrature(int option_ur, int Nr, int option_theta, int n_int, int option_phi, int nphi_int)
Definition: Quadrature.h:200
Quadrature::getDirCount
int getDirCount() const
Definition: Quadrature.h:56
Quadrature::dcxyzPtr
TArray * dcxyzPtr
Definition: Quadrature.h:52
Quadrature::czPtr
TArray * czPtr
Definition: Quadrature.h:47
Quadrature::Quadrature
Quadrature(int N1, int N2, int N3, double clim, double T2)
Definition: Quadrature.h:83
Quadrature::get_absci1
TArray & get_absci1() const
Definition: Quadrature.h:63
sqrt
Tangent sqrt(const Tangent &a)
Definition: Tangent.h:317
Quadrature::absci2Ptr
TArray * absci2Ptr
Definition: Quadrature.h:527
Quadrature::wts1Ptr
TArray * wts1Ptr
Definition: Quadrature.h:529
Quadrature::cxPtr
TArray * cxPtr
Definition: Quadrature.h:37
sin
Tangent sin(const Tangent &a)
Definition: Tangent.h:307
Quadrature::get_absci2
TArray & get_absci2() const
Definition: Quadrature.h:64
Quadrature::get_dcx
T get_dcx() const
Definition: Quadrature.h:60
Quadrature::get_absci3
TArray & get_absci3() const
Definition: Quadrature.h:65
Quadrature::absci3Ptr
TArray * absci3Ptr
Definition: Quadrature.h:528
Quadrature::TQuad
Quadrature< T > TQuad
Definition: Quadrature.h:32
Quadrature::wts2Ptr
TArray * wts2Ptr
Definition: Quadrature.h:530
Quadrature::get_wts2
TArray & get_wts2() const
Definition: Quadrature.h:70
Quadrature::get_wts3
TArray & get_wts3() const
Definition: Quadrature.h:71
Array
Definition: Array.h:14
Quadrature::TArray2D
Array2D< T > TArray2D
Definition: Quadrature.h:31
Quadrature::getNthetaCount
int getNthetaCount() const
Definition: Quadrature.h:58
Quadrature::wts3Ptr
TArray * wts3Ptr
Definition: Quadrature.h:531
Quadrature::get_wts1
TArray & get_wts1() const
Definition: Quadrature.h:69
Quadrature::get_cx
TArray & get_cx() const
Definition: Quadrature.h:66
Quadrature::get_dcz
T get_dcz() const
Definition: Quadrature.h:62
Quadrature::get_cy
TArray & get_cy() const
Definition: Quadrature.h:67
Quadrature::get_cz
TArray & get_cz() const
Definition: Quadrature.h:68