Chombo + EB  3.0
EBLevelDataOps.H
Go to the documentation of this file.
1 #ifdef CH_LANG_CC
2 /*
3  * _______ __
4  * / ___/ / ___ __ _ / / ___
5  * / /__/ _ \/ _ \/ V \/ _ \/ _ \
6  * \___/_//_/\___/_/_/_/_.__/\___/
7  * Please refer to Copyright.txt, in Chombo's root directory.
8  */
9 #endif
10 
11 #ifndef _EBLEVELDATAOPS_H_
12 #define _EBLEVELDATAOPS_H_
13 
14 #include "IntVect.H"
15 #include "LevelData.H"
16 #include "RefCountedPtr.H"
17 
18 #include "EBCellFAB.H"
19 #include "EBCellFactory.H"
20 #include "EBFluxFAB.H"
21 #include "EBFluxFactory.H"
22 #include "EBISLayout.H"
23 #include "NamespaceHeader.H"
24 
25 #define EBLEVELDATAOPS_INTERIORREGVOFS 0x1
26 #define EBLEVELDATAOPS_BOUNDARYREGVOFS 0x2
27 #define EBLEVELDATAOPS_INTERIORIRREGVOFS 0x4
28 #define EBLEVELDATAOPS_BOUNDARYIRREGVOFS 0x8
29 
30 #define EBLEVELDATAOPS_ALLVOFS (EBLEVELDATAOPS_INTERIORREGVOFS | \
31  EBLEVELDATAOPS_BOUNDARYREGVOFS | \
32  EBLEVELDATAOPS_INTERIORIRREGVOFS | \
33  EBLEVELDATAOPS_BOUNDARYIRREGVOFS )
34 
35 #define EBLEVELDATAOPS_REGULARVOFS (EBLEVELDATAOPS_INTERIORREGVOFS | \
36  EBLEVELDATAOPS_BOUNDARYREGVOFS )
37 
38 #define EBLEVELDATAOPS_IRREGULARVOFS (EBLEVELDATAOPS_INTERIORIRREGVOFS | \
39  EBLEVELDATAOPS_BOUNDARYIRREGVOFS )
40 
41 #define EBLEVELDATAOPS_BOUNDARYVOFS (EBLEVELDATAOPS_BOUNDARYREGVOFS | \
42  EBLEVELDATAOPS_IRREGULARVOFS )
43 
44 ///
45 /**
46  Repository of useful EB functions over a level. All functions are static so just
47  use EBLevelDataOps::blah(...);
48  */
50 {
51 public:
53  {
54  }
55 
57  {
58  }
59 
60 
61  ///
62  /**
63  If a_interpolateToCentroid = true. first do cell centered average on grown box. then interpolate to centroids.
64  Otherwise just do cell centered averaging. This does not do anything special about components (the way mac averaging
65  does). Every component is treated as face centered value = average of adjacent cell values.
66  ***/
67  static void averageCellToFace(EBFaceFAB & a_fluxData,
68  const EBCellFAB & a_cellData,
69  const Box & a_grid,
70  const EBISBox & a_ebisl,
71  const ProblemDomain & a_domain,
72  int isrc, int idst, int inco,
73  bool a_interpolateToCentroid);
74 
75 
76  ///
77  /**
78  straightforward average from cells to faces over components faceval = half(hival + loval).
79  at domain boundaries, just use cell centered value. nothing crazy
80  about ghost cells either.
81  */
82  static void faceCenteredAverageCellsToFaces(EBFaceFAB & a_faceData,
83  const EBCellFAB & a_cellData,
84  const Box & ccFluxBox,
85  const EBISBox & a_ebisBox,
86  const ProblemDomain & a_domain,
87  int isrc, int idst, int inco);
88  ///
89  /**
90  If a_interpolateToCentroid = true. first do cell centered average on grown box. then interpolate to centroids.
91  Otherwise just do cell centered averaging. This does not do anything special about components (the way mac averaging
92  does). Every component is treated as face centered value = average of adjacent cell values.
93  **/
94  static void averageCellToFace(LevelData<EBFluxFAB>& a_fluxData,
95  const LevelData<EBCellFAB>& a_cellData,
96  const DisjointBoxLayout& a_grids,
97  const EBISLayout& a_ebisl,
98  const ProblemDomain& a_domain,
99  int isrc, int idst, int inco,
100  bool a_interpolateToCentroid);
101  ///
102  /**
103  */
104  static void pruneCoveredBoxes(Vector<Box>& a_boxes,
105  const ProblemDomain& a_domain,
106  const EBIndexSpace* a_ebisPtr);
107 
108  ///
109  /**
110  */
111  static int parallelSum(const int& a_value);
112 
113  ///
114  /**
115  */
116  static Real parallelSum(const Real& a_value);
117 
118  ///
119  /**
120  */
121  static int parallelMin(const int& a_value);
122 
123  ///
124  /**
125  */
126  static int parallelMax(const int& a_value);
127 
128  ///
129  /**
130  */
131  static Real parallelMin(const Real& a_value);
132 
133  ///
134  /**
135  */
136  static Real parallelMax(const Real& a_value);
137 
138 
139  ///
140  /**
141  */
142  static void
144  const LevelData<EBCellFAB>& a_cellData,
145  const DisjointBoxLayout& a_grids,
146  const EBISLayout& a_ebisl,
147  const ProblemDomain& a_domain,
148  const int& a_comp);
149 
150 
151  ///
152  /**
153  */
154  static void
156  const LevelData<EBCellFAB>& a_cellData,
157  const DisjointBoxLayout& a_grids,
158  const EBISLayout& a_ebisl,
159  const ProblemDomain& a_domain);
160 
161 
162  ///
163  /**
164  */
165  static void exchangeAll(LevelData<EBCellFAB>& a_phi);
166 
167  ///
168  /**
169  */
170  static void exchangeCorners(LevelData<EBCellFAB>& a_data,
171  const ProblemDomain& a_domain);
172 
173  ///
174  /**
175  */
176  static void exchangeComp(LevelData<EBCellFAB>& a_data,
177  const int& a_comp);
178 
179 
180  ///
181  /**
182  */
183  static void exchangeAll(LevelData<EBFluxFAB>& a_phi);
184 
185 
186  ///
187  /**
188  */
189  static void exchangeComp(LevelData<EBFluxFAB>& a_data,
190  const int& a_comp);
191 
192 
193  ///
194  /**
195  */
196  static void setIrregVal(LevelData<EBCellFAB>& a_data,
197  const DisjointBoxLayout& a_dbl,
198  const EBISLayout& a_ebisl,
199  const Real& a_value);
200 
201  ///
202  /**
203  */
204  static bool checkNANINF(const LevelData<EBCellFAB>&a_data,
205  const IntVect& a_iv1 = IntVect::Zero,
206  const IntVect& a_iv2 = IntVect::Zero,
207  const Real& a_shift = 0.0);
208 
209  ///
210  /**
211  */
212  static void getMaxMin(Real& a_maxVal,
213  Real& a_minVal,
214  const LevelData<EBCellFAB>& a_data,
215  const int& a_comp,
216  const bool& a_doAbs=false);
217  ///
218  /**
219  */
220  static void setCoveredVal(LevelData<EBCellFAB>& a_lData,
221  const Real& a_value);
222 
223 
224  ///
225  /**
226  */
227  static void setCoveredVal(LevelData<EBCellFAB>& a_lData,
228  const int& a_comp,
229  const Real& a_value);
230 
231 
232  ///
233  /**
234  */
235  static void setCoveredVal(LevelData<EBFluxFAB>& a_lData,
236  const Real& a_value);
237 
238 
239  ///
240  /**
241  */
242  static void setCoveredVal(LevelData<EBFluxFAB>& a_lData,
243  const int& a_comp,
244  const Real& a_value);
245 
246  ///
247  /**
248  */
250  const DisjointBoxLayout& a_dbl,
251  const EBISLayout& a_ebisl);
252 
253 
254  ///
255  /**
256  */
258  const DisjointBoxLayout& a_dbl,
259  const EBISLayout& a_ebisl);
260 
261 
262  ///
263  /**
264  */
265  static void defineLevelData(LevelData<EBCellFAB>& a_levelData,
266  const EBISLayout& a_ebisl,
267  const DisjointBoxLayout& a_dbl,
268  const IntVect& a_ghosts,
269  const int& a_nComp);
270 
271 
272  ///
273  /**
274  */
275  static void defineLevelData(LevelData<EBFluxFAB>& a_levelData,
276  const EBISLayout& a_ebisl,
277  const DisjointBoxLayout& a_dbl,
278  const IntVect& a_ghosts,
279  const int& a_nComp);
280 
281 
282  ///
283  /**
284  */
285  static void setToZero(LevelData<EBCellFAB>& a_result);
286 
287 
288  ///
289  /**
290  */
291  static void setToZero(LevelData<EBFluxFAB>& a_result);
292 
293 
294  ///
295  /**
296  */
297  static void scale(LevelData<EBFluxFAB>& a_lhs,
298  const Real& a_scale) ;
299 
300  static void scale(LevelData<EBCellFAB>& a_lhs,
301  const LevelData<EBCellFAB>& a_scale) ;
302 
303 
304  ///
305  /**
306  */
307  static void scale(LevelData<EBCellFAB>& a_lhs,
308  const Real& a_scale) ;
309 
310 
311  ///
312  /**
313  */
314  static void scale(LevelData<EBCellFAB>& a_lhs,
315  const Real& a_scale,
316  const int& a_comp);
317 
318 
319  ///
320  /**
321  */
322  static void setVal(LevelData<EBCellFAB>& a_result,
323  const Real& a_value);
324 
325  ///
326  /**
327  */
328  static void setVal(LevelData<EBCellFAB>& a_result,
329  const Real& a_value,
330  const int& a_comp);
331 
332  ///
333  /**
334  */
335  static void setVal(LevelData<EBFluxFAB>& a_result,
336  const Real& a_value);
337 
338  ///
339  /**
340  */
341  static void assign(LevelData<EBCellFAB>& a_to,
342  const LevelData<EBCellFAB>& a_from,
343  const Interval& a_toInterva,
344  const Interval& a_fromInterval);
345 
346 
347  ///
348  /**
349  */
350  static void assign(LevelData<EBCellFAB>& a_lhs,
351  const LevelData<EBCellFAB>& a_rhs);
352 
353 
354  ///
355  /**
356  */
357  static void clone(LevelData<EBCellFAB>& a_lhs,
358  const LevelData<EBCellFAB>& a_rhs);
359 
360 
361  ///
362  /**
363  */
364  static void assign(LevelData<EBFluxFAB>& a_lhs,
365  const LevelData<EBFluxFAB>& a_rhs);
366 
367 
368  ///
369  /**
370  */
371  static void incr( LevelData<EBCellFAB>& a_lhs,
372  const LevelData<EBCellFAB>& a_rhs,
373  const Real& a_scale);
374 
375 
376  ///
377  /**
378  */
379  static void incr( LevelData<EBCellFAB>& a_lhs,
380  const Real& a_scale);
381 
382 
383  ///
384  /**
385  */
386  static void axby( LevelData<EBCellFAB>& a_lhs,
387  const LevelData<EBCellFAB>& a_x,
388  const LevelData<EBCellFAB>& a_y,
389  const Real& a,
390  const Real& b);
391 
392 
393  ///
394  /**
395  */
396  static void axby( LevelData<EBCellFAB>& a_lhs,
397  const LevelData<EBCellFAB>& a_x,
398  const LevelData<EBCellFAB>& a_y,
399  const Real& a,
400  const Real& b,
401  const int& a_lhsComp,
402  const int& a_xComp,
403  const int& a_yComp);
404 
405 
406 
407  ///
408  /**
409  */
410  static void sum(LevelData<EBCellFAB>& a_result,
411  const LevelData<EBCellFAB>& a_in1,
412  const LevelData<EBCellFAB>& a_in2);
413 
414 
415  ///
416  /**
417  */
418  static void addConstant(LevelData<EBCellFAB>& a_data,
419  const Real& a_constant);
420 
421 
422  ///
423  /**
424  */
425  static void power(LevelData<EBCellFAB>& a_result,
426  const Real& a_exponent,
427  const int& a_comp);
428 
429  ///
430  /**
431  */
432  static void product(LevelData<EBCellFAB>& a_result,
433  const LevelData<EBCellFAB>& a_in1,
434  const LevelData<EBCellFAB>& a_in2);
435 
436 
437  ///
438  /**
439  */
440  static void product(LevelData<EBFluxFAB>& a_result,
441  const LevelData<EBFluxFAB>& a_in1,
442  const LevelData<EBFluxFAB>& a_in2);
443 
444 
445  ///
446  /**
447  */
448  static void product(LevelData<EBCellFAB>& a_result,
449  const LevelData<EBCellFAB>& a_in1,
450  const LevelData<EBCellFAB>& a_in2,
451  const int& a_rComp,
452  const int& a_1Comp,
453  const int& a_2Comp);
454 
455 
456  ///
457  /**
458  */
459  static void invert(LevelData<EBCellFAB>& a_result,
460  const LevelData<EBCellFAB>& a_in1);
461 
462 
463  ///
464  /**
465  */
466  static void divideVectorByScalar(LevelData<EBCellFAB>& a_vectorOut,
467  const LevelData<EBCellFAB>& a_vectorIn,
468  const LevelData<EBCellFAB>& a_scalar);
469 
470  ///
471  /**
472  */
473  static void divide(LevelData<EBCellFAB>& a_result,
474  const LevelData<EBCellFAB>& a_in1,
475  const LevelData<EBCellFAB>& a_in2);
476 
477 
478  ///
479  /**
480  */
481  static void divide(LevelData<EBCellFAB>& a_result,
482  const LevelData<EBCellFAB>& a_in1,
483  const LevelData<EBCellFAB>& a_in2,
484  const int& a_rComp,
485  const int& a_1Comp,
486  const int& a_2Comp);
487 
488 
489  //! Multiply each datum in \a a_data by the largest area fraction
490  //! of the faces of the corresponding cell.
491  //! \param a_data The data to be multiplied by the maximum area
492  //! fraction.
493  static void areaFracScalingWeight(LevelData<EBCellFAB>& a_data);
494 
495  //! Multiply each datum in \a a_data by the area fraction scaling
496  //! of the corresponding cell.
497  //! \param a_data The data to be multiplied by the area fraction
498  //! scaling.
499  static void areaFracScalingWeight(EBCellFAB& a_data);
500 
501  //! Multiply each datum in \a a_data by the volume fraction of the
502  //! corresponding cell.
503  //! \param a_data The data to be multiplied by the volume fraction.
504  static void kappaWeight(LevelData<EBCellFAB>& a_data);
505 
506  //! Multiply each datum in \a a_data by the volume fraction of the
507  //! corresponding cell.
508  //! \param a_data The data to be multiplied by the volume fraction.
509  static void kappaWeight(EBCellFAB& a_data);
510 
511  //! Scale each datum in \a a_data by the product of \a a_scale with
512  //! the volume fraction of the corresponding cell.
513  //! \param a_data The data to be multiplied by the volume fraction.
514  //! \param a_scale The scale factor in the product.
515  static void kappaScale(LevelData<EBCellFAB>& a_data,
516  const Real& a_scale);
517 
518 
519  ///
520  /**
521  */
522  static Real kappaNorm(Real& a_volume,
523  const LevelData<EBCellFAB>& a_data,
524  int a_which,
525  const ProblemDomain& a_domain,
526  int a_p=2);
527 
528 
529  ///
530  /**
531  */
532  static Vector<Real> vectorKappaNorm(Real& a_volume,
533  const LevelData<EBCellFAB>& a_data,
534  int a_which,
535  const ProblemDomain& a_domain,
536  int a_p=2);
537 
538 
539  ///
540  /**
541  */
542  static Real noKappaNorm(Real& a_volume,
543  const LevelData<EBCellFAB>& a_data,
544  int a_which,
545  const ProblemDomain& a_domain,
546  int a_p=2);
547 
548 
549  ///
550  /**
551  */
552  static Real kappaDotProduct(Real& a_volume,
553  const LevelData<EBCellFAB>& a_data1,
554  const LevelData<EBCellFAB>& a_data2,
555  int a_which,
556  const ProblemDomain& a_domain);
557 
558 
559  ///
560  /**
561  */
562  static Real noKappaDotProduct(Real& a_volume,
563  const LevelData<EBCellFAB>& a_data1,
564  const LevelData<EBCellFAB>& a_data2,
565  int a_which,
566  const ProblemDomain& a_domain);
567 
568 
569  ///
570  /**
571  */
572  static Real kappaSumLevel(Real& a_volume,
573  const LevelData<EBCellFAB>& a_data,
574  int a_which,
575  const ProblemDomain& a_domain);
576 
577 
578  ///
579  /**
580  */
581  static Real noKappaSumLevel(Real& a_volume,
582  const LevelData<EBCellFAB>& a_data,
583  int a_which,
584  const ProblemDomain& a_domain);
585 
586 
587  ///
588  /**
589  */
590  static Vector<Real> vectorSumKappaPow(Real& a_volume,
591  const EBCellFAB& a_data, const Box& curBox,
592  int a_which,
593  const ProblemDomain& a_domain,
594  int a_p);
595 
596  ///
597  /**
598  */
599  static Real sumKappaPow(Real& a_volume,
600  const EBCellFAB& a_data, const Box& a_region,
601  int a_which,
602  const ProblemDomain& a_domain,
603  int a_p);
604 
605 
606  ///
607  /**
608  */
609  static Real sumNoKappaPow(Real& a_volume,
610  const EBCellFAB& a_data,const Box& a_region,
611  int a_which,
612  const ProblemDomain& a_domain,
613  int a_p);
614 
615 
616  ///
617  /**
618  */
619  static Real sumKappaDotProduct(Real& a_volume,
620  const EBCellFAB& a_data1,
621  const EBCellFAB& a_data2,
622  const Box& a_region,
623  int a_which,
624  const ProblemDomain& a_domain);
625 
626  ///
627  /**
628  */
629  static Real sumKappaDotProductAllCells(Real& a_volume,
630  const EBCellFAB& a_data1,
631  const EBCellFAB& a_data2,
632  const Box& a_region,
633  int a_which,
634  const ProblemDomain& a_domain);
635  ///
636  /**
637  */
638  static Real sumNoKappaDotProduct(Real& a_volume,
639  const EBCellFAB& a_data1,
640  const EBCellFAB& a_data2,const Box& a_region,
641  int a_which,
642  const ProblemDomain& a_domain);
643 
644 
645  ///
646  /**
647  */
648  static Real sumKappa(Real& a_volume,
649  const EBCellFAB& a_data,const Box& a_region,
650  int a_which,
651  const ProblemDomain& a_domain);
652 
653 
654  ///
655  /**
656  */
657  static Real sumNoKappa(Real& a_volume,
658  const EBCellFAB& a_data,const Box& a_region,
659  int a_which,
660  const ProblemDomain& a_domain);
661 
662  ///
663 
664  ///
665  /**
666  */
667  static void
668  averageCellToFace(EBFaceFAB& a_faceData,
669  const EBCellFAB& a_cellData,
670  const EBGraph& a_ebGraph,
671  const Box& a_dblBox,
672  const int& a_ghostFlux,
673  const int& a_idir,
674  const ProblemDomain& a_domain,
675  const int& a_cellComp,
676  const int& a_faceComp);
677 
678 
679  ///
680  /**
681  */
682  static void gatherBroadCast(Real& a_accum, Real& a_volume, const int& a_p);
683 
684  ///
685  /**
686  */
687  static void gatherBroadCast(Vector<Real>& a_accum, Real& a_volume, const int& a_p);
688 
689 
690  ///
691  /**
692  */
693  static Real sum(const LevelData<EBCellFAB> & a_data,
694  const DisjointBoxLayout & a_grids,
695  const EBISLayout & a_ebisl,
696  const IntVectSet & a_ivsExclude,
697  int a_comp,
698  bool a_mutiplyByKappa);
699 private:
700 
701 };
702 #include "NamespaceFooter.H"
703 #endif
static bool checkNANINF(const LevelData< EBCellFAB > &a_data, const IntVect &a_iv1=IntVect::Zero, const IntVect &a_iv2=IntVect::Zero, const Real &a_shift=0.0)
static void copyToMultiVofsFromRegFAB(LevelData< EBCellFAB > &a_data, const DisjointBoxLayout &a_dbl, const EBISLayout &a_ebisl)
static void averageCellToFaces(LevelData< EBFluxFAB > &a_fluxData, const LevelData< EBCellFAB > &a_cellData, const DisjointBoxLayout &a_grids, const EBISLayout &a_ebisl, const ProblemDomain &a_domain, const int &a_comp)
static void averageMultiVofsToRegFAB(LevelData< EBCellFAB > &a_data, const DisjointBoxLayout &a_dbl, const EBISLayout &a_ebisl)
static Vector< Real > vectorSumKappaPow(Real &a_volume, const EBCellFAB &a_data, const Box &curBox, int a_which, const ProblemDomain &a_domain, int a_p)
An irregular domain on an integer lattice.
Definition: IntVectSet.H:44
static Real sumNoKappa(Real &a_volume, const EBCellFAB &a_data, const Box &a_region, int a_which, const ProblemDomain &a_domain)
A class to facilitate interaction with physical boundary conditions.
Definition: ProblemDomain.H:130
Definition: EBIndexSpace.H:260
static void averageCellToFace(EBFaceFAB &a_fluxData, const EBCellFAB &a_cellData, const Box &a_grid, const EBISBox &a_ebisl, const ProblemDomain &a_domain, int isrc, int idst, int inco, bool a_interpolateToCentroid)
static void kappaWeight(LevelData< EBCellFAB > &a_data)
static Real kappaDotProduct(Real &a_volume, const LevelData< EBCellFAB > &a_data1, const LevelData< EBCellFAB > &a_data2, int a_which, const ProblemDomain &a_domain)
static void incr(LevelData< EBCellFAB > &a_lhs, const LevelData< EBCellFAB > &a_rhs, const Real &a_scale)
static void defineLevelData(LevelData< EBCellFAB > &a_levelData, const EBISLayout &a_ebisl, const DisjointBoxLayout &a_dbl, const IntVect &a_ghosts, const int &a_nComp)
static void kappaScale(LevelData< EBCellFAB > &a_data, const Real &a_scale)
static void divideVectorByScalar(LevelData< EBCellFAB > &a_vectorOut, const LevelData< EBCellFAB > &a_vectorIn, const LevelData< EBCellFAB > &a_scalar)
static void power(LevelData< EBCellFAB > &a_result, const Real &a_exponent, const int &a_comp)
Definition: EBISBox.H:46
static Real sumKappaDotProduct(Real &a_volume, const EBCellFAB &a_data1, const EBCellFAB &a_data2, const Box &a_region, int a_which, const ProblemDomain &a_domain)
static void faceCenteredAverageCellsToFaces(EBFaceFAB &a_faceData, const EBCellFAB &a_cellData, const Box &ccFluxBox, const EBISBox &a_ebisBox, const ProblemDomain &a_domain, int isrc, int idst, int inco)
static int parallelSum(const int &a_value)
Definition: EBFaceFAB.H:28
Geometric description within a box.
Definition: EBGraph.H:432
static void scale(LevelData< EBFluxFAB > &a_lhs, const Real &a_scale)
static void addConstant(LevelData< EBCellFAB > &a_data, const Real &a_constant)
static Real sumNoKappaDotProduct(Real &a_volume, const EBCellFAB &a_data1, const EBCellFAB &a_data2, const Box &a_region, int a_which, const ProblemDomain &a_domain)
static void averageCellToFacesMAC(LevelData< EBFluxFAB > &a_fluxData, const LevelData< EBCellFAB > &a_cellData, const DisjointBoxLayout &a_grids, const EBISLayout &a_ebisl, const ProblemDomain &a_domain)
static Real sumKappa(Real &a_volume, const EBCellFAB &a_data, const Box &a_region, int a_which, const ProblemDomain &a_domain)
static Real noKappaDotProduct(Real &a_volume, const LevelData< EBCellFAB > &a_data1, const LevelData< EBCellFAB > &a_data2, int a_which, const ProblemDomain &a_domain)
static void areaFracScalingWeight(LevelData< EBCellFAB > &a_data)
static Real sumKappaDotProductAllCells(Real &a_volume, const EBCellFAB &a_data1, const EBCellFAB &a_data2, const Box &a_region, int a_which, const ProblemDomain &a_domain)
static void exchangeComp(LevelData< EBCellFAB > &a_data, const int &a_comp)
static void sum(LevelData< EBCellFAB > &a_result, const LevelData< EBCellFAB > &a_in1, const LevelData< EBCellFAB > &a_in2)
Structure for passing component ranges in code.
Definition: Interval.H:23
static Real noKappaNorm(Real &a_volume, const LevelData< EBCellFAB > &a_data, int a_which, const ProblemDomain &a_domain, int a_p=2)
Definition: EBCellFAB.H:29
static void setToZero(LevelData< EBCellFAB > &a_result)
static Real sumNoKappaPow(Real &a_volume, const EBCellFAB &a_data, const Box &a_region, int a_which, const ProblemDomain &a_domain, int a_p)
double Real
Definition: REAL.H:33
static void clone(LevelData< EBCellFAB > &a_lhs, const LevelData< EBCellFAB > &a_rhs)
A BoxLayout that has a concept of disjointedness.
Definition: DisjointBoxLayout.H:31
static void getMaxMin(Real &a_maxVal, Real &a_minVal, const LevelData< EBCellFAB > &a_data, const int &a_comp, const bool &a_doAbs=false)
static void setCoveredVal(LevelData< EBCellFAB > &a_lData, const Real &a_value)
static void gatherBroadCast(Real &a_accum, Real &a_volume, const int &a_p)
static const IntVect Zero
Definition: IntVect.H:627
static void exchangeAll(LevelData< EBCellFAB > &a_phi)
static void exchangeCorners(LevelData< EBCellFAB > &a_data, const ProblemDomain &a_domain)
static Real kappaSumLevel(Real &a_volume, const LevelData< EBCellFAB > &a_data, int a_which, const ProblemDomain &a_domain)
A Rectangular Domain on an Integer Lattice.
Definition: Box.H:465
static void pruneCoveredBoxes(Vector< Box > &a_boxes, const ProblemDomain &a_domain, const EBIndexSpace *a_ebisPtr)
EBLevelDataOps()
Definition: EBLevelDataOps.H:52
~EBLevelDataOps()
Definition: EBLevelDataOps.H:56
static void product(LevelData< EBCellFAB > &a_result, const LevelData< EBCellFAB > &a_in1, const LevelData< EBCellFAB > &a_in2)
An integer Vector in SpaceDim-dimensional space.
Definition: CHArray.H:42
static Real kappaNorm(Real &a_volume, const LevelData< EBCellFAB > &a_data, int a_which, const ProblemDomain &a_domain, int a_p=2)
static int parallelMin(const int &a_value)
static void axby(LevelData< EBCellFAB > &a_lhs, const LevelData< EBCellFAB > &a_x, const LevelData< EBCellFAB > &a_y, const Real &a, const Real &b)
Definition: EBISLayout.H:39
static Vector< Real > vectorKappaNorm(Real &a_volume, const LevelData< EBCellFAB > &a_data, int a_which, const ProblemDomain &a_domain, int a_p=2)
Definition: EBLevelDataOps.H:49
static void assign(LevelData< EBCellFAB > &a_to, const LevelData< EBCellFAB > &a_from, const Interval &a_toInterva, const Interval &a_fromInterval)
static void setVal(LevelData< EBCellFAB > &a_result, const Real &a_value)
static Real noKappaSumLevel(Real &a_volume, const LevelData< EBCellFAB > &a_data, int a_which, const ProblemDomain &a_domain)
static Real sumKappaPow(Real &a_volume, const EBCellFAB &a_data, const Box &a_region, int a_which, const ProblemDomain &a_domain, int a_p)
static void setIrregVal(LevelData< EBCellFAB > &a_data, const DisjointBoxLayout &a_dbl, const EBISLayout &a_ebisl, const Real &a_value)
static int parallelMax(const int &a_value)
static void divide(LevelData< EBCellFAB > &a_result, const LevelData< EBCellFAB > &a_in1, const LevelData< EBCellFAB > &a_in2)
static void invert(LevelData< EBCellFAB > &a_result, const LevelData< EBCellFAB > &a_in1)