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