Nektar++
MappingXYofXY.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: MappingXYofXY.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,y), Y = Y(x,y)
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#include <GlobalMapping/MappingXYofXY.h>
36#include <MultiRegions/ExpList.h>
37
38namespace Nektar::GlobalMapping
39{
40
41std::string MappingXYofXY::className =
42 GetMappingFactory().RegisterCreatorFunction("XYofXY", MappingXYofXY::create,
43 "X = X(x,y), Y = Y(x,y)");
44
45/**
46 * @class MappingXYofXY
47 * This class implements a mapping defined by the transformation
48 * \f[ \bar{x} = \bar{x}(x,y) \f]
49 * \f[ \bar{y} = \bar{y}(x,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 */
55MappingXYofXY::MappingXYofXY(
56 const LibUtilities::SessionReaderSharedPtr &pSession,
57 const Array<OneD, MultiRegions::ExpListSharedPtr> &pFields)
58 : Mapping(pSession, pFields)
59{
60}
61
62/**
63 *
64 */
65void MappingXYofXY::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 >= 2,
74 "Mapping X = X(x,y), Y = Y(x,y) needs 2 velocity components.");
75}
76
77void MappingXYofXY::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 + fy*u2
84 Vmath::Vmul(physTot, m_GeometricInfo[0], 1, inarray[0], 1, outarray[0], 1);
85 Vmath::Vvtvp(physTot, m_GeometricInfo[1], 1, inarray[1], 1, outarray[0], 1,
86 outarray[0], 1);
87
88 // U2 = gx*u1+gy*u2
89 Vmath::Vmul(physTot, m_GeometricInfo[2], 1, inarray[0], 1, outarray[1], 1);
90 Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, inarray[1], 1, outarray[1], 1,
91 outarray[1], 1);
92
93 // U3 = u3
94 if (m_nConvectiveFields == 3)
95 {
96 Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
97 }
98}
99
100void MappingXYofXY::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 = [gy*u1-gx*u2]/(fx*gy-gx*fy)
108 Vmath::Vmul(physTot, inarray[1], 1, m_GeometricInfo[2], 1, outarray[0], 1);
109 Vmath::Vvtvm(physTot, inarray[0], 1, m_GeometricInfo[3], 1, outarray[0], 1,
110 outarray[0], 1);
111 Vmath::Vdiv(physTot, outarray[0], 1, m_GeometricInfo[4], 1, outarray[0], 1);
112
113 // U2 = [fx*u2 - fy*u1]/(fx*gy-gx*fy)
114 Vmath::Vmul(physTot, inarray[0], 1, m_GeometricInfo[1], 1, outarray[1], 1);
115 Vmath::Vvtvm(physTot, inarray[1], 1, m_GeometricInfo[0], 1, outarray[1], 1,
116 outarray[1], 1);
117 Vmath::Vdiv(physTot, outarray[1], 1, m_GeometricInfo[4], 1, outarray[1], 1);
118
119 // U3 = u3
120 if (m_nConvectiveFields == 3)
121 {
122 Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
123 }
124}
125
126void MappingXYofXY::v_ContravarFromCartesian(
127 const Array<OneD, Array<OneD, NekDouble>> &inarray,
128 Array<OneD, Array<OneD, NekDouble>> &outarray)
129{
130 int physTot = m_fields[0]->GetTotPoints();
131 Array<OneD, NekDouble> wk(physTot, 0.0);
132
133 // U1 = [gy*u1-fy*u2]/(fx*gy-gx*fy)
134 Vmath::Vmul(physTot, inarray[1], 1, m_GeometricInfo[1], 1, outarray[0], 1);
135 Vmath::Vvtvm(physTot, inarray[0], 1, m_GeometricInfo[3], 1, outarray[0], 1,
136 outarray[0], 1);
137 Vmath::Vdiv(physTot, outarray[0], 1, m_GeometricInfo[4], 1, outarray[0], 1);
138
139 // U2 = [fx*u2-gx*u1]/(fx*gy-gx*fy)
140 Vmath::Vmul(physTot, inarray[0], 1, m_GeometricInfo[2], 1, outarray[1], 1);
141 Vmath::Vvtvm(physTot, inarray[1], 1, m_GeometricInfo[0], 1, outarray[1], 1,
142 outarray[1], 1);
143 Vmath::Vdiv(physTot, outarray[1], 1, m_GeometricInfo[4], 1, outarray[1], 1);
144
145 // U3 = u3
146 if (m_nConvectiveFields == 3)
147 {
148 Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
149 }
150}
151
152void MappingXYofXY::v_CovarFromCartesian(
153 const Array<OneD, Array<OneD, NekDouble>> &inarray,
154 Array<OneD, Array<OneD, NekDouble>> &outarray)
155{
156 int physTot = m_fields[0]->GetTotPoints();
157
158 // U1 = u1*fx +gx*u2
159 Vmath::Vmul(physTot, m_GeometricInfo[0], 1, inarray[0], 1, outarray[0], 1);
160 Vmath::Vvtvp(physTot, m_GeometricInfo[2], 1, inarray[1], 1, outarray[0], 1,
161 outarray[0], 1);
162
163 // U2 = fy*u1 + gy*u2
164 Vmath::Vmul(physTot, m_GeometricInfo[1], 1, inarray[0], 1, outarray[1], 1);
165 Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, inarray[1], 1, outarray[1], 1,
166 outarray[1], 1);
167
168 // U3 = u3
169 if (m_nConvectiveFields == 3)
170 {
171 Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
172 }
173}
174
175void MappingXYofXY::v_GetJacobian(Array<OneD, NekDouble> &outarray)
176{
177 int physTot = m_fields[0]->GetTotPoints();
178 Vmath::Vabs(physTot, m_GeometricInfo[4], 1, outarray, 1);
179}
180
181void MappingXYofXY::v_GetMetricTensor(
182 Array<OneD, Array<OneD, NekDouble>> &outarray)
183{
184 int physTot = m_fields[0]->GetTotPoints();
185 int nvel = m_nConvectiveFields;
186
187 for (int i = 0; i < nvel * nvel; i++)
188 {
189 outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
190 }
191
192 // g_{1,1} = m_metricTensor[0]
193 Vmath::Vcopy(physTot, m_metricTensor[0], 1, outarray[0 * nvel + 0], 1);
194
195 // g_{2,2} = m_metricTensor[1]
196 Vmath::Vcopy(physTot, m_metricTensor[1], 1, outarray[1 * nvel + 1], 1);
197
198 // g_{1,2}=g{2,1} = m_metricTensor[2]
199 Vmath::Vcopy(physTot, m_metricTensor[2], 1, outarray[0 * nvel + 1], 1);
200 Vmath::Vcopy(physTot, m_metricTensor[2], 1, outarray[1 * nvel + 0], 1);
201
202 // g_{3,3} = 1
203 if (m_nConvectiveFields == 3)
204 {
205 Vmath::Sadd(physTot, 1.0, outarray[2 * nvel + 2], 1,
206 outarray[2 * nvel + 2], 1);
207 }
208}
209
210void MappingXYofXY::v_GetInvMetricTensor(
211 Array<OneD, Array<OneD, NekDouble>> &outarray)
212{
213 int physTot = m_fields[0]->GetTotPoints();
214 int nvel = m_nConvectiveFields;
215
216 for (int i = 0; i < nvel * nvel; i++)
217 {
218 outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
219 }
220
221 // Get Jacobian
222 Array<OneD, NekDouble> Jac(physTot, 0.0);
223 GetJacobian(Jac);
224
225 // Get Jacobian squared
226 Array<OneD, NekDouble> wk(physTot, 0.0);
227 Vmath::Vmul(physTot, Jac, 1, Jac, 1, wk, 1);
228 // G^{1,1} = m_metricTensor[1]/Jac^2
229 Vmath::Vcopy(physTot, m_metricTensor[1], 1, outarray[0 * nvel + 0], 1);
230 Vmath::Vdiv(physTot, outarray[0 * nvel + 0], 1, wk, 1,
231 outarray[0 * nvel + 0], 1);
232
233 // G^{2,2} = m_metricTensor[0]/Jac^2
234 Vmath::Vcopy(physTot, m_metricTensor[0], 1, outarray[1 * nvel + 1], 1);
235 Vmath::Vdiv(physTot, outarray[1 * nvel + 1], 1, wk, 1,
236 outarray[1 * nvel + 1], 1);
237
238 // G^{1,2} = G^{2,1} = -m_metricTensor[2]/Jac^2
239 Vmath::Vcopy(physTot, m_metricTensor[2], 1, outarray[0 * nvel + 1], 1);
240 Vmath::Neg(physTot, outarray[0 * nvel + 1], 1);
241 Vmath::Vdiv(physTot, outarray[0 * nvel + 1], 1, wk, 1,
242 outarray[0 * nvel + 1], 1);
243 Vmath::Vcopy(physTot, outarray[0 * nvel + 1], 1, outarray[1 * nvel + 0], 1);
244
245 // G^{3,3} = 1
246 if (m_nConvectiveFields == 3)
247 {
248 Vmath::Sadd(physTot, 1.0, outarray[2 * nvel + 2], 1,
249 outarray[2 * nvel + 2], 1);
250 }
251}
252
253void MappingXYofXY::v_ApplyChristoffelContravar(
254 const Array<OneD, Array<OneD, NekDouble>> &inarray,
255 Array<OneD, Array<OneD, NekDouble>> &outarray)
256{
257 int physTot = m_fields[0]->GetTotPoints();
258 int nvel = m_nConvectiveFields;
259
260 for (int i = 0; i < nvel; i++)
261 {
262 for (int j = 0; j < nvel; j++)
263 {
264 outarray[i * nvel + j] = Array<OneD, NekDouble>(physTot, 0.0);
265 }
266 }
267
268 // Calculate non-zero terms
269
270 // outarray(0,0) = U1 * m_Christoffel[0] + U2 * m_Christoffel[1]
271 Vmath::Vmul(physTot, m_Christoffel[0], 1, inarray[0], 1,
272 outarray[0 * nvel + 0], 1);
273 Vmath::Vvtvp(physTot, m_Christoffel[1], 1, inarray[1], 1,
274 outarray[0 * nvel + 0], 1, outarray[0 * nvel + 0], 1);
275
276 // outarray(0,1) = U1 * m_Christoffel[1] + U2 * m_Christoffel[2]
277 Vmath::Vmul(physTot, m_Christoffel[1], 1, inarray[0], 1,
278 outarray[0 * nvel + 1], 1);
279 Vmath::Vvtvp(physTot, m_Christoffel[2], 1, inarray[1], 1,
280 outarray[0 * nvel + 1], 1, outarray[0 * nvel + 1], 1);
281
282 // outarray(1,0) = U1 * m_Christoffel[3] + U2 * m_Christoffel[4]
283 Vmath::Vmul(physTot, m_Christoffel[3], 1, inarray[0], 1,
284 outarray[1 * nvel + 0], 1);
285 Vmath::Vvtvp(physTot, m_Christoffel[4], 1, inarray[1], 1,
286 outarray[1 * nvel + 0], 1, outarray[1 * nvel + 0], 1);
287
288 // outarray(1,1) = U1 * m_Christoffel[4] + U2 * m_Christoffel[5]
289 Vmath::Vmul(physTot, m_Christoffel[4], 1, inarray[0], 1,
290 outarray[1 * nvel + 1], 1);
291 Vmath::Vvtvp(physTot, m_Christoffel[5], 1, inarray[1], 1,
292 outarray[1 * nvel + 1], 1, outarray[1 * nvel + 1], 1);
293}
294
295void MappingXYofXY::v_ApplyChristoffelCovar(
296 const Array<OneD, Array<OneD, NekDouble>> &inarray,
297 Array<OneD, Array<OneD, NekDouble>> &outarray)
298{
299 int physTot = m_fields[0]->GetTotPoints();
300 int nvel = m_nConvectiveFields;
301
302 for (int i = 0; i < nvel; i++)
303 {
304 for (int j = 0; j < nvel; j++)
305 {
306 outarray[i * nvel + j] = Array<OneD, NekDouble>(physTot, 0.0);
307 }
308 }
309
310 // Calculate non-zero terms
311
312 // outarray(0,0) = U1 * m_Christoffel[0] + U2 * m_Christoffel[3]
313 Vmath::Vmul(physTot, m_Christoffel[0], 1, inarray[0], 1,
314 outarray[0 * nvel + 0], 1);
315 Vmath::Vvtvp(physTot, m_Christoffel[3], 1, inarray[1], 1,
316 outarray[0 * nvel + 0], 1, outarray[0 * nvel + 0], 1);
317
318 // outarray(0,1) = U1 * m_Christoffel[1] + U2 * m_Christoffel[4]
319 Vmath::Vmul(physTot, m_Christoffel[1], 1, inarray[0], 1,
320 outarray[0 * nvel + 1], 1);
321 Vmath::Vvtvp(physTot, m_Christoffel[4], 1, inarray[1], 1,
322 outarray[0 * nvel + 1], 1, outarray[0 * nvel + 1], 1);
323
324 // outarray(1,0) = U1 * m_Christoffel[1] + U2 * m_Christoffel[4]
325 Vmath::Vmul(physTot, m_Christoffel[1], 1, inarray[0], 1,
326 outarray[1 * nvel + 0], 1);
327 Vmath::Vvtvp(physTot, m_Christoffel[4], 1, inarray[1], 1,
328 outarray[1 * nvel + 0], 1, outarray[1 * nvel + 0], 1);
329
330 // outarray(1,1) = U1 * m_Christoffel[2] + U2 * m_Christoffel[5]
331 Vmath::Vmul(physTot, m_Christoffel[2], 1, inarray[0], 1,
332 outarray[1 * nvel + 1], 1);
333 Vmath::Vvtvp(physTot, m_Christoffel[5], 1, inarray[1], 1,
334 outarray[1 * nvel + 1], 1, outarray[1 * nvel + 1], 1);
335}
336
337void MappingXYofXY::v_UpdateGeomInfo()
338{
339 int phystot = m_fields[0]->GetTotPoints();
340 // Allocation of geometry memory
341 m_GeometricInfo = Array<OneD, Array<OneD, NekDouble>>(5);
342 for (int i = 0; i < m_GeometricInfo.size(); i++)
343 {
344 m_GeometricInfo[i] = Array<OneD, NekDouble>(phystot, 0.0);
345 }
346
347 bool waveSpace = m_fields[0]->GetWaveSpace();
348 m_fields[0]->SetWaveSpace(false);
349
350 // Calculate derivatives of x transformation --> m_GeometricInfo 0-1
351 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], m_coords[0],
352 m_GeometricInfo[0]);
353 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], m_coords[0],
354 m_GeometricInfo[1]);
355
356 // Calculate derivatives of y transformation m_GeometricInfo 2-3
357 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], m_coords[1],
358 m_GeometricInfo[2]);
359 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], m_coords[1],
360 m_GeometricInfo[3]);
361
362 // Calculate fx*gy-gx*fy --> m_GeometricInfo4
363 Vmath::Vmul(phystot, m_GeometricInfo[1], 1, m_GeometricInfo[2], 1,
364 m_GeometricInfo[4], 1);
365 Vmath::Vvtvm(phystot, m_GeometricInfo[0], 1, m_GeometricInfo[3], 1,
366 m_GeometricInfo[4], 1, m_GeometricInfo[4], 1);
367 //
368 CalculateMetricTensor();
369 CalculateChristoffel();
370
371 m_fields[0]->SetWaveSpace(waveSpace);
372}
373
374void MappingXYofXY::CalculateMetricTensor()
375{
376 int physTot = m_fields[0]->GetTotPoints();
377 // Allocate memory
378 m_metricTensor = Array<OneD, Array<OneD, NekDouble>>(3);
379 for (int i = 0; i < m_metricTensor.size(); i++)
380 {
381 m_metricTensor[i] = Array<OneD, NekDouble>(physTot, 0.0);
382 }
383 // g_{1,1} = fx^2+gx^2
384 Vmath::Vmul(physTot, m_GeometricInfo[0], 1, m_GeometricInfo[0], 1,
385 m_metricTensor[0], 1);
386 Vmath::Vvtvp(physTot, m_GeometricInfo[2], 1, m_GeometricInfo[2], 1,
387 m_metricTensor[0], 1, m_metricTensor[0], 1);
388 // g_{2,2} = fy^2+gy^2
389 Vmath::Vmul(physTot, m_GeometricInfo[1], 1, m_GeometricInfo[1], 1,
390 m_metricTensor[1], 1);
391 Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, m_GeometricInfo[3], 1,
392 m_metricTensor[1], 1, m_metricTensor[1], 1);
393 // g_{1,2} = g_{2,1} = fy*fx+gx*gy
394 Vmath::Vmul(physTot, m_GeometricInfo[0], 1, m_GeometricInfo[1], 1,
395 m_metricTensor[2], 1);
396 Vmath::Vvtvp(physTot, m_GeometricInfo[2], 1, m_GeometricInfo[3], 1,
397 m_metricTensor[2], 1, m_metricTensor[2], 1);
398}
399
400void MappingXYofXY::CalculateChristoffel()
401{
402 int physTot = m_fields[0]->GetTotPoints();
403 int nvel = m_nConvectiveFields;
404
405 Array<OneD, Array<OneD, NekDouble>> G(nvel * nvel);
406 Array<OneD, Array<OneD, NekDouble>> G_inv(nvel * nvel);
407 Array<OneD, Array<OneD, NekDouble>> gradG(2 * 2 * 2);
408 Array<OneD, Array<OneD, NekDouble>> tmp(2 * 2 * 2);
409 m_Christoffel = Array<OneD, Array<OneD, NekDouble>>(6);
410 // Allocate memory
411 for (int i = 0; i < gradG.size(); i++)
412 {
413 gradG[i] = Array<OneD, NekDouble>(physTot, 0.0);
414 tmp[i] = Array<OneD, NekDouble>(physTot, 0.0);
415 }
416 for (int i = 0; i < G.size(); i++)
417 {
418 G[i] = Array<OneD, NekDouble>(physTot, 0.0);
419 G_inv[i] = Array<OneD, NekDouble>(physTot, 0.0);
420 }
421
422 // Get the metric tensor and its inverse
423 GetMetricTensor(G);
424 GetInvMetricTensor(G_inv);
425
426 bool waveSpace = m_fields[0]->GetWaveSpace();
427 m_fields[0]->SetWaveSpace(false);
428 // Calculate gradients of g
429 // consider only 2 dimensions, since the 3rd is trivial
430 for (int i = 0; i < 2; i++)
431 {
432 for (int j = 0; j < 2; j++)
433 {
434 for (int k = 0; k < 2; k++)
435 {
436 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[k],
437 G[i * nvel + j],
438 gradG[i * 2 * 2 + j * 2 + k]);
439 }
440 }
441 }
442
443 // Calculate tmp[p,j,k] = 1/2( gradG[pj,k]+ gradG[pk,j]-gradG[jk,p])
444 for (int p = 0; p < 2; p++)
445 {
446 for (int j = 0; j < 2; j++)
447 {
448 for (int k = 0; k < 2; k++)
449 {
450 Vmath::Vadd(physTot, gradG[p * 2 * 2 + j * 2 + k], 1,
451 gradG[p * 2 * 2 + k * 2 + j], 1,
452 tmp[p * 2 * 2 + j * 2 + k], 1);
453 Vmath::Vsub(physTot, tmp[p * 2 * 2 + j * 2 + k], 1,
454 gradG[j * 2 * 2 + k * 2 + p], 1,
455 tmp[p * 2 * 2 + j * 2 + k], 1);
456 Vmath::Smul(physTot, 0.5, tmp[p * 2 * 2 + j * 2 + k], 1,
457 tmp[p * 2 * 2 + j * 2 + k], 1);
458 }
459 }
460 }
461
462 // Calculate Christoffel symbols = g^ip tmp[p,j,k]
463 int n = 0;
464 for (int i = 0; i < 2; i++)
465 {
466 for (int j = 0; j < 2; j++)
467 {
468 for (int k = 0; k <= j; k++)
469 {
470 m_Christoffel[n] = Array<OneD, NekDouble>(physTot, 0.0);
471 for (int p = 0; p < 2; p++)
472 {
473 Vmath::Vvtvp(physTot, G_inv[i * nvel + p], 1,
474 tmp[p * 2 * 2 + j * 2 + k], 1,
475 m_Christoffel[n], 1, m_Christoffel[n], 1);
476 }
477 n = n + 1;
478 }
479 }
480 }
481
482 m_fields[0]->SetWaveSpace(waveSpace);
483}
484
485} // 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::GetInvMetricTensor
GLOBAL_MAPPING_EXPORT void GetInvMetricTensor(Array< OneD, Array< OneD, NekDouble > > &outarray)
Get the inverse of metric tensor .
Definition: Mapping.h:182
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::GetMetricTensor
GLOBAL_MAPPING_EXPORT void GetMetricTensor(Array< OneD, Array< OneD, NekDouble > > &outarray)
Get the metric tensor .
Definition: Mapping.h:175
Nektar::GlobalMapping::Mapping::GetJacobian
GLOBAL_MAPPING_EXPORT void GetJacobian(Array< OneD, NekDouble > &outarray)
Get the Jacobian of the transformation.
Definition: Mapping.h:153
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::MappingXYofXY::className
static std::string className
Name of the class.
Definition: MappingXYofXY.h:68
Nektar::GlobalMapping::MappingXYofXY::v_CovarToCartesian
GLOBAL_MAPPING_EXPORT void v_CovarToCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:100
Nektar::GlobalMapping::MappingXYofXY::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: MappingXYofXY.h:56
Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelCovar
GLOBAL_MAPPING_EXPORT void v_ApplyChristoffelCovar(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:295
Nektar::GlobalMapping::MappingXYofXY::MappingXYofXY
MappingXYofXY(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
Definition: MappingXYofXY.cpp:55
Nektar::GlobalMapping::MappingXYofXY::m_metricTensor
Array< OneD, Array< OneD, NekDouble > > m_metricTensor
Definition: MappingXYofXY.h:77
Nektar::GlobalMapping::MappingXYofXY::m_Christoffel
Array< OneD, Array< OneD, NekDouble > > m_Christoffel
Definition: MappingXYofXY.h:78
Nektar::GlobalMapping::MappingXYofXY::v_GetMetricTensor
GLOBAL_MAPPING_EXPORT void v_GetMetricTensor(Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:181
Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelContravar
GLOBAL_MAPPING_EXPORT void v_ApplyChristoffelContravar(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:253
Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo
GLOBAL_MAPPING_EXPORT void v_UpdateGeomInfo() override
Definition: MappingXYofXY.cpp:337
Nektar::GlobalMapping::MappingXYofXY::v_CovarFromCartesian
GLOBAL_MAPPING_EXPORT void v_CovarFromCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:152
Nektar::GlobalMapping::MappingXYofXY::v_GetJacobian
GLOBAL_MAPPING_EXPORT void v_GetJacobian(Array< OneD, NekDouble > &outarray) override
Definition: MappingXYofXY.cpp:175
Nektar::GlobalMapping::MappingXYofXY::v_InitObject
GLOBAL_MAPPING_EXPORT void v_InitObject(const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping) override
Definition: MappingXYofXY.cpp:65
Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor
GLOBAL_MAPPING_EXPORT void v_GetInvMetricTensor(Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:210
Nektar::GlobalMapping::MappingXYofXY::v_ContravarToCartesian
GLOBAL_MAPPING_EXPORT void v_ContravarToCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:77
Nektar::GlobalMapping::MappingXYofXY::v_ContravarFromCartesian
GLOBAL_MAPPING_EXPORT void v_ContravarFromCartesian(const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: MappingXYofXY.cpp:126
Nektar::LibUtilities::NekFactory::RegisterCreatorFunction
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:197
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
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::Vabs
void Vabs(int n, const T *x, const int incx, T *y, const int incy)
vabs: y = |x|
Definition: Vmath.hpp:352
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::Vvtvm
void Vvtvm(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)
vvtvm (vector times vector minus vector): z = w*x - y
Definition: Vmath.hpp:381
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.hpp:100
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