Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Nektar::LibUtilities::Kernel Class Reference

#include <kernel.h>

Collaboration diagram for Nektar::LibUtilities::Kernel:
Collaboration graph
[legend]

Public Member Functions

 Kernel ()
 The default constructor. More...
 
 Kernel (int order)
 
void UpdateKernelBspline ()
 The default destructor. More...
 
void UpdateKernelCoeffs ()
 This funciton updates the kernel coefficients. More...
 
void UpdateKernelBreaks (NekDouble h)
 This funciton updates the kernel breaks. More...
 
Array< TwoD, NekDoubleGetKernelBspline ()
 This funciton returns a 2D array representing the bspline of the appropriate order. More...
 
Array< OneD, NekDoubleGetKernelCoeffs ()
 This funciton returns a 1D array representing the kernel coefficients. More...
 
Array< OneD, NekDoubleGetKernelBreaks ()
 This funciton returns a 1D array representing the kernel breaks. More...
 
void UpdateKernelOrder (int order)
 This funciton sets the k_order variable. More...
 
void UpdateKernelNumOfCoeffs ()
 This funciton sets the k_ncoeffs variable. More...
 
void UpdateKernelWidth ()
 This funciton sets the kernel width size. More...
 
int GetKernelOrder ()
 This funciton returns the order of the kernel. More...
 
int GetKernelNumeOfCoeffs ()
 This funciton returns the number of kernel coefficients. More...
 
int GetKernelWidth ()
 This funciton returns the size of the kernel width. More...
 
void MoveKernelCenter (NekDouble x_value, Array< OneD, NekDouble > &outarray)
 This funciton moves the center of the kernel to the. More...
 
void FindMeshUnderKernel (Array< OneD, NekDouble > &inarray, NekDouble h, Array< OneD, NekDouble > &outarray)
 This funciton calculates the mesh breaks under the kernel support. More...
 
void EvaluateKernel (Array< OneD, NekDouble > inarray, NekDouble h, Array< OneD, NekDouble > &outarray)
 This funciton evaluates the kernel at input values. More...
 
void EvaluateBspline (Array< OneD, NekDouble > inarray, NekDouble h, NekDouble offset, Array< OneD, NekDouble > &outarray)
 This function evaluates the bspline at input values. More...
 
void Sort (Array< OneD, NekDouble > &inarray1, Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray)
 This funciton performs the ordered merge of. More...
 

Protected Member Functions

NekDouble EvaluateBsplinePoly (NekDouble x_value, int interval)
 This funciton evaluates the piecewise bspline polynomial. More...
 

Protected Attributes

int k_order
 
int k_ncoeffs
 
int k_width
 
NekDouble k_center
 
Array< TwoD, NekDoubleb_spline
 
Array< OneD, NekDoublek_coeffs
 
Array< OneD, NekDoublek_breaks
 

Detailed Description

Definition at line 47 of file kernel.h.

Constructor & Destructor Documentation

Nektar::LibUtilities::Kernel::Kernel ( )

The default constructor.

Nektar::LibUtilities::Kernel::Kernel ( int  order)

Definition at line 42 of file kernel.cpp.

References k_center, UpdateKernelBspline(), UpdateKernelCoeffs(), UpdateKernelNumOfCoeffs(), UpdateKernelOrder(), and UpdateKernelWidth().

43  {
44  UpdateKernelOrder(order);
49  k_center = 0.0;
50  }
void UpdateKernelNumOfCoeffs()
This funciton sets the k_ncoeffs variable.
Definition: kernel.h:114
void UpdateKernelOrder(int order)
This funciton sets the k_order variable.
Definition: kernel.h:106
void UpdateKernelCoeffs()
This funciton updates the kernel coefficients.
Definition: kernel.cpp:176
void UpdateKernelWidth()
This funciton sets the kernel width size.
Definition: kernel.h:122
void UpdateKernelBspline()
The default destructor.
Definition: kernel.cpp:52

Member Function Documentation

void Nektar::LibUtilities::Kernel::EvaluateBspline ( Array< OneD, NekDouble inarray,
NekDouble  h,
NekDouble  offset,
Array< OneD, NekDouble > &  outarray 
)

This function evaluates the bspline at input values.

Parameters
inarrayinput values.
hthe mesh spacing.
offset
outarraycontains the bspline values.

Definition at line 307 of file kernel.cpp.

