Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
MappingXofXZ.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File: MappingXofXZ.cpp
4 //
5 // For more information, please see: http://www.nektar.info
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description: Mapping of the type X = X(x,z)
33 //
34 ///////////////////////////////////////////////////////////////////////////////
35 
36 #include <GlobalMapping/MappingXofXZ.h>
37 #include <MultiRegions/ExpList.h>
38 
39 namespace Nektar
40 {
41 namespace GlobalMapping
42 {
43 
44 std::string MappingXofXZ::className =
45  GetMappingFactory().RegisterCreatorFunction("XofXZ",
46  MappingXofXZ::create, "X = X(x,z)");
47 
48 /**
49  * @class MappingXofXZ
50  * This class implements a mapping defined by a transformation of the type
51  * \f[ \bar{x} = \bar{x}(x,z) \f]
52  * \f[ \bar{y} = y \f]
53  * \f[ \bar{z} = z \f]
54  * where \f$(\bar{x},\bar{y},\bar{z})\f$ are the Cartesian (physical)
55  * coordinates and \f$(x,y,z)\f$ are the transformed (computational)
56  * coordinates.
57  */
58 MappingXofXZ::MappingXofXZ(
59  const LibUtilities::SessionReaderSharedPtr &pSession,
60  const Array<OneD, MultiRegions::ExpListSharedPtr>& pFields)
61  : Mapping(pSession, pFields)
62 {
63 }
64 
65 
66 /**
67  *
68  */
69 void MappingXofXZ::v_InitObject(
70  const Array<OneD, MultiRegions::ExpListSharedPtr> &pFields,
71  const TiXmlElement *pMapping)
72 {
73  Mapping::v_InitObject(pFields, pMapping);
74 
75  m_constantJacobian = false;
76 
77  ASSERTL0(m_nConvectiveFields==3,
78  "Mapping X = X(x,z) needs 3 velocity components.");
79 }
80 
81 void MappingXofXZ::v_ContravarToCartesian(
82  const Array<OneD, Array<OneD, NekDouble> > &inarray,
83  Array<OneD, Array<OneD, NekDouble> > &outarray)
84 {
85  int physTot = m_fields[0]->GetTotPoints();
86 
87  // U1 = fx*u1 + fz*u3
88  Vmath::Vmul(physTot, m_GeometricInfo[0], 1, inarray[0], 1,
89  outarray[0], 1);
90  Vmath::Vvtvp(physTot, m_GeometricInfo[1], 1, inarray[2], 1,
91  outarray[0], 1, outarray[0],1);
92 
93  // U2 = u2
94  Vmath::Vcopy(physTot, inarray[1], 1, outarray[1], 1);
95 
96  // U3 = u3
97  Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
98 }
99 
100 void MappingXofXZ::v_CovarToCartesian(
101  const Array<OneD, Array<OneD, NekDouble> > &inarray,
102  Array<OneD, Array<OneD, NekDouble> > &outarray)
103 {
104  int physTot = m_fields[0]->GetTotPoints();
105  Array<OneD, NekDouble> wk(physTot, 0.0);
106 
107  // U1 = u1/fx
108  Vmath::Vdiv(physTot, inarray[0], 1, m_GeometricInfo[0], 1,
109  outarray[0], 1);
110 
111  // U2 = u2
112  Vmath::Vcopy(physTot, inarray[1], 1, outarray[1], 1);
113 
114  // U3 = u3 - fz/fx*u1
115  Vmath::Vdiv(physTot, m_GeometricInfo[1], 1,
116  m_GeometricInfo[0], 1, wk, 1);
117  Vmath::Vmul(physTot, wk, 1, inarray[0], 1, wk, 1);
118  Vmath::Vsub(physTot, inarray[2], 1, wk, 1, outarray[2], 1);
119 }
120 
121 void MappingXofXZ::v_ContravarFromCartesian(
122  const Array<OneD, Array<OneD, NekDouble> > &inarray,
123  Array<OneD, Array<OneD, NekDouble> > &outarray)
124 {
125  int physTot = m_fields[0]->GetTotPoints();
126  Array<OneD, NekDouble> wk(physTot, 0.0);
127 
128  // U1 = u1/fx - fz/fx * u3
129  Vmath::Vdiv(physTot, inarray[0], 1,
130  m_GeometricInfo[0], 1, outarray[0], 1);
131  Vmath::Vdiv(physTot, m_GeometricInfo[1], 1,
132  m_GeometricInfo[0], 1, wk, 1);
133  Vmath::Vmul(physTot, wk, 1, inarray[2], 1, wk, 1);
134  Vmath::Vsub(physTot, outarray[0], 1, wk, 1, outarray[0], 1);
135 
136  // U2 = u2
137  Vmath::Vcopy(physTot, inarray[1], 1, outarray[1], 1);
138 
139  // U3 = u3
140  Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
141 }
142 
143 void MappingXofXZ::v_CovarFromCartesian(
144  const Array<OneD, Array<OneD, NekDouble> > &inarray,
145  Array<OneD, Array<OneD, NekDouble> > &outarray)
146 {
147  int physTot = m_fields[0]->GetTotPoints();
148 
149  // U1 = u1*fx
150  Vmath::Vmul(physTot, inarray[0], 1, m_GeometricInfo[0], 1,
151  outarray[0], 1);
152 
153  // U2 = u2
154  Vmath::Vcopy(physTot, inarray[1], 1, outarray[1], 1);
155 
156  // U3 = u3 + fz*u1
157  Vmath::Vmul(physTot, m_GeometricInfo[1], 1,
158  inarray[0], 1, outarray[2], 1);
159  Vmath::Vadd(physTot, inarray[2], 1, outarray[2], 1, outarray[2], 1);
160 }
161 
162 void MappingXofXZ::v_GetJacobian(
163  Array<OneD, NekDouble> &outarray)
164 {
165  int physTot = m_fields[0]->GetTotPoints();
166  Vmath::Vcopy(physTot, m_GeometricInfo[0], 1, outarray, 1);
167 }
168 
169 void MappingXofXZ::v_DotGradJacobian(
170  const Array<OneD, Array<OneD, NekDouble> > &inarray,
171  Array<OneD, NekDouble> &outarray)
172 {
173  int physTot = m_fields[0]->GetTotPoints();
174 
175  Vmath::Vmul(physTot, m_GeometricInfo[2], 1, inarray[0], 1, outarray, 1);
176  Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, inarray[2], 1,
177  outarray, 1, outarray,1);
178 }
179 
180 void MappingXofXZ::v_GetMetricTensor(
181  Array<OneD, Array<OneD, NekDouble> > &outarray)
182 {
183  int physTot = m_fields[0]->GetTotPoints();
184  int nvel = m_nConvectiveFields;
185  Array<OneD, NekDouble> wk(physTot, 0.0);
186 
187  for (int i=0; i<nvel*nvel; i++)
188  {
189  outarray[i] = Array<OneD, NekDouble> (physTot, 0.0);
190  }
191  // Fill G^{22} and G^{33} with 1.0
192  for (int i=1; i<nvel; i++)
193  {
194  Vmath::Sadd(physTot, 1.0, outarray[i+nvel*i], 1,
195  outarray[i+nvel*i], 1);
196  }
197 
198  // G_{13} and G_{31} = fz*fx
199  Vmath::Vmul(physTot,m_GeometricInfo[1],1,
200  m_GeometricInfo[0],1,wk,1); // fz*fx
201  Vmath::Vcopy(physTot, wk, 1, outarray[0*nvel+2], 1);
202  Vmath::Vcopy(physTot, wk, 1, outarray[2*nvel+0], 1);
203 
204  // G^{11} = (fx^2)
205  Vmath::Vmul(physTot, m_GeometricInfo[0], 1,
206  m_GeometricInfo[0], 1, outarray[0*nvel+0], 1);
207 
208  // G^{33} = (1+fz^2)
209  Vmath::Vmul(physTot, m_GeometricInfo[1], 1,
210  m_GeometricInfo[1], 1, wk, 1); // fz^2
211  Vmath::Vadd(physTot, wk, 1, outarray[2*nvel+2], 1,
212  outarray[2*nvel+2], 1);
213 }
214 
215 void MappingXofXZ::v_GetInvMetricTensor(
216  Array<OneD, Array<OneD, NekDouble> > &outarray)
217 {
218  int physTot = m_fields[0]->GetTotPoints();
219  int nvel = m_nConvectiveFields;
220  Array<OneD, NekDouble> wk(physTot, 0.0);
221 
222  for (int i=0; i<nvel*nvel; i++)
223  {
224  outarray[i] = Array<OneD, NekDouble> (physTot, 0.0);
225  }
226  // Fill diagonal with 1.0
227  for (int i=0; i<nvel; i++)
228  {
229  Vmath::Sadd(physTot, 1.0, outarray[i+nvel*i], 1,
230  outarray[i+nvel*i], 1);
231  }
232 
233  // G^{13} and G^{31} = -fz/fx
234  Vmath::Vdiv(physTot,m_GeometricInfo[1],1,
235  m_GeometricInfo[0],1,wk,1); // fz/fx
236  Vmath::Neg(physTot, wk, 1);
237  Vmath::Vcopy(physTot, wk, 1, outarray[0*nvel+2], 1);
238  Vmath::Vcopy(physTot, wk, 1, outarray[2*nvel+0], 1);
239 
240  // G^{11} = (1+fz^2)/(fx^2)
241  Vmath::Vmul(physTot, m_GeometricInfo[1], 1,
242  m_GeometricInfo[1], 1, wk, 1); // fz^2
243  Vmath::Vadd(physTot, wk, 1, outarray[0*nvel+0], 1,
244  outarray[0*nvel+0], 1);
245 
246  Vmath::Vmul(physTot, m_GeometricInfo[0], 1,
247  m_GeometricInfo[0], 1, wk, 1); // fx^2
248  Vmath::Vdiv(physTot, outarray[0*nvel+0], 1, wk,1,
249  outarray[0*nvel+0], 1);
250 }
251 
252 void MappingXofXZ::v_LowerIndex(
253  const Array<OneD, Array<OneD, NekDouble> > &inarray,
254  Array<OneD, Array<OneD, NekDouble> > &outarray)
255 {
256  int physTot = m_fields[0]->GetTotPoints();
257  Array<OneD, NekDouble> wk(physTot, 0.0);
258 
259  // out[0] = in[0]*fx^2 + in[2] * fz*fx
260  Vmath::Vmul(physTot,m_GeometricInfo[1],1,m_GeometricInfo[0],1,
261  wk,1); // fz*fx
262  Vmath::Vmul(physTot, wk, 1, inarray[2], 1, outarray[0], 1); //in[2]*fz*fx
263  Vmath::Vmul(physTot, wk, 1, inarray[0], 1, outarray[2], 1); //in[0]*fz*fx
264 
265  Vmath::Vmul(physTot, m_GeometricInfo[0], 1, m_GeometricInfo[0], 1,
266  wk, 1); //fx^2
267  Vmath::Vmul(physTot, wk, 1, inarray[0], 1, wk, 1); //in[0]*fx^2
268 
269  Vmath::Vadd(physTot, outarray[0], 1, wk, 1, outarray[0], 1);
270 
271  // out[1] = in[1]
272  Vmath::Vcopy(physTot, inarray[1], 1, outarray[1], 1);
273 
274  // out[2] = fx*fz*in[0] + (1+fz^2)*in[2]
275  Vmath::Vmul(physTot, m_GeometricInfo[1], 1, m_GeometricInfo[1], 1,
276  wk, 1); // fz^2
277  Vmath::Sadd(physTot, 1.0, wk, 1, wk, 1); // 1+fz^2
278  Vmath::Vmul(physTot, wk, 1, inarray[2],1, wk, 1); // (1+fz^2)*in[2]
279 
280  Vmath::Vadd(physTot, wk, 1, outarray[2],1, outarray[2], 1);
281 }
282 
283 void MappingXofXZ::v_RaiseIndex(
284  const Array<OneD, Array<OneD, NekDouble> > &inarray,
285  Array<OneD, Array<OneD, NekDouble> > &outarray)
286 {
287  int physTot = m_fields[0]->GetTotPoints();
288  Array<OneD, NekDouble> wk(physTot, 0.0);
289  Array<OneD, NekDouble> wk_2(physTot, 0.0);
290 
291  // out[2] = in[2] - in[0] * fz/fx
292  Vmath::Vdiv(physTot,m_GeometricInfo[1],1,m_GeometricInfo[0],1,
293  wk,1);
294  Vmath::Vmul(physTot, wk, 1, inarray[0], 1, outarray[2], 1);
295  Vmath::Vsub(physTot, inarray[2], 1, outarray[2], 1, outarray[2], 1);
296 
297  // out[0] = in[0]*(1+fz^2)/(fx^2) - in[2] * fz/fx
298  Vmath::Vmul(physTot, wk, 1, inarray[2], 1, outarray[0], 1);
299  Vmath::Vmul(physTot, m_GeometricInfo[1], 1, m_GeometricInfo[1], 1,
300  wk, 1);
301  Vmath::Sadd(physTot, 1.0, wk, 1, wk, 1);
302  Vmath::Vmul(physTot, m_GeometricInfo[0], 1, m_GeometricInfo[0], 1,
303  wk_2, 1);
304  Vmath::Vdiv(physTot, wk, 1, wk_2,1, wk, 1);
305  Vmath::Vmul(physTot, wk, 1, inarray[0],1, wk, 1);
306  Vmath::Vsub(physTot, wk, 1, outarray[0], 1, outarray[0], 1);
307 
308  // out[1] = in[1]
309  Vmath::Vcopy(physTot, inarray[1], 1, outarray[1], 1);
310 
311 
312 }
313 
314 void MappingXofXZ::v_ApplyChristoffelContravar(
315  const Array<OneD, Array<OneD, NekDouble> > &inarray,
316  Array<OneD, Array<OneD, NekDouble> > &outarray)
317 {
318  int physTot = m_fields[0]->GetTotPoints();
319  int nvel = m_nConvectiveFields;
320  Array<OneD, NekDouble> wk(physTot, 0.0);
321 
322  for (int i = 0; i< nvel; i++)
323  {
324  for (int j = 0; j< nvel; j++)
325  {
326  outarray[i*nvel+j] = Array<OneD, NekDouble>(physTot,0.0);
327  }
328  }
329 
330  // Calculate non-zero terms
331 
332  // outarray(0,0) = U1 * fxx/fx + U3 * fxz/fx
333  Vmath::Vdiv(physTot,m_GeometricInfo[2],1,m_GeometricInfo[0],1,wk,1);
334  Vmath::Vmul(physTot,wk,1,inarray[0],1,outarray[0*nvel+0],1);
335  Vmath::Vdiv(physTot,m_GeometricInfo[3],1,m_GeometricInfo[0],1,wk,1);
336  Vmath::Vvtvp(physTot,wk,1,inarray[2],1,outarray[0*nvel+0],1,
337  outarray[0*nvel+0],1);
338 
339  // outarray(0,2) = U1 * fxz/fx + U3 * fzz/fx
340  Vmath::Vmul(physTot,wk,1,inarray[0],1,outarray[0*nvel+2],1);
341  Vmath::Vdiv(physTot,m_GeometricInfo[4],1,m_GeometricInfo[0],1,wk,1);
342  Vmath::Vvtvp(physTot,wk,1,inarray[2],1,outarray[0*nvel+2],1,
343  outarray[0*nvel+2],1);
344 
345 }
346 
347 void MappingXofXZ::v_ApplyChristoffelCovar(
348  const Array<OneD, Array<OneD, NekDouble> > &inarray,
349  Array<OneD, Array<OneD, NekDouble> > &outarray)
350 {
351  int physTot = m_fields[0]->GetTotPoints();
352  int nvel = m_nConvectiveFields;
353  Array<OneD, NekDouble> wk(physTot, 0.0);
354 
355  for (int i = 0; i< nvel; i++)
356  {
357  for (int j = 0; j< nvel; j++)
358  {
359  outarray[i*nvel+j] = Array<OneD, NekDouble>(physTot,0.0);
360  }
361  }
362 
363  // Calculate non-zero terms
364 
365  // outarray(0,0) = U1 * fxx/fx
366  Vmath::Vdiv(physTot,m_GeometricInfo[2],1,m_GeometricInfo[0],1,wk,1);
367  Vmath::Vmul(physTot,wk,1,inarray[0],1,outarray[0*nvel+0],1);
368 
369  //outarray(0,2) = outarray(2,0) = U1 * fxz/fx
370  Vmath::Vdiv(physTot,m_GeometricInfo[3],1,m_GeometricInfo[0],1,wk,1);
371  Vmath::Vmul(physTot,wk,1,inarray[0],1,outarray[0*nvel+2],1);
372  Vmath::Vcopy(physTot,outarray[0*nvel+2],1,outarray[2*nvel+0],1);
373 
374  // outarray(2,2) = U1 * fzz/fx
375  Vmath::Vdiv(physTot,m_GeometricInfo[4],1,m_GeometricInfo[0],1,wk,1);
376  Vmath::Vmul(physTot,wk,1,inarray[0],1,outarray[2*nvel+2],1);
377 }
378 
379 void MappingXofXZ::v_UpdateGeomInfo()
380 {
381  int phystot = m_fields[0]->GetTotPoints();
382  // Allocation of geometry memory
383  m_GeometricInfo = Array<OneD, Array<OneD, NekDouble> >(5);
384  for (int i = 0; i < m_GeometricInfo.num_elements(); i++)
385  {
386  m_GeometricInfo[i] = Array<OneD, NekDouble>(phystot, 0.0);
387  }
388 
389  bool waveSpace = m_fields[0]->GetWaveSpace();
390  m_fields[0]->SetWaveSpace(false);
391 
392  // Calculate derivatives of transformation
393  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
394  m_coords[0], m_GeometricInfo[0]); //f_x
395  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
396  m_coords[0], m_GeometricInfo[1]); //f_z
397 
398  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
399  m_GeometricInfo[0], m_GeometricInfo[2]); //f_xx
400  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
401  m_GeometricInfo[0], m_GeometricInfo[3]); //f_xz
402  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
403  m_GeometricInfo[1], m_GeometricInfo[4]); //f_zz
404 
405  m_fields[0]->SetWaveSpace(waveSpace);
406 }
407 
408 
409 }
410 }
Nektar::GlobalMapping::Mapping::m_GeometricInfo
Array< OneD, Array< OneD, NekDouble > > m_GeometricInfo
Array with metric terms of the mapping.
Definition: Mapping.h:415
Nektar::GlobalMapping::Mapping::m_coords
Array< OneD, Array< OneD, NekDouble > > m_coords
Array with the Cartesian coordinates.
Definition: Mapping.h:411
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
Nektar::GlobalMapping::MappingXofXZ::v_LowerIndex
virtual GLOBAL_MAPPING_EXPORT void v_LowerIndex(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:252
Nektar::GlobalMapping::GetMappingFactory
MappingFactory & GetMappingFactory()
Declaration of the mapping factory singleton.
Definition: Mapping.cpp:49
Nektar::GlobalMapping::MappingXofXZ::v_GetJacobian
virtual GLOBAL_MAPPING_EXPORT void v_GetJacobian(Array< OneD, NekDouble > &outarray)
Definition: MappingXofXZ.cpp:162
Nektar::GlobalMapping::MappingXofXZ::v_ContravarFromCartesian
virtual GLOBAL_MAPPING_EXPORT void v_ContravarFromCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:121
Nektar::GlobalMapping::MappingXofXZ::v_InitObject
virtual GLOBAL_MAPPING_EXPORT void v_InitObject(const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping)
Definition: MappingXofXZ.cpp:69
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:442
Nektar::GlobalMapping::MappingXofXZ::className
static std::string className
Name of the class.
Definition: MappingXofXZ.h:73
Vmath::Vdiv
void Vdiv(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x/y.
Definition: Vmath.cpp:241
Nektar::GlobalMapping::MappingXofXZ::create
static GLOBAL_MAPPING_EXPORT MappingSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping)
Creates an instance of this class.
Definition: MappingXofXZ.h:60
Nektar::LibUtilities::SessionReaderSharedPtr
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:51
Nektar::GlobalMapping::Mapping::m_nConvectiveFields
int m_nConvectiveFields
Number of velocity components.
Definition: Mapping.h:417
Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelCovar
virtual GLOBAL_MAPPING_EXPORT void v_ApplyChristoffelCovar(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:347
Nektar::GlobalMapping::Mapping::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Mapping.h:409
Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor
virtual GLOBAL_MAPPING_EXPORT void v_GetInvMetricTensor(Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:215
Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex
virtual GLOBAL_MAPPING_EXPORT void v_RaiseIndex(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:283
Nektar::GlobalMapping::MappingXofXZ::v_GetMetricTensor
virtual GLOBAL_MAPPING_EXPORT void v_GetMetricTensor(Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:180
ExpList.h
Nektar::GlobalMapping::Mapping::v_InitObject
virtual GLOBAL_MAPPING_EXPORT void v_InitObject(const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping)
Definition: Mapping.cpp:99
Nektar::GlobalMapping::Mapping::m_constantJacobian
bool m_constantJacobian
Flag defining if the Jacobian is constant.
Definition: Mapping.h:427
Vmath::Neg
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:396
Nektar::GlobalMapping::MappingXofXZ::v_ContravarToCartesian
virtual GLOBAL_MAPPING_EXPORT void v_ContravarToCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:81
Vmath::Sadd
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
Definition: Vmath.cpp:315
Nektar::GlobalMapping::MappingXofXZ::v_CovarFromCartesian
virtual GLOBAL_MAPPING_EXPORT void v_CovarFromCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:143
Nektar::GlobalMapping::MappingXofXZ::MappingXofXZ
MappingXofXZ(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
Definition: MappingXofXZ.cpp:58
Nektar::GlobalMapping::Mapping
Base class for mapping to be applied to the coordinate system.
Definition: Mapping.h:69
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:343
Nektar::MultiRegions::DirCartesianMap
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:86
Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelContravar
virtual GLOBAL_MAPPING_EXPORT void v_ApplyChristoffelContravar(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:314
Nektar::GlobalMapping::MappingXofXZ::v_DotGradJacobian
virtual GLOBAL_MAPPING_EXPORT void v_DotGradJacobian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &outarray)
Definition: MappingXofXZ.cpp:169
MappingXofXZ.h
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:299
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:183
Nektar::GlobalMapping::MappingXofXZ::v_UpdateGeomInfo
virtual GLOBAL_MAPPING_EXPORT void v_UpdateGeomInfo()
Definition: MappingXofXZ.cpp:379
Nektar::GlobalMapping::MappingXofXZ::v_CovarToCartesian
virtual GLOBAL_MAPPING_EXPORT void v_CovarToCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: MappingXofXZ.cpp:100
Nektar::LibUtilities::NekFactory::RegisterCreatorFunction
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, tDescription pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:215
Generated on Sat Nov 25 2017 16:18:13 for Nektar++ by   doxygen 1.8.8