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