References EvaluateBsplinePoly(), and k_order.

Referenced by EvaluateKernel().

309  {
310  int i;
311  NekDouble min_value = -k_order/2.0;
312  NekDouble max_value = k_order/2.0;
313 
314  int nvalues = inarray.num_elements();
315 
316  // Make a copy for further modifications
317  Array<OneD,NekDouble> inarray_cp(nvalues);
318 
319  for(i = 0; i < nvalues; i++)
320  {
321  inarray_cp[i] = inarray[i] - offset;
322  inarray_cp[i] = inarray_cp[i]/h;
323  int interval = (int)floor(inarray_cp[i] - min_value); // determines to which interval of the bspline the value belongs
324 
325  if(inarray_cp[i] >= min_value && inarray_cp[i] <= max_value)
326  {
327  if(interval >= k_order)
328  {
329  interval -= 1;
330  }
331  NekDouble shift = min_value + interval;
332  inarray_cp[i] -= shift;
333  outarray[i] = EvaluateBsplinePoly(inarray_cp[i],interval);
334  }else
335  {
336  outarray[i] = 0.0;
337  }
338 
339  }
340  }
NekDouble EvaluateBsplinePoly(NekDouble x_value, int interval)
This funciton evaluates the piecewise bspline polynomial.
Definition: kernel.cpp:342
double NekDouble
NekDouble Nektar::LibUtilities::Kernel::EvaluateBsplinePoly ( NekDouble  x_value,
int  interval 
)
protected

This funciton evaluates the piecewise bspline polynomial.

Parameters
interval
intervalat point
x_value.

Definition at line 342 of file kernel.cpp.

References b_spline, and k_order.

Referenced by EvaluateBspline().

343  {
344  int i;
345  int deg = k_order - 1;
346  NekDouble poly_value = b_spline[interval][0];
347 
348  for(i = 0; i < deg; i++)
349  {
350  poly_value = poly_value*x_value + b_spline[interval][i+1];
351 
352  }
353 
354  return poly_value;
355  }
Array< TwoD, NekDouble > b_spline
Definition: kernel.h:201
double NekDouble
void Nektar::LibUtilities::Kernel::EvaluateKernel ( Array< OneD, NekDouble inarray,
NekDouble  h,
Array< OneD, NekDouble > &  outarray 
)

This funciton evaluates the kernel at input values.

Parameters
inarray.
his the mesh spacing.
outarraycontains the kernel values

Definition at line 279 of file kernel.cpp.

References EvaluateBspline(), k_center, k_coeffs, and k_order.

281  {
282  int gamma,i;
283  int degree = k_order - 1;
284  int nvalues = inarray.num_elements();
285  Array<OneD,NekDouble> bs_values(nvalues);
286 
287  for(i = 0; i < nvalues; i++ )
288  {
289  outarray[i] = 0.0;
290  }
291 
292  for(gamma = -degree; gamma <= degree; gamma++)
293  {
294  int cIndex = gamma+degree;
295 
296  // Evaluate the bSpline values
297  EvaluateBspline(inarray,h,k_center+(gamma*h),bs_values);
298 
299  for(i = 0; i < nvalues; i++ )
300  {
301  outarray[i] += k_coeffs[cIndex]*bs_values[i];
302  }
303  }
304 
305  }
void EvaluateBspline(Array< OneD, NekDouble > inarray, NekDouble h, NekDouble offset, Array< OneD, NekDouble > &outarray)
This function evaluates the bspline at input values.
Definition: kernel.cpp:307
Array< OneD, NekDouble > k_coeffs
Definition: kernel.h:202
void Nektar::LibUtilities::Kernel::FindMeshUnderKernel ( Array< OneD, NekDouble > &  inarray,
NekDouble  h,
Array< OneD, NekDouble > &  outarray 
)

This funciton calculates the mesh breaks under the kernel support.

Parameters
inarraycontains the local kernel breaks
his the mesh spacing
outarraycontains the coordinate of the mesh breaks under the kernel support

Definition at line 261 of file kernel.cpp.

References k_width.

263  {
264  int j;
265  NekDouble first = ceil(inarray[0]/h)*h;
266  int index = k_width;
267  NekDouble last = floor(inarray[index]/h)*h;
268  int count = (int)((last-first)/h)+1; // number of mesh breaks under the kernel support
269  Array<OneD,NekDouble> mesh_breaks(count);
270  mesh_breaks[0] = first;
271  for(j = 1; j < count; j++)
272  {
273  mesh_breaks[j] = mesh_breaks[j-1]+h;
274  }
275  outarray = mesh_breaks;
276 
277  }
double NekDouble
Array<OneD,NekDouble> Nektar::LibUtilities::Kernel::GetKernelBreaks ( )
inline

