OPAL (Object Oriented Parallel Accelerator Library) 2022.1
OPAL
UniformCartesian.h
Go to the documentation of this file.
1// -*- C++ -*-
2/***************************************************************************
3 *
4 * The IPPL Framework
5 *
6 *
7 * Visit http://people.web.psi.ch/adelmann/ for more details
8 *
9 ***************************************************************************/
10
11#ifndef UNIFORM_CARTESIAN_H
12#define UNIFORM_CARTESIAN_H
13
14// UniformCartesian.h
15// UniformCartesian class - represents uniform-spacing cartesian meshes.
16
17// include files
18#include "Meshes/Mesh.h"
19#include "Meshes/Centering.h"
20#include "Meshes/CartesianCentering.h"
21#include "AppTypes/Vektor.h"
22
23// forward declarations
24template<class T, unsigned D> class BareField;
25template<class T, unsigned D, class M, class C> class Field;
26template <unsigned Dim, class MFLOAT> class UniformCartesian;
27template <unsigned Dim, class MFLOAT>
28std::ostream& operator<<(std::ostream&, const UniformCartesian<Dim,MFLOAT>&);
29template <unsigned Dim, class MFLOAT>
30Inform& operator<<(Inform&, const UniformCartesian<Dim,MFLOAT>&);
31
32template <unsigned Dim, class MFLOAT=double>
33class UniformCartesian : public Mesh<Dim>
34{
35public:
36 //# public typedefs
37 typedef Cell DefaultCentering;
38 typedef MFLOAT MeshValue_t;
39 typedef Vektor<MFLOAT,Dim> MeshVektor_t;
40
41 // Default constructor (use initialize() to make valid)
42 UniformCartesian()
43 {
44 hasSpacingFields = false;
45 };
46 // Destructor
47 ~UniformCartesian()
48 {
49 if (hasSpacingFields) {
50 delete VertSpacings;
51 delete CellSpacings;
52 delete FlVert;
53 delete FlCell;
54 }
55 };
56
57 // Non-default constructors
58 UniformCartesian(const NDIndex<Dim>& ndi);
59 UniformCartesian(const Index& I);
60 UniformCartesian(const Index& I, const Index& J);
61 UniformCartesian(const Index& I, const Index& J, const Index& K);
62 // These also take a MFLOAT* specifying the mesh spacings:
63 UniformCartesian(const NDIndex<Dim>& ndi, MFLOAT* const delX);
64 UniformCartesian(const Index& I, MFLOAT* const delX);
65 UniformCartesian(const Index& I, const Index& J, MFLOAT* const delX);
66 UniformCartesian(const Index& I, const Index& J, const Index& K,
67 MFLOAT* const delX);
68 // These further take a Vektor<MFLOAT,Dim>& specifying the origin:
69 UniformCartesian(const NDIndex<Dim>& ndi, MFLOAT* const delX,
70 const Vektor<MFLOAT,Dim>& orig);
71 UniformCartesian(const Index& I, MFLOAT* const delX,
72 const Vektor<MFLOAT,Dim>& orig);
73 UniformCartesian(const Index& I, const Index& J, MFLOAT* const delX,
74 const Vektor<MFLOAT,Dim>& orig);
75 UniformCartesian(const Index& I, const Index& J, const Index& K,
76 MFLOAT* const delX, const Vektor<MFLOAT,Dim>& orig);
77
78 // initialize functions
79 void initialize(const NDIndex<Dim>& ndi);
80 void initialize(const Index& I);
81 void initialize(const Index& I, const Index& J);
82 void initialize(const Index& I, const Index& J, const Index& K);
83 // These also take a MFLOAT* specifying the mesh spacings:
84 void initialize(const NDIndex<Dim>& ndi, MFLOAT* const delX);
85 void initialize(const Index& I, MFLOAT* const delX);
86 void initialize(const Index& I, const Index& J, MFLOAT* const delX);
87 void initialize(const Index& I, const Index& J, const Index& K,
88 MFLOAT* const delX);
89 // These further take a Vektor<MFLOAT,Dim>& specifying the origin:
90 void initialize(const NDIndex<Dim>& ndi, MFLOAT* const delX,
91 const Vektor<MFLOAT,Dim>& orig);
92 void initialize(const Index& I, MFLOAT* const delX,
93 const Vektor<MFLOAT,Dim>& orig);
94 void initialize(const Index& I, const Index& J, MFLOAT* const delX,
95 const Vektor<MFLOAT,Dim>& orig);
96 void initialize(const Index& I, const Index& J, const Index& K,
97 MFLOAT* const delX, const Vektor<MFLOAT,Dim>& orig);
98
99
100private:
101
102 // Private member data:
103 MFLOAT meshSpacing[Dim]; // delta-x, delta-y (>1D), delta-z (>2D)
104 MFLOAT volume; // Cell length(1D), area(2D), or volume (>2D)
105 Vektor<MFLOAT,Dim> origin; // Origin of mesh coordinates (vertices)
106 FieldLayout<Dim>* FlCell; // Layouts for BareField* CellSpacings
107 FieldLayout<Dim>* FlVert; // Layouts for BareField* VertSpacings
108
109 // Private member functions:
110 void setup(); // Private function doing tasks common to all constructors.
111 // Set only the derivative constants, using pre-set spacings:
112 void set_Dvc();
113
114
115public:
116
117 // Public member data:
118 unsigned gridSizes[Dim]; // Sizes (number of vertices)
119 Vektor<MFLOAT,Dim> Dvc[1<<Dim]; // Constants for derivatives.
120 bool hasSpacingFields; // Flags allocation of the following:
121 BareField<Vektor<MFLOAT,Dim>,Dim>* VertSpacings;
122 BareField<Vektor<MFLOAT,Dim>,Dim>* CellSpacings;
123
124 // Public member functions:
125
126 // Create BareField's of vertex and cell spacings; allow for specifying
127 // layouts via the FieldLayout e_dim_tag and vnodes parameters (these
128 // get passed in to construct the FieldLayout used to construct the
129 // BareField's).
130 void storeSpacingFields(); // Default; will have default layout
131 // Special cases for 1-3 dimensions, ala FieldLayout ctors:
132 void storeSpacingFields(e_dim_tag p1, int vnodes=-1);
133 void storeSpacingFields(e_dim_tag p1, e_dim_tag p2, int vnodes=-1);
134 void storeSpacingFields(e_dim_tag p1, e_dim_tag p2, e_dim_tag p3,
135 int vnodes=-1);
136 // Next we have one for arbitrary dimension, ala FieldLayout ctor:
137 // All the others call this one internally:
138 void storeSpacingFields(e_dim_tag *p, int vnodes=-1);
139
140 // These specify both the total number of vnodes and the numbers of vnodes
141 // along each dimension for the partitioning of the index space. Obviously
142 // this restricts the number of vnodes to be a product of the numbers along
143 // each dimension (the constructor implementation checks this): Special
144 // cases for 1-3 dimensions, ala FieldLayout ctors (see FieldLayout.h for
145 // more relevant comments, including definition of recurse):
146 void storeSpacingFields(e_dim_tag p1,
147 unsigned vnodes1,
148 bool recurse=false,
149 int vnodes=-1);
150 void storeSpacingFields(e_dim_tag p1, e_dim_tag p2,
151 unsigned vnodes1, unsigned vnodes2,
152 bool recurse=false,int vnodes=-1);
153 void storeSpacingFields(e_dim_tag p1, e_dim_tag p2, e_dim_tag p3,
154 unsigned vnodes1, unsigned vnodes2, unsigned vnodes3,
155 bool recurse=false, int vnodes=-1);
156 // Next we have one for arbitrary dimension, ala FieldLayout ctor:
157 // All the others call this one internally:
158 void storeSpacingFields(e_dim_tag *p,
159 unsigned* vnodesPerDirection,
160 bool recurse=false, int vnodes=-1);
161
162 // Accessor functions for member data:
163 // Get the origin of mesh vertex positions:
164 Vektor<MFLOAT,Dim> get_origin() const;
165 // Get the spacings of mesh vertex positions along specified direction:
166 MFLOAT get_meshSpacing(unsigned d) const;
167 // Get the cell volume:
168 MFLOAT get_volume() const;
169
170 // Set functions for member data:
171 // Set the origin of mesh vertex positions:
172 void set_origin(const Vektor<MFLOAT,Dim>& o);
173 // Set the spacings of mesh vertex positions (recompute Dvc, cell volume):
174 void set_meshSpacing(MFLOAT* const del);
175
176 // Formatted output of UniformCartesian object:
177 void print(std::ostream&);
178
179 void print(Inform &);
180
181 //----Other UniformCartesian methods:----------------------------------------
182 // Volume of single cell indexed by input NDIndex;
183 MFLOAT getCellVolume(const NDIndex<Dim>&) const;
184 // Field of volumes of all cells:
185 Field<MFLOAT,Dim,UniformCartesian<Dim,MFLOAT>,Cell>&
186 getCellVolumeField(Field<MFLOAT,Dim,UniformCartesian<Dim,MFLOAT>,Cell>&) const;
187 // Volume of range of cells bounded by verticies specified by input NDIndex:
188 MFLOAT getVertRangeVolume(const NDIndex<Dim>&) const;
189 // Volume of range of cells spanned by input NDIndex (index of cells):
190 MFLOAT getCellRangeVolume(const NDIndex<Dim>&) const;
191 // Nearest vertex index to (x,y,z):
192 NDIndex<Dim> getNearestVertex(const Vektor<MFLOAT,Dim>&) const;
193 // Nearest vertex index with all vertex coordinates below (x,y,z):
194 NDIndex<Dim> getVertexBelow(const Vektor<MFLOAT,Dim>&) const;
195 // NDIndex for cell in cell-ctrd Field containing the point (x,y,z):
196 inline
197 NDIndex<Dim> getCellContaining(const Vektor<MFLOAT,Dim>& x) const
198 {
199 return getVertexBelow(x); // I think these functions are identical. -tjw
200 }
201 // (x,y,z) coordinates of indexed vertex:
202 Vektor<MFLOAT,Dim> getVertexPosition(const NDIndex<Dim>&) const;
203 // Field of (x,y,z) coordinates of all vertices:
204 Field<Vektor<MFLOAT,Dim>,Dim,UniformCartesian<Dim,MFLOAT>,Vert>&
205 getVertexPositionField(Field<Vektor<MFLOAT,Dim>,Dim,
206 UniformCartesian<Dim,MFLOAT>,Vert>& ) const;
207 // (x,y,z) coordinates of indexed cell:
208 Vektor<MFLOAT,Dim> getCellPosition(const NDIndex<Dim>&) const;
209 // Field of (x,y,z) coordinates of all cells:
210 Field<Vektor<MFLOAT,Dim>,Dim,UniformCartesian<Dim,MFLOAT>,Cell>&
211 getCellPositionField(Field<Vektor<MFLOAT,Dim>,Dim,
212 UniformCartesian<Dim,MFLOAT>,Cell>& ) const;
213 // Vertex-vertex grid spacing of indexed cell:
214 Vektor<MFLOAT,Dim> getDeltaVertex(const NDIndex<Dim>&) const;
215 // Field of vertex-vertex grid spacings of all cells:
216 Field<Vektor<MFLOAT,Dim>,Dim,UniformCartesian<Dim,MFLOAT>,Cell>&
217 getDeltaVertexField(Field<Vektor<MFLOAT,Dim>,Dim,
218 UniformCartesian<Dim,MFLOAT>,Cell>& ) const;
219 // Cell-cell grid spacing of indexed vertex:
220 Vektor<MFLOAT,Dim> getDeltaCell(const NDIndex<Dim>&) const;
221 // Field of cell-cell grid spacings of all vertices:
222 Field<Vektor<MFLOAT,Dim>,Dim,UniformCartesian<Dim,MFLOAT>,Vert>&
223 getDeltaCellField(Field<Vektor<MFLOAT,Dim>,Dim,
224 UniformCartesian<Dim,MFLOAT>,Vert>& ) const;
225 // Array of surface normals to cells adjoining indexed cell:
226 Vektor<MFLOAT,Dim>* getSurfaceNormals(const NDIndex<Dim>&) const;
227 // Array of (pointers to) Fields of surface normals to all cells:
228 void getSurfaceNormalFields(Field<Vektor<MFLOAT,Dim>,Dim,
229 UniformCartesian<Dim,MFLOAT>,Cell>** ) const;
230 // Similar functions, but specify the surface normal to a single face, using
231 // the following numbering convention: 0 means low face of 1st dim, 1 means
232 // high face of 1st dim, 2 means low face of 2nd dim, 3 means high face of
233 // 2nd dim, and so on:
234 Vektor<MFLOAT,Dim> getSurfaceNormal(const NDIndex<Dim>&, unsigned) const;
235 Field<Vektor<MFLOAT,Dim>,Dim,UniformCartesian<Dim,MFLOAT>,Cell>&
236 getSurfaceNormalField(Field<Vektor<MFLOAT,Dim>,Dim,
237 UniformCartesian<Dim,MFLOAT>,Cell>&, unsigned) const;
238
239};
240
241// I/O
242
243// Stream formatted output of UniformCartesian object:
244template< unsigned Dim, class MFLOAT >
245inline
246std::ostream& operator<<(std::ostream& out, const UniformCartesian<Dim,MFLOAT>& mesh)
247{
248 UniformCartesian<Dim,MFLOAT>& ncmesh =
249 const_cast<UniformCartesian<Dim,MFLOAT>&>(mesh);
250 ncmesh.print(out);
251 return out;
252}
253
254template< unsigned Dim, class MFLOAT >
255inline
256Inform& operator<<(Inform& out, const UniformCartesian<Dim,MFLOAT>& mesh)
257{
258 UniformCartesian<Dim,MFLOAT>& ncmesh =
259 const_cast<UniformCartesian<Dim,MFLOAT>&>(mesh);
260 ncmesh.print(out);
261 return out;
262}
263
264//*****************************************************************************
265// Stuff taken from old Cartesian.h, which now applies to UniformCartesian:
266//*****************************************************************************
267
268#ifndef CARTESIAN_STENCIL_SETUP_H
269#include "Meshes/CartesianStencilSetup.h"
270#endif
271
272//----------------------------------------------------------------------
273//
274//
275// Definitions of stencils.
276//
277// For each one we have first we have the user level function that takes
278// a Field argument and returns an expression template.
279// This is the thing the user code sees.
280// These could use some asserts to make sure the Fields have
281// enough guard cells.
282//
283// Then we have the 'apply' function that gets used in the inner loop
284// when evaluating the expression. This would be better done as a
285// member function of the tags above, but that would require member
286// function templates, which we are holding off on for now.
287//
288//----------------------------------------------------------------------
289
290//----------------------------------------------------------------------
291//
292// Divergence Vert->Cell
293//
294// First is the user function for any dimension and element types.
295// it returns a unary element type.
296//
297//----------------------------------------------------------------------
298
300//
301// Here are the old style definitions.
302//
304
305//----------------------------------------------------------------------
306// Divergence Vektor/Vert -> Scalar/Cell
307//----------------------------------------------------------------------
308template < class T, class MFLOAT >
309Field<T,1U,UniformCartesian<1U,MFLOAT>,Cell>&
310Div(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
311 Field<T,1U,UniformCartesian<1U,MFLOAT>,Cell>& r);
312//----------------------------------------------------------------------
313template < class T, class MFLOAT >
314Field<T,2U,UniformCartesian<2U,MFLOAT>,Cell>&
315Div(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
316 Field<T,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
317//----------------------------------------------------------------------
318template < class T, class MFLOAT >
319Field<T,3U,UniformCartesian<3U,MFLOAT>,Cell>&
320Div(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
321 Field<T,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
322//----------------------------------------------------------------------
323// Divergence Vektor/Cell -> Scalar/Vert
324//----------------------------------------------------------------------
325template < class T, class MFLOAT >
326Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>&
327Div(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
328 Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
329//----------------------------------------------------------------------
330template < class T, class MFLOAT >
331Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>&
332Div(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
333 Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
334//----------------------------------------------------------------------
335template < class T, class MFLOAT >
336Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>&
337Div(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
338 Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
339//----------------------------------------------------------------------
340// Divergence Vektor/Vert -> Scalar/Vert
341//----------------------------------------------------------------------
342template < class T, class MFLOAT >
343Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>&
344Div(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
345 Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
346//----------------------------------------------------------------------
347template < class T, class MFLOAT >
348Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>&
349Div(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
350 Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
351//----------------------------------------------------------------------
352template < class T, class MFLOAT >
353Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>&
354Div(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
355 Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
356//----------------------------------------------------------------------
357// Divergence Vektor/Edge -> Scalar/Vert
358//----------------------------------------------------------------------
359template < class T, class MFLOAT >
360Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>&
361Div(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Edge>& x,
362 Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
363//----------------------------------------------------------------------
364template < class T, class MFLOAT >
365Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>&
366Div(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Edge>& x,
367 Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
368//----------------------------------------------------------------------
369template < class T, class MFLOAT >
370Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>&
371Div(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Edge>& x,
372 Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
373//----------------------------------------------------------------------
374// Divergence Vektor/Cell -> Scalar/Cell
375//----------------------------------------------------------------------
376template < class T, class MFLOAT >
377Field<T,1U,UniformCartesian<1U,MFLOAT>,Cell>&
378Div(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
379 Field<T,1U,UniformCartesian<1U,MFLOAT>,Cell>& r);
380//----------------------------------------------------------------------
381template < class T, class MFLOAT >
382Field<T,2U,UniformCartesian<2U,MFLOAT>,Cell>&
383Div(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
384 Field<T,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
385//----------------------------------------------------------------------
386template < class T, class MFLOAT >
387Field<T,3U,UniformCartesian<3U,MFLOAT>,Cell>&
388Div(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
389 Field<T,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
390//----------------------------------------------------------------------
391// Divergence Tenzor/Vert -> Vektor/Cell
392//----------------------------------------------------------------------
393template < class T, class MFLOAT >
394Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>&
395Div(Field<Tenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
396 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& r);
397//----------------------------------------------------------------------
398template < class T, class MFLOAT >
399Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>&
400Div(Field<Tenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
401 Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
402//----------------------------------------------------------------------
403template < class T, class MFLOAT >
404Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>&
405Div(Field<Tenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
406 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
407//----------------------------------------------------------------------
408// Divergence Tenzor/Cell -> Vektor/Vert
409//----------------------------------------------------------------------
410template < class T, class MFLOAT >
411Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>&
412Div(Field<Tenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
413 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
414//----------------------------------------------------------------------
415template < class T, class MFLOAT >
416Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>&
417Div(Field<Tenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
418 Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
419//----------------------------------------------------------------------
420template < class T, class MFLOAT >
421Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>&
422Div(Field<Tenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
423 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
424
425//----------------------------------------------------------------------
426// Grad Scalar/Vert -> Vektor/Cell
427//----------------------------------------------------------------------
428template < class T, class MFLOAT >
429Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>&
430Grad(Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
431 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& r);
432//----------------------------------------------------------------------
433template < class T, class MFLOAT >
434Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>&
435Grad(Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
436 Field<Vektor<T,2u>,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
437//----------------------------------------------------------------------
438
440template < class T, class MFLOAT >
441Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>&
442Grad(Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
443 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
444
446template < class T, class MFLOAT >
447Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>&
448Grad1Ord(Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
449 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
450//----------------------------------------------------------------------
451// Grad Scalar/Vert -> Vektor/Edge
452//----------------------------------------------------------------------
453template < class T, class MFLOAT >
454Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Edge>&
455Grad(Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
456 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Edge>& r);
457//----------------------------------------------------------------------
458template < class T, class MFLOAT >
459Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Edge>&
460Grad(Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
461 Field<Vektor<T,2u>,2U,UniformCartesian<2U,MFLOAT>,Edge>& r);
462//----------------------------------------------------------------------
463template < class T, class MFLOAT >
464Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Edge>&
465Grad(Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
466 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Edge>& r);
467//----------------------------------------------------------------------
468// Grad Scalar/Cell -> Vektor/Vert
469//----------------------------------------------------------------------
470template < class T, class MFLOAT >
471Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>&
472Grad(Field<T,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
473 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
474//----------------------------------------------------------------------
475template < class T, class MFLOAT >
476Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>&
477Grad(Field<T,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
478 Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
479//----------------------------------------------------------------------
480template < class T, class MFLOAT >
481Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>&
482Grad(Field<T,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
483 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
484//----------------------------------------------------------------------
485// Grad Scalar/Vert -> Vektor/Vert
486//----------------------------------------------------------------------
487template < class T, class MFLOAT >
488Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>&
489Grad(Field<T,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
490 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
491//----------------------------------------------------------------------
492template < class T, class MFLOAT >
493Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>&
494Grad(Field<T,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
495 Field<Vektor<T,2u>,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
496//----------------------------------------------------------------------
497template < class T, class MFLOAT >
498Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>&
499Grad(Field<T,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
500 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
501//----------------------------------------------------------------------
502// Grad Scalar/Cell -> Vektor/Cell
503//----------------------------------------------------------------------
504template < class T, class MFLOAT >
505Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>&
506Grad(Field<T,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
507 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& r);
508//----------------------------------------------------------------------
509template < class T, class MFLOAT >
510Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>&
511Grad(Field<T,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
512 Field<Vektor<T,2u>,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
513//----------------------------------------------------------------------
514template < class T, class MFLOAT >
515Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>&
516Grad(Field<T,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
517 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
518//----------------------------------------------------------------------
519// Grad Vektor/Vert -> Tenzor/Cell
520//----------------------------------------------------------------------
521template < class T, class MFLOAT >
522Field<Tenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>&
523Grad(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
524 Field<Tenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& r);
525//----------------------------------------------------------------------
526template < class T, class MFLOAT >
527Field<Tenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>&
528Grad(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
529 Field<Tenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
530//----------------------------------------------------------------------
531template < class T, class MFLOAT >
532Field<Tenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>&
533Grad(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
534 Field<Tenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
535//----------------------------------------------------------------------
536// Grad Vektor/Cell -> Tenzor/Vert
537//----------------------------------------------------------------------
538template < class T, class MFLOAT >
539Field<Tenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>&
540Grad(Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
541 Field<Tenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
542//----------------------------------------------------------------------
543template < class T, class MFLOAT >
544Field<Tenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>&
545Grad(Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
546 Field<Tenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
547//----------------------------------------------------------------------
548template < class T, class MFLOAT >
549Field<Tenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>&
550Grad(Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
551 Field<Tenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
552//----------------------------------------------------------------------
553// Divergence SymTenzor/Vert -> Vektor/Cell
554//----------------------------------------------------------------------
555//----------------------------------------------------------------------
556template < class T, class MFLOAT >
557Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>&
558Div(Field<SymTenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
559 Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
560//----------------------------------------------------------------------
561template < class T, class MFLOAT >
562Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>&
563Div(Field<SymTenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
564 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
565//----------------------------------------------------------------------
566// Divergence SymTenzor/Cell -> Vektor/Vert
567//----------------------------------------------------------------------
568template < class T, class MFLOAT >
569Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>&
570Div(Field<SymTenzor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
571 Field<Vektor<T,1U>,1U,UniformCartesian<1U,MFLOAT>,Vert>& r);
572//----------------------------------------------------------------------
573template < class T, class MFLOAT >
574Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>&
575Div(Field<SymTenzor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
576 Field<Vektor<T,2U>,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
577//----------------------------------------------------------------------
578template < class T, class MFLOAT >
579Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>&
580Div(Field<SymTenzor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
581 Field<Vektor<T,3U>,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
582
583namespace IPPL {
584
585//----------------------------------------------------------------------
586// Weighted average Cell to Vert
587//----------------------------------------------------------------------
588template < class T1, class T2, class MFLOAT >
589Field<T1,1U,UniformCartesian<1U,MFLOAT>,Vert>&
590Average(Field<T1,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
591 Field<T2,1U,UniformCartesian<1U,MFLOAT>,Cell>& w,
592 Field<T1,1U,UniformCartesian<1U,MFLOAT>,Vert>& r) ;
593//----------------------------------------------------------------------
594template < class T1, class T2, class MFLOAT >
595Field<T1,2U,UniformCartesian<2U,MFLOAT>,Vert>&
596Average(Field<T1,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
597 Field<T2,2U,UniformCartesian<2U,MFLOAT>,Cell>& w,
598 Field<T1,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
599//----------------------------------------------------------------------
600template < class T1, class T2, class MFLOAT >
601Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>&
602Average(Field<T1,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
603 Field<T2,3U,UniformCartesian<3U,MFLOAT>,Cell>& w,
604 Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
605
606//----------------------------------------------------------------------
607// Weighted average Vert to Cell
608//----------------------------------------------------------------------
609template < class T1, class T2, class MFLOAT >
610Field<T1,1U,UniformCartesian<1U,MFLOAT>,Cell>&
611Average(Field<T1,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
612 Field<T2,1U,UniformCartesian<1U,MFLOAT>,Vert>& w,
613 Field<T1,1U,UniformCartesian<1U,MFLOAT>,Cell>& r) ;
614//----------------------------------------------------------------------
615template < class T1, class T2, class MFLOAT >
616Field<T1,2U,UniformCartesian<2U,MFLOAT>,Cell>&
617Average(Field<T1,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
618 Field<T2,2U,UniformCartesian<2U,MFLOAT>,Vert>& w,
619 Field<T1,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
620//----------------------------------------------------------------------
621template < class T1, class T2, class MFLOAT >
622Field<T1,3U,UniformCartesian<3U,MFLOAT>,Cell>&
623Average(Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
624 Field<T2,3U,UniformCartesian<3U,MFLOAT>,Vert>& w,
625 Field<T1,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
626
627//----------------------------------------------------------------------
628
629//----------------------------------------------------------------------
630// Unweighted average Cell to Vert
631//----------------------------------------------------------------------
632template < class T1, class MFLOAT >
633Field<T1,1U,UniformCartesian<1U,MFLOAT>,Vert>&
634Average(Field<T1,1U,UniformCartesian<1U,MFLOAT>,Cell>& x,
635 Field<T1,1U,UniformCartesian<1U,MFLOAT>,Vert>& r) ;
636//----------------------------------------------------------------------
637template < class T1, class MFLOAT >
638Field<T1,2U,UniformCartesian<2U,MFLOAT>,Vert>&
639Average(Field<T1,2U,UniformCartesian<2U,MFLOAT>,Cell>& x,
640 Field<T1,2U,UniformCartesian<2U,MFLOAT>,Vert>& r);
641//----------------------------------------------------------------------
642template < class T1, class MFLOAT >
643Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>&
644Average(Field<T1,3U,UniformCartesian<3U,MFLOAT>,Cell>& x,
645 Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>& r);
646
647//----------------------------------------------------------------------
648// Unweighted average Vert to Cell
649//----------------------------------------------------------------------
650template < class T1, class MFLOAT >
651Field<T1,1U,UniformCartesian<1U,MFLOAT>,Cell>&
652Average(Field<T1,1U,UniformCartesian<1U,MFLOAT>,Vert>& x,
653 Field<T1,1U,UniformCartesian<1U,MFLOAT>,Cell>& r) ;
654//----------------------------------------------------------------------
655template < class T1, class MFLOAT >
656Field<T1,2U,UniformCartesian<2U,MFLOAT>,Cell>&
657Average(Field<T1,2U,UniformCartesian<2U,MFLOAT>,Vert>& x,
658 Field<T1,2U,UniformCartesian<2U,MFLOAT>,Cell>& r);
659//----------------------------------------------------------------------
660template < class T1, class MFLOAT >
661Field<T1,3U,UniformCartesian<3U,MFLOAT>,Cell>&
662Average(Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
663 Field<T1,3U,UniformCartesian<3U,MFLOAT>,Cell>& r);
664
665//----------------------------------------------------------------------
666}
667
668#include "Meshes/UniformCartesian.hpp"
669
670#endif // UNIFORM_CARTESIAN_H
671
672/***************************************************************************
673 * $RCSfile: UniformCartesian.h,v $ $Author: adelmann $
674 * $Revision: 1.1.1.1 $ $Date: 2003/01/23 07:40:28 $
675 * IPPL_VERSION_ID: $Id: UniformCartesian.h,v 1.1.1.1 2003/01/23 07:40:28 adelmann Exp $
676 ***************************************************************************/
Dim
const unsigned Dim
Definition: P3MPoissonSolver.h:26
e_dim_tag
e_dim_tag
Definition: FieldLayout.h:55
operator<<
std::ostream & operator<<(std::ostream &, const UniformCartesian< Dim, MFLOAT > &)
Definition: UniformCartesian.h:246
Grad
Field< Vektor< T, 1U >, 1U, UniformCartesian< 1U, MFLOAT >, Cell > & Grad(Field< T, 1U, UniformCartesian< 1U, MFLOAT >, Vert > &x, Field< Vektor< T, 1U >, 1U, UniformCartesian< 1U, MFLOAT >, Cell > &r)
Definition: UniformCartesian.hpp:1804
Grad1Ord
Field< Vektor< T, 3U >, 3U, UniformCartesian< 3U, MFLOAT >, Cell > & Grad1Ord(Field< T, 3U, UniformCartesian< 3U, MFLOAT >, Vert > &x, Field< Vektor< T, 3U >, 3U, UniformCartesian< 3U, MFLOAT >, Cell > &r)
Old Grad operator.
Div
Field< T, 1U, UniformCartesian< 1U, MFLOAT >, Cell > & Div(Field< Vektor< T, 1U >, 1U, UniformCartesian< 1U, MFLOAT >, Vert > &x, Field< T, 1U, UniformCartesian< 1U, MFLOAT >, Cell > &r)
Definition: UniformCartesian.hpp:1279
IPPL::Average
Field< T1, 1U, Cartesian< 1U, MFLOAT >, Vert > & Average(Field< T1, 1U, Cartesian< 1U, MFLOAT >, Cell > &x, Field< T2, 1U, Cartesian< 1U, MFLOAT >, Cell > &w, Field< T1, 1U, Cartesian< 1U, MFLOAT >, Vert > &r)
Definition: Cartesian.hpp:3113
Tenzor
Definition: Tenzor.h:35
Vektor
Definition: Vektor.h:32
Field
Definition: Field.h:33
UniformCartesian::getVertexBelow
NDIndex< Dim > getVertexBelow(const Vektor< MFLOAT, Dim > &) const
Definition: UniformCartesian.hpp:1006
UniformCartesian::getSurfaceNormalFields
void getSurfaceNormalFields(Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > **) const
Definition: UniformCartesian.hpp:1176
UniformCartesian::CellSpacings
BareField< Vektor< MFLOAT, Dim >, Dim > * CellSpacings
Definition: UniformCartesian.h:122
UniformCartesian::getDeltaCellField
Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Vert > & getDeltaCellField(Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Vert > &) const
Definition: UniformCartesian.hpp:1145
UniformCartesian::set_origin
void set_origin(const Vektor< MFLOAT, Dim > &o)
Definition: UniformCartesian.hpp:412
UniformCartesian::getCellContaining
NDIndex< Dim > getCellContaining(const Vektor< MFLOAT, Dim > &x) const
Definition: UniformCartesian.h:197
UniformCartesian::getSurfaceNormals
Vektor< MFLOAT, Dim > * getSurfaceNormals(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:1158
UniformCartesian::getCellVolumeField
Field< MFLOAT, Dim, UniformCartesian< Dim, MFLOAT >, Cell > & getCellVolumeField(Field< MFLOAT, Dim, UniformCartesian< Dim, MFLOAT >, Cell > &) const
Definition: UniformCartesian.hpp:928
UniformCartesian::getVertexPosition
Vektor< MFLOAT, Dim > getVertexPosition(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:1025
UniformCartesian::gridSizes
unsigned gridSizes[Dim]
Definition: UniformCartesian.h:118
UniformCartesian::origin
Vektor< MFLOAT, Dim > origin
Definition: UniformCartesian.h:105
UniformCartesian::FlCell
FieldLayout< Dim > * FlCell
Definition: UniformCartesian.h:106
UniformCartesian::getDeltaVertexField
Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > & getDeltaVertexField(Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > &) const
Definition: UniformCartesian.hpp:1118
UniformCartesian::get_meshSpacing
MFLOAT get_meshSpacing(unsigned d) const
Definition: UniformCartesian.hpp:461
UniformCartesian::MeshVektor_t
Vektor< MFLOAT, Dim > MeshVektor_t
Definition: UniformCartesian.h:39
UniformCartesian::getSurfaceNormalField
Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > & getSurfaceNormalField(Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > &, unsigned) const
Definition: UniformCartesian.hpp:1233
UniformCartesian::get_volume
MFLOAT get_volume() const
Definition: UniformCartesian.hpp:471
UniformCartesian::getDeltaVertex
Vektor< MFLOAT, Dim > getDeltaVertex(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:1105
UniformCartesian::getCellVolume
MFLOAT getCellVolume(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:915
UniformCartesian::getCellRangeVolume
MFLOAT getCellRangeVolume(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:962
UniformCartesian::getCellPositionField
Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > & getCellPositionField(Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Cell > &) const
Definition: UniformCartesian.hpp:1083
UniformCartesian::meshSpacing
MFLOAT meshSpacing[Dim]
Definition: UniformCartesian.h:103
UniformCartesian::getVertexPositionField
Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Vert > & getVertexPositionField(Field< Vektor< MFLOAT, Dim >, Dim, UniformCartesian< Dim, MFLOAT >, Vert > &) const
Definition: UniformCartesian.hpp:1043
UniformCartesian::set_meshSpacing
void set_meshSpacing(MFLOAT *const del)
Definition: UniformCartesian.hpp:428
UniformCartesian::getNearestVertex
NDIndex< Dim > getNearestVertex(const Vektor< MFLOAT, Dim > &) const
Definition: UniformCartesian.hpp:987
UniformCartesian::FlVert
FieldLayout< Dim > * FlVert
Definition: UniformCartesian.h:107
UniformCartesian::getVertRangeVolume
MFLOAT getVertRangeVolume(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:938
UniformCartesian::getCellPosition
Vektor< MFLOAT, Dim > getCellPosition(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:1065
UniformCartesian::print
void print(std::ostream &)
Definition: UniformCartesian.hpp:883
UniformCartesian::get_origin
Vektor< MFLOAT, Dim > get_origin() const
Definition: UniformCartesian.hpp:420
UniformCartesian::VertSpacings
BareField< Vektor< MFLOAT, Dim >, Dim > * VertSpacings
Definition: UniformCartesian.h:121
UniformCartesian::Dvc
Vektor< MFLOAT, Dim > Dvc[1<< Dim]
Definition: UniformCartesian.h:119
UniformCartesian::getSurfaceNormal
Vektor< MFLOAT, Dim > getSurfaceNormal(const NDIndex< Dim > &, unsigned) const
Definition: UniformCartesian.hpp:1202
UniformCartesian::initialize
void initialize(const NDIndex< Dim > &ndi)
Definition: UniformCartesian.hpp:221
UniformCartesian::getDeltaCell
Vektor< MFLOAT, Dim > getDeltaCell(const NDIndex< Dim > &) const
Definition: UniformCartesian.hpp:1132
Index
Definition: Index.h:237
Cell
Definition: Centering.h:32
Vert
Definition: Centering.h:43
Edge
Definition: Centering.h:50
Mesh
Definition: Mesh.h:35
Inform
Definition: Inform.h:42
Generated on Thu Oct 20 2022 17:40:08 for OPAL (Object Oriented Parallel Accelerator Library) by doxygen 1.9.3