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