This funciton returns a 1D array representing the kernel breaks.

Definition at line 98 of file kernel.h.

References k_breaks.

99  {
100  return k_breaks;
101  }
Array< OneD, NekDouble > k_breaks
Definition: kernel.h:203
Array<TwoD,NekDouble> Nektar::LibUtilities::Kernel::GetKernelBspline ( )
inline

This funciton returns a 2D array representing the bspline of the appropriate order.

Definition at line 82 of file kernel.h.

References b_spline.

83  {
84  return b_spline;
85  }
Array< TwoD, NekDouble > b_spline
Definition: kernel.h:201
Array<OneD,NekDouble> Nektar::LibUtilities::Kernel::GetKernelCoeffs ( )
inline

This funciton returns a 1D array representing the kernel coefficients.

Definition at line 90 of file kernel.h.

References k_coeffs.

91  {
92  return k_coeffs;
93  }
Array< OneD, NekDouble > k_coeffs
Definition: kernel.h:202
int Nektar::LibUtilities::Kernel::GetKernelNumeOfCoeffs ( )
inline

This funciton returns the number of kernel coefficients.

Definition at line 138 of file kernel.h.

References k_ncoeffs.

139  {
140  return k_ncoeffs;
141  }
int Nektar::LibUtilities::Kernel::GetKernelOrder ( )
inline

This funciton returns the order of the kernel.

Definition at line 130 of file kernel.h.

References k_order.

131  {
132  return k_order;
133  }
int Nektar::LibUtilities::Kernel::GetKernelWidth ( )
inline

This funciton returns the size of the kernel width.

Definition at line 146 of file kernel.h.

References k_width.

147  {
148  return k_width;
149  }
void Nektar::LibUtilities::Kernel::MoveKernelCenter ( NekDouble  x_value,
Array< OneD, NekDouble > &  outarray 
)

This funciton moves the center of the kernel to the.

Parameters
x_value.
outarrayis used to store the result

Definition at line 249 of file kernel.cpp.

References k_breaks, k_center, and k_width.

250  {
251  int i;
252  for(i = 0; i < k_width+1; i++)
253  {
254  outarray[i] = k_breaks[i] + x_value;
255  }
256 
257  // Update the center of the kernel
258  k_center = x_value;
259  }
Array< OneD, NekDouble > k_breaks
Definition: kernel.h:203
void Nektar::LibUtilities::Kernel::Sort ( Array< OneD, NekDouble > &  inarray1,
Array< OneD, NekDouble > &  inarray2,
Array< OneD, NekDouble > &  outarray 
)

This funciton performs the ordered merge of.

Parameters
inarray1and
inarray2and puts the result in
outarray

Definition at line 357 of file kernel.cpp.

359  {
360  int j;
361  int kIndex = 0; // Keeps track of the kernel breaks
362  int mIndex = 0; // Keeps track of the mesh breaks
363  for(j = 0; j < outarray.num_elements(); j++)
364  {
365  if(mIndex >= inarray2.num_elements())
366  {
367  outarray[j] = inarray1[kIndex];
368  kIndex++;
369  }else if(kIndex >= inarray1.num_elements())
370  {
371  outarray[j] = inarray2[mIndex];
372  mIndex++;
373 
374  }else if(inarray1[kIndex] < inarray2[mIndex])
375  {
376  outarray[j] = inarray1[kIndex];
377  kIndex++;
378  }else
379  {
380  outarray[j] = inarray2[mIndex];
381  mIndex++;
382  }
383 
384  }
385  }
void Nektar::LibUtilities::Kernel::UpdateKernelBreaks ( NekDouble  h)

This funciton updates the kernel breaks.

Parameters
hrepresents the mesh spacing

Definition at line 237 of file kernel.cpp.

References k_breaks, and k_width.

238  {
239  int i;
240  Array<OneD,NekDouble> temp(k_width+1);
241  temp[0] = -(k_width/2.0)*h; // it needs to get scaled by h
242  for(i = 1; i < k_width+1; i++)
243  {
244  temp[i] = temp[i-1]+h;
245  }
246  k_breaks = temp;
247  }
Array< OneD, NekDouble > k_breaks
Definition: kernel.h:203
void Nektar::LibUtilities::Kernel::UpdateKernelBspline ( )

The default destructor.

This funciton updates the bspline to the appropriate order.

Definition at line 52 of file kernel.cpp.

References ASSERTL0, b_spline, and k_order.

Referenced by Kernel().

53  {
54  Array<TwoD,NekDouble> out_final(k_order,k_order);
55 
56  int i,j;
57 
58  if(k_order == 1.0)
59  {
60  b_spline[0][0] = 1.0;
61 
62  }else if(k_order == 2)
63  {
64  NekDouble out[2][2] = {{1.0,0.0},
65  {-1.0,1.0}};
66  for(i = 0; i < k_order; i++)
67  {
68  for(j = 0; j < k_order; j++)
69  {
70  out_final[i][j] = out[i][j];
71  }
72  }
73 
74  }else if(k_order == 3)
75  {
76  NekDouble out[3][3] = {{0.5, 0.0, 0.0},
77  {-1.0, 1.0, 0.5},
78  {0.5, -1.0, 0.5}};
79  for(i = 0; i < k_order; i++)
80  {
81  for(j = 0; j < k_order; j++)
82  {
83  out_final[i][j] = out[i][j];
84  }
85  }
86 
87  }else if(k_order == 4)
88  {
89  NekDouble out[4][4] = {{1.0/6.0, 0, 0, 0},
90  {-0.5, 0.5, 0.5, 1.0/6.0},
91  {0.5, -1.0, 0, 2.0/3},
92  {-1.0/6.0, 0.5, -0.5, 1.0/6.0}};
93  for(i = 0; i < k_order; i++)
94  {
95  for(j = 0; j < k_order; j++)
96  {
97  out_final[i][j] = out[i][j];
98  }
99  }
100 
101  }else if(k_order == 5)
102  {
103  NekDouble out[5][5] = {{1.0 / 24.0, 0, 0, 0, 0},
104  {-1.0/6, 1.0/6, 0.25, 1.0/6, 1.0/24},
105  {0.25, -0.5, -0.25, 0.5, 11.0/24},
106  {-1.0/6, 0.5, -0.25, -0.5, 11.0/24},
107  {1.0/24, -1.0/6.0, 0.25, -1.0/6, 1.0/24}};
108  for(i = 0; i < k_order; i++)
109  {
110  for(j = 0; j < k_order; j++)
111  {
112  out_final[i][j] = out[i][j];
113  }
114  }
115 
116  }else if(k_order == 6)
117  {
118  NekDouble out[6][6] = {{1.0/1.020, 0, 0, 0, 0, 0},
119  {-1.0/24, 1.0/24, 1.0/12, 1.0/12, 1.0/24, 1.0/120},
120  {1.0/12, -1.0/6, -1.0/6, 1.0/6, 5.0/12, 13.0/60},
121  {-1.0/12, 0.25, 0, -1.0/2, 0, 11.0/20},
122  {1.0/24, -1.0/6, 1.0/6, 1.0/6, -5.0/12, 13.0/60},
123  {-1.0/120, 1.0/24, -1.0/12, 1.0/12, -1.0/24, 1.0/120}};
124  for(i = 0; i < k_order; i++)
125  {
126  for(j = 0; j < k_order; j++)
127  {
128  out_final[i][j] = out[i][j];
129  }
130  }
131 
132  }else if(k_order == 7)
133  {
134  NekDouble out[7][7] = {{1.0/720, 0, 0, 0, 0, 0, 0},
135  {-1.0/120, 1.0/120, 1.0/48, 1.0/36, 1.0/48, 1.0/120, 1.0/720},
136  {1.0/48, -1.0/24, -1.0/16, 1.0/36, 3.0/16, 5.0/24, 19.0/240},
137  {-1.0/36, 1.0/1.02, 1.0/24, -2.0/9, -5.0/24, 1.0/3, 151.0/360},
138  {1.0/48, -1.0/12, 1.0/24, 2.0/9, -5.0/24, -1.0/3, 151.0/360},
139  {-1.0/120, 1.0/24, -1.0/16, -1.0/36, 3.0/16, -5.0/24, 19.0/240},
140  {1.0/720, -1.0/120, 1.0/48, -1.0/36, 1.0/48, -1.0/120, 1.0/720}};
141  for(i = 0; i < k_order; i++)
142  {
143  for(j = 0; j < k_order; j++)
144  {
145  out_final[i][j] = out[i][j];
146  }
147  }
148 
149  }else if(k_order == 8)
150  {
151  NekDouble out[8][8] = {{1.0/5040, 0, 0, 0, 0, 0, 0, 0},
152  {-1.0/720, 1.0/720, 1.0/240, 1.0/144, 1.0/144, 1.0/240, 1.0/720, 1.0/5040 },
153  {1.0/240, -1.0/120, -1.0/60, 0, 1.0/18, 1.0/10, 7.0/90, 1.0/42},
154  {-1.0/144, 1.0/48, 1.0/48, -1.0/16, -19.0/144, 1.0/16, 49.0/144, 397.0/1680},
155  {1.0/144, -1.0/36, 0, 1.0/9, 0, -1.0/3, 0, 151.0/315},
156  {-1.0/240, 1.0/48, -1.0/48, -1.0/16, 19.0/144, 1.0/16, -49.0/144, 397.0/1680},
157  { 1.0/720, -1.0/120, 1.0/60, 0, -1.0/18, 1.0/10, -7.0/90, 1.0/42},
158  { -1.0/5040, 1.0/720, -1.0/240, 1.0/144, -1.0/144, 1.0/240, -1.0/720, 1.0/5040}};
159  for(i = 0; i < k_order; i++)
160  {
161  for(j = 0; j < k_order; j++)
162  {
163  out_final[i][j] = out[i][j];
164  }
165  }
166 
167  }
168 
169  b_spline = out_final;
170 
171  ASSERTL0(k_order <= 8, "Order is not supported");
172 
173 
174  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
Array< TwoD, NekDouble > b_spline
Definition: kernel.h:201
double NekDouble
void Nektar::LibUtilities::Kernel::UpdateKernelCoeffs ( )

This funciton updates the kernel coefficients.

Definition at line 176 of file kernel.cpp.

References ASSERTL0, k_coeffs, k_ncoeffs, and k_order.

Referenced by Kernel().

177  {
178  int i;
179  Array<OneD,NekDouble> out_final(k_ncoeffs);
180 
181  if (k_order == 2)
182  {
183  NekDouble out[3] = {-1.0/12, 7.0/6, -1.0/12};
184  for(i = 0; i < k_ncoeffs; i++)
185  {
186  out_final[i] = out[i];
187  }
188  }else if (k_order == 3)
189  {
190  NekDouble out[5] = {37.0/1920, -97.0/480, 437.0/320, -97.0/480, 37.0/1920};
191  for(i = 0; i < k_ncoeffs; i++)
192  {
193  out_final[i] = out[i];
194  }
195  }else if (k_order == 4)
196  {
197  NekDouble out[7] = {-41.0/7560, 311.0/5040, -919.0/2520, 12223.0/7560, -919.0/2520, 311.0/5040, -41.0/7560};
198  for(i = 0; i < k_ncoeffs; i++)
199  {
200  out_final[i] = out[i];
201  }
202  }else if (k_order == 5)
203  {
204  NekDouble out[9] = {153617.0/92897280, -35411.0/1658880, 3153959.0/23224320, -6803459.0/11612160, 18017975.0/9289728, -6803459.0/11612160, 3153959.0/23224320, -35411.0/1658880, 153617.0/92897280};
205  for(i = 0; i < k_ncoeffs; i++)
206  {
207  out_final[i] = out[i];
208  }
209  }else if (k_order == 6)
210  {
211  NekDouble out[11] = {-4201.0/7983360, 30773.0/3991680, -20813.0/380160, 2825.0/11088, -1179649.0/1330560, 1569217.0/665280, -1179649.0/1330560, 2825.0/11088, -20813.0/380160, 30773.0/3991680, -4201.0/7983360};
212  for(i = 0; i < k_ncoeffs; i++)
213  {
214  out_final[i] = out[i];
215  }
216  }else if (k_order == 7)
217  {
218  NekDouble out[13] = {13154671847.0/76517631590400.0, -18073154507.0/6376469299200.0, 287360344573.0/12752938598400.0, -2217732343517.0/19129407897600.0, 1240941746699.0/2833986355200.0, -275386671493.0/212548976640.0, 2648644782397.0/910924185600.0, -275386671493.0/212548976640.0, 1240941746699.0/2833986355200.0, -2217732343517.0/19129407897600.0, 287360344573.0/12752938598400.0, -18073154507.0/6376469299200.0, 13154671847.0/76517631590400.0};
219  for(i = 0; i < k_ncoeffs; i++)
220  {
221  out_final[i] = out[i];
222  }
223  }else if (k_order == 8)
224  {
225  NekDouble out[15] = {-800993.0/14010796800.0, 73587167.0/70053984000.0, -651305719.0/70053984000.0, 3714581677.0/70053984000.0, -3085236289.0/14010796800.0, 1426328231.0/2001542400.0, -43268401973.0/23351328000.0, 42401344373.0/11675664000.0, -43268401973.0/23351328000.0, 1426328231.0/2001542400.0, -3085236289.0/14010796800.0, 3714581677.0/70053984000.0, -651305719.0/70053984000.0, 73587167.0/70053984000.0, -800993.0/14010796800.0};
226  for(i = 0; i < k_ncoeffs; i++)
227  {
228  out_final[i] = out[i];
229  }
230  }
231 
232  k_coeffs = out_final;
233  ASSERTL0(k_order <= 8, "Order is not supported");
234 
235  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
Array< OneD, NekDouble > k_coeffs
Definition: kernel.h:202
double NekDouble
void Nektar::LibUtilities::Kernel::UpdateKernelNumOfCoeffs ( )
inline

This funciton sets the k_ncoeffs variable.

Definition at line 114 of file kernel.h.

References k_ncoeffs, and k_order.

Referenced by Kernel().

115  {
116  k_ncoeffs = 2*(k_order-1)+1;
117  }
void Nektar::LibUtilities::Kernel::UpdateKernelOrder ( int  order)
inline

This funciton sets the k_order variable.

Definition at line 106 of file kernel.h.

References k_order.

Referenced by Kernel().

107  {
108  k_order = order;
109  }
void Nektar::LibUtilities::Kernel::UpdateKernelWidth ( )
inline

This funciton sets the kernel width size.

Definition at line 122 of file kernel.h.

References k_order, and k_width.

Referenced by Kernel().

123  {
124  k_width = 3*(k_order-1)+1;
125  }

Member Data Documentation

Array<TwoD,NekDouble> Nektar::LibUtilities::Kernel::b_spline
protected

2D array representing the bspline

Definition at line 201 of file kernel.h.

Referenced by EvaluateBsplinePoly(), GetKernelBspline(), and UpdateKernelBspline().

Array<OneD,NekDouble> Nektar::LibUtilities::Kernel::k_breaks
protected

1D array representing the kernel breaks

Definition at line 203 of file kernel.h.

Referenced by GetKernelBreaks(), MoveKernelCenter(), and UpdateKernelBreaks().

NekDouble Nektar::LibUtilities::Kernel::k_center
protected

holds the center of the kernel

Definition at line 200 of file kernel.h.

Referenced by EvaluateKernel(), Kernel(), and MoveKernelCenter().

Array<OneD,NekDouble> Nektar::LibUtilities::Kernel::k_coeffs
protected

1D array representing the kernel coefficients

Definition at line 202 of file kernel.h.

Referenced by EvaluateKernel(), GetKernelCoeffs(), and UpdateKernelCoeffs().

int Nektar::LibUtilities::Kernel::k_ncoeffs
protected

Represents the number of kernel coefficients

Definition at line 198 of file kernel.h.

Referenced by GetKernelNumeOfCoeffs(), UpdateKernelCoeffs(), and UpdateKernelNumOfCoeffs().

int Nektar::LibUtilities::Kernel::k_order
protected

bsplines are obtained by convolving the characteristic fucntion with itself (k_order - 1) times

Definition at line 196 of file kernel.h.

Referenced by EvaluateBspline(), EvaluateBsplinePoly(), EvaluateKernel(), GetKernelOrder(), UpdateKernelBspline(), UpdateKernelCoeffs(), UpdateKernelNumOfCoeffs(), UpdateKernelOrder(), and UpdateKernelWidth().

int Nektar::LibUtilities::Kernel::k_width
protected

Represents the width of the kernel

Definition at line 199 of file kernel.h.

Referenced by FindMeshUnderKernel(), GetKernelWidth(), MoveKernelCenter(), UpdateKernelBreaks(), and UpdateKernelWidth().