Chombo + EB + MF  3.2
EBAdvectPatchIntegrator.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 _EBADVECTPATCHINTEGRATOR_H_
12 #define _EBADVECTPATCHINTEGRATOR_H_
13 
14 #include "Box.H"
15 #include "IntVectSet.H"
16 #include "Vector.H"
17 #include "CH_HDF5.H"
18 #include "EBCellFAB.H"
19 #include "EBFluxFAB.H"
20 #include "EBISBox.H"
21 #include "BaseIVFAB.H"
22 #include "EBPhysIBC.H"
23 #include "EBPhysIBCFactory.H"
24 #include "Stencils.H"
25 #include "AggStencil.H"
26 #include "NamespaceHeader.H"
27 
28 #define EBAPI_TOL 1.e-12
29 
30 ///
31 /**
32  This does the same as EBPatchAdvect but presumably with less memory footprint.
33  and with a somewhat more sane interface.
34 
35  I have pared down the EBPatchGodunov interface and tried to optimize for minimal
36  memory without completely destroying performance.
37 */
39 {
40 public:
41 
42  ///boundary condions are set via setEBPhysIBC
43  EBAdvectPatchIntegrator(const Box& a_validBox,
44  const EBISBox& a_ebisBox,
45  const IntVectSet& a_coarseFineIVS,
46  const ProblemDomain& a_domain,
47  const RealVect& a_dx,
48  bool a_useSlopeLimiting);
49 
51  {;}
52 
53 
54  void
55  extrapolatePrim(EBFluxFAB& a_flux,
56  Vector<BaseIVFAB<Real> * >& a_coveredFluxMinu,
57  Vector<BaseIVFAB<Real> * >& a_coveredFluxPlus,
58  const Vector<IntVectSet >& a_coveredSetsMinu,
59  const Vector<IntVectSet >& a_coveredSetsPlus,
60  const Vector<Vector<VolIndex> >& a_coveredFaceMinu,
61  const Vector<Vector<VolIndex> >& a_coveredFacePlus,
62  const EBCellFAB& a_consState,
63  const EBCellFAB& a_source,
64  const DataIndex& a_dit,
65  const Real& a_time,
66  const Real& a_dt);
67 
68  ///
69  /**
70  */
71  void
72  advectiveDerivative(EBCellFAB& a_uDotDelRho,
73  const EBFluxFAB& a_faceRho,
74  const EBFluxFAB& a_faceVel,
75  const Vector<BaseIVFAB<Real>*> & a_coveredRhoLo,
76  const Vector<BaseIVFAB<Real>*> & a_coveredRhoHi,
77  const Vector<BaseIVFAB<Real>*> & a_coveredVelLo,
78  const Vector<BaseIVFAB<Real>*> & a_coveredVelHi,
79  const Vector<Vector<VolIndex> >& a_coveredFaceLo,
80  const Vector<Vector<VolIndex> >& a_coveredFaceHi,
81  const Box& a_box);
82 
83 
84  ///
85  /**
86  Version that leaves out the covered face stuff. This is wrong near the EB but
87  the codes that use it overwrite the EB stuff anyway.
88  */
89  void
90  advectiveDerivative(EBCellFAB& a_uDotDelRho,
91  const EBFluxFAB& a_faceRho,
92  const EBFluxFAB& a_faceVel,
93  const Box& a_box);
94  ///
95  /**
96  */
97  void
99  {
102  m_isBCSet = true;
103  }
104 
105  void setVelocities(const EBCellFAB& a_normalVel,
106  const EBFluxFAB& a_advectionVel)
107  {
108  m_normalVelPtr = &a_normalVel;
109  m_advectionVelPtr = &a_advectionVel;
110  m_isVelSet = true;
111  }
112 
113 
114  /**
115  For when EBFlux is always zero.
116  */
117  void
119  const BaseIFFAB<Real> a_centroidFlux[SpaceDim],
120  const IntVectSet& a_ivs);
121 
122 
123  void
125  const BaseIFFAB<Real> a_centroidFlux[SpaceDim],
126  const BaseIVFAB<Real>& a_ebIrregFlux,
127  const IntVectSet& a_ivs);
128 
129  void
131  const BaseIFFAB<Real>* const a_fluxInterpolant[SpaceDim],
132  const IntVectSet& a_irregIVS);
133 
134  void
135  averageVelToCC(EBCellFAB& a_normalVel,
136  const EBFluxFAB& a_advectionVel,
137  const Vector<BaseIVFAB<Real> * >& a_coveredVeloLo,
138  const Vector<BaseIVFAB<Real> * >& a_coveredVeloHi,
139  const Vector<Vector<VolIndex> >& a_coveredFaceLo,
140  const Vector<Vector<VolIndex> >& a_coveredFaceHi,
141  const Box& a_box) const;
142 
143 
144  void
145  extrapolateBCG(EBFluxFAB& a_flux,
146  const EBCellFAB& a_consState,
147  const EBCellFAB& a_source,
148  const DataIndex& a_dit,
149  const Real& a_time,
150  const Real& a_dt);
151 
152 
153  void
154  mvExtrapolateBCG(EBFluxFAB & a_flux,
155  const EBCellFAB & a_consState,
156  const EBFluxFAB & a_advectionVel,
157  const EBCellFAB & a_normalVel,
158  const EBCellFAB & a_source,
159  const Vector<RefCountedPtr<EBPhysIBCFactory> > & a_allAdvectBC,
160  const DataIndex & a_dit,
161  const Real & a_time,
162  const Real & a_dt,
163  const int & a_doingVel);
164 
165  void
166  kappaDivergenceFlux(EBCellFAB& a_kappaDivF,
167  const EBFluxFAB& a_centroidFlux,
168  const Box& a_validBox);
169 
170  ///here are a couple of awful hooks necessary to get the minutiae of the algorithm correct
171  static void setCurComp(int a_curComp)
172  {
173  s_curComp = a_curComp;
174  }
175  ///
176  static void setDoingVel(int a_yesorno)
177  {
178  s_doingVel = a_yesorno;
179  }
180 
181  static int getDoingVel()
182  {
183  return s_doingVel;
184  }
185  static int getCurComp()
186  {
187  return s_curComp;
188  }
189 
190  ///
191  /**
192  This is called by EBAMRNoSubCycle. The insane version that uses cell-centered
193  data holders for face data (the plus-minus stuff) is called internally.
194  */
195  void
196  extrapToCoveredFaces(BaseIVFAB<Real>& a_extendedPrim,
197  const EBFaceFAB& a_primFace,
198  const EBCellFAB& a_primState,
199  const Vector<VolIndex>& a_coveredFaces,
200  const int& a_faceDir,
201  const Side::LoHiSide& a_sd,
202  const Box& a_box);
203 
204  void setMaxMin(const Real& a_maxVal,
205  const Real& a_minVal)
206  {
207  m_isMaxMinSet = true;
208  m_maxVal = a_maxVal;
209  m_minVal = a_minVal;
210  }
211 private:
219 
221  bool m_isBCSet;
229 
234 
235  ///these exist because special things have to be done for velocity
236  static int s_curComp;
237  static int s_doingVel;
238 
239  /// weak construction is bad.
241 
242  /// internal functions (all the madness below probably needs to get cleaned up)
243 
244  ///
245  void extrapolatePrim3D(EBCellFAB a_primMinu[SpaceDim],
246  EBCellFAB a_primPlus[SpaceDim],
247  const EBCellFAB& a_consState,
248  const EBCellFAB& a_source,
249  const DataIndex& a_dit,
250  const Real& a_time,
251  const Real& a_dt);
252 
253  ///
254  void
255  extrapolateBCG(EBCellFAB a_primMinu[SpaceDim],
256  EBCellFAB a_primPlus[SpaceDim],
257  const EBCellFAB& a_consState,
258  const EBCellFAB& a_source,
259  const DataIndex& a_dit,
260  const Real& a_time,
261  const Real& a_dt);
262 
263  ///
264  void extrapolatePrim2D(EBCellFAB a_primMinu[SpaceDim],
265  EBCellFAB a_primPlus[SpaceDim],
266  const EBCellFAB& a_consState,
267  const EBCellFAB& a_source,
268  const DataIndex& a_dit,
269  const Real& a_time,
270  const Real& a_dt);
271 
272  ///
273  void
274  riemann(BaseIVFAB<Real>& a_coveredPrim,
275  const BaseIVFAB<Real>& a_exteState,
276  const EBCellFAB& a_primState,
277  const Vector<VolIndex>& a_vofset,
278  const int& a_faceDir,
279  const Side::LoHiSide& a_sd,
280  const Box& a_box);
281 
282  ///
283  void
284  riemann(EBFaceFAB& a_primGdnv,
285  const EBCellFAB& a_primLeft,
286  const EBCellFAB& a_primRigh,
287  const int& a_faceDir,
288  const Box& a_box);
289 
290  ///
291  FaceStencil getInterpStencil(const FaceIndex& a_face) const;
292 
293 
294  void
296  const EBFaceFAB& a_primFace,
297  const EBCellFAB& a_primState,
298  const int& a_faceDir,
299  const VolIndex& a_vof,
300  const RealVect& a_normal,
301  const Side::LoHiSide& a_sd,
302  const int& a_numPrim);
303 
304  void
306  const EBFaceFAB& a_primFace,
307  const EBCellFAB& a_primState,
308  const int& a_faceDir,
309  const VolIndex& a_vof,
310  const RealVect& a_normal,
311  const Side::LoHiSide& a_sd,
312  const int& a_numPrim);
313 
314  ///
315  /**
316  This insane version called internally. The primMinu and primPlus stuff
317  are really face centered data but because they *came* from cell-centered data
318  they are left there.
319  */
320  void
321  extrapToCoveredFaces(BaseIVFAB<Real>& a_extendedPrim,
322  const EBCellFAB& a_primMinu,
323  const EBCellFAB& a_primPlus,
324  const EBCellFAB& a_primState,
325  const Vector<VolIndex>& a_coveredFaces,
326  const int& a_faceDir,
327  const Side::LoHiSide& a_sd,
328  const Box& a_box);
329 
330  void
332  const EBCellFAB& a_primMinu,
333  const EBCellFAB& a_primPlus,
334  const EBCellFAB& a_primState,
335  const int& a_faceDir,
336  const VolIndex& a_vof,
337  const RealVect& a_normal,
338  const Side::LoHiSide& a_sd,
339  const int& a_numPrim);
340 
341  void
343  const EBCellFAB& a_primMinu,
344  const EBCellFAB& a_primPlus,
345  const EBCellFAB& a_primState,
346  const int& a_faceDir,
347  const VolIndex& a_vof,
348  const RealVect& a_normal,
349  const Side::LoHiSide& a_sd,
350  const int& a_numPrim);
351 
352 
353  /// floors if m_isMaxMinSet
354  void
355  floorPrimitives(EBCellFAB& a_primState,
356  const Box& a_box);
357 
358  /// floors if m_isMaxMinSet
359  void
360  floorPrimitives(BaseIVFAB<Real>& a_primState,
361  const IntVectSet& a_set);
362 
363  void
365  const VolIndex& a_vof,
366  const EBCellFAB& a_primState,
367  const int& a_dir,
368  const int& a_ivar);
369 
370  void
371  pointGetSlopes(Real& a_dql,
372  Real& a_dqr,
373  Real& a_dqc,
374  bool& a_hasFacesLeft,
375  bool& a_hasFacesRigh,
376  const VolIndex& a_vof,
377  const EBCellFAB& a_primState,
378  const int& a_dir,
379  const int& a_ivar,
380  const bool& a_verbose);
381 
382  Real
383  bilinearFunc(const Real a_WVal[2][2],
384  const Real& a_xd1,
385  const Real& a_xd2);
386 
387  void
388  pointGetSlopesUpwind(Real& a_dql,
389  Real& a_dqr,
390  Real& a_dqc,
391  bool& a_hasFacesLeft,
392  bool& a_hasFacesRigh,
393  const VolIndex& a_vof,
394  const EBCellFAB& a_primState,
395  const int& a_dir,
396  const int& a_ivar,
397  const bool& a_verbose);
398 
399  ///and this is the *simplified* version
400  void
402  EBCellFAB a_primPlus[SpaceDim],
403  EBFaceFAB a_fluxOne[SpaceDim],
404  BaseIVFAB<Real> a_coveredFluxNormMinu[SpaceDim],
405  BaseIVFAB<Real> a_coveredFluxNormPlus[SpaceDim],
406  Vector<VolIndex> a_coveredFaceNormMinu[SpaceDim],
407  Vector<VolIndex> a_coveredFaceNormPlus[SpaceDim],
408  const EBCellFAB& a_primState,
409  const EBCellFAB& a_source,
410  const DataIndex& a_dit,
411  const Real & a_time,
412  const Real & a_dt);
413 
414  ///options for 4th ordeer slopes and flattening removed
415  void
416  slope(EBCellFAB& a_slopePrim,
417  const EBCellFAB& a_primState,
418  const int& a_dir,
419  const Box& a_box);
420 
421 
422  void
423  finalExtrap2D(EBCellFAB a_primMinu[SpaceDim],
424  EBCellFAB a_primPlus[SpaceDim],
425  const BaseIVFAB<Real> a_coveredFluxNormMinu[SpaceDim],
426  const BaseIVFAB<Real> a_coveredFluxNormPlus[SpaceDim],
427  const Vector<VolIndex> a_coveredFaceNormMinu[SpaceDim],
428  const Vector<VolIndex> a_coveredFaceNormPlus[SpaceDim],
429  const EBFaceFAB a_fluxOne[SpaceDim],
430  const EBCellFAB& a_primState,
431  const Real & a_time,
432  const Real & a_dt);
433 
434  //and it goes on like this...
435  void
436  finalExtrap3D(EBCellFAB a_primMinu[SpaceDim],
437  EBCellFAB a_primPlus[SpaceDim],
438  const BaseIVFAB<Real> a_coveredFluxMinu3D[SpaceDim][SpaceDim],
439  const BaseIVFAB<Real> a_coveredFluxPlus3D[SpaceDim][SpaceDim],
440  const EBFaceFAB a_fluxTwo[SpaceDim][SpaceDim],
441  const EBCellFAB& a_primState,
442  const Real & a_time,
443  const Real & a_dt);
444 
445  void
447  BaseIVFAB<Real> a_coveredFluxMinu3D[SpaceDim][SpaceDim],
448  BaseIVFAB<Real> a_coveredFluxPlus3D[SpaceDim][SpaceDim],
449  const EBCellFAB a_primMinu[SpaceDim],
450  const EBCellFAB a_primPlus[SpaceDim],
451  const BaseIVFAB<Real> a_coveredFluxNormMinu[SpaceDim],
452  const BaseIVFAB<Real> a_coveredFluxNormPlus[SpaceDim],
453  const Vector<VolIndex> a_coveredFaceNormMinu[SpaceDim],
454  const Vector<VolIndex> a_coveredFaceNormPlus[SpaceDim],
455  const EBFaceFAB a_fluxOne[SpaceDim],
456  const EBCellFAB& a_primState,
457  const DataIndex& a_dit,
458  const Real & a_time,
459  const Real & a_dt);
460 
461  void
463  EBCellFAB a_primPlus[SpaceDim],
464  EBFaceFAB a_fluxOne[SpaceDim],
465  BaseIVFAB<Real> a_coveredFluxNormMinu[SpaceDim],
466  BaseIVFAB<Real> a_coveredFluxNormPlus[SpaceDim],
467  Vector<VolIndex> a_coveredFaceNormMinu[SpaceDim],
468  Vector<VolIndex> a_coveredFaceNormPlus[SpaceDim],
469  const EBCellFAB& a_primState,
470  const EBCellFAB& a_source,
471  const DataIndex& a_dit,
472  const Real & a_time,
473  const Real & a_dt);
474 
475 
476  void
477  normalPred(EBCellFAB& a_primLo,
478  EBCellFAB& a_primHi,
479  const EBCellFAB& a_primState,
480  const EBCellFAB& a_slopePrim,
481  const Real& a_scale,
482  const int& a_dir,
483  const Box& a_box);
484 
485  void
486  incrementWithSource(EBCellFAB& a_primState,
487  const EBCellFAB& a_source,
488  const Real& a_scale,
489  const Box& a_box) ;
490 
491  void
492  updatePrim(EBCellFAB& a_primMinu,
493  EBCellFAB& a_primPlus,
494  const EBFaceFAB& a_primFace,
495  const BaseIVFAB<Real>& a_coveredPrimMinu,
496  const BaseIVFAB<Real>& a_coveredPrimPlus,
497  const Vector<VolIndex>& a_coveredFaceMinu,
498  const Vector<VolIndex>& a_coveredFacePlus,
499  const int& a_faceDir,
500  const Box& a_box,
501  const Real& a_scale);
502 
503  void
504  upwindSlope(EBCellFAB& a_slopeUpWi,
505  const EBCellFAB& a_primState,
506  const int& a_dir,
507  const Box& a_box);
508 
509  void
510  transversePred(EBCellFAB& a_rhoLo,
511  EBCellFAB& a_rhoHi,
512  const EBCellFAB& a_rho,
513  const EBCellFAB& a_dRho,
514  const Real& a_dtbydx,
515  const int& a_dir,
516  const Box& a_box);
517 };
518 
519 #include "NamespaceFooter.H"
520 #endif
void mvExtrapolateBCG(EBFluxFAB &a_flux, const EBCellFAB &a_consState, const EBFluxFAB &a_advectionVel, const EBCellFAB &a_normalVel, const EBCellFAB &a_source, const Vector< RefCountedPtr< EBPhysIBCFactory > > &a_allAdvectBC, const DataIndex &a_dit, const Real &a_time, const Real &a_dt, const int &a_doingVel)
void pointExtrapToCovered2D(Vector< Real > &a_extrapVal, const EBFaceFAB &a_primFace, const EBCellFAB &a_primState, const int &a_faceDir, const VolIndex &a_vof, const RealVect &a_normal, const Side::LoHiSide &a_sd, const int &a_numPrim)
Definition: Stencils.H:181
An irregular domain on an integer lattice.
Definition: IntVectSet.H:44
A class to facilitate interaction with physical boundary conditions.
Definition: ProblemDomain.H:141
bool m_isMaxMinSet
Definition: EBAdvectPatchIntegrator.H:215
void consUndividedDivergence(BaseIVFAB< Real > &a_divF, const BaseIFFAB< Real > a_centroidFlux[SpaceDim], const IntVectSet &a_ivs)
const EBFluxFAB * m_advectionVelPtr
Definition: EBAdvectPatchIntegrator.H:212
virtual ~EBAdvectPatchIntegrator()
Definition: EBAdvectPatchIntegrator.H:50
one dimensional dynamic array
Definition: Vector.H:53
bool m_isVelSet
Definition: EBAdvectPatchIntegrator.H:214
Definition: FaceIndex.H:28
void extrapolateBCG(EBFluxFAB &a_flux, const EBCellFAB &a_consState, const EBCellFAB &a_source, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
void setMaxMin(const Real &a_maxVal, const Real &a_minVal)
Definition: EBAdvectPatchIntegrator.H:204
void doNormalDerivativeExtr2D(EBCellFAB a_primMinu[SpaceDim], EBCellFAB a_primPlus[SpaceDim], EBFaceFAB a_fluxOne[SpaceDim], BaseIVFAB< Real > a_coveredFluxNormMinu[SpaceDim], BaseIVFAB< Real > a_coveredFluxNormPlus[SpaceDim], Vector< VolIndex > a_coveredFaceNormMinu[SpaceDim], Vector< VolIndex > a_coveredFaceNormPlus[SpaceDim], const EBCellFAB &a_primState, const EBCellFAB &a_source, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
and this is the simplified version
void normalPred(EBCellFAB &a_primLo, EBCellFAB &a_primHi, const EBCellFAB &a_primState, const EBCellFAB &a_slopePrim, const Real &a_scale, const int &a_dir, const Box &a_box)
Definition: EBISBox.H:46
void slope(EBCellFAB &a_slopePrim, const EBCellFAB &a_primState, const int &a_dir, const Box &a_box)
options for 4th ordeer slopes and flattening removed
void extrapolatePrim2D(EBCellFAB a_primMinu[SpaceDim], EBCellFAB a_primPlus[SpaceDim], const EBCellFAB &a_consState, const EBCellFAB &a_source, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
void pointGetSlopesUpwind(Real &a_dql, Real &a_dqr, Real &a_dqc, bool &a_hasFacesLeft, bool &a_hasFacesRigh, const VolIndex &a_vof, const EBCellFAB &a_primState, const int &a_dir, const int &a_ivar, const bool &a_verbose)
void setVelocities(const EBCellFAB &a_normalVel, const EBFluxFAB &a_advectionVel)
Definition: EBAdvectPatchIntegrator.H:105
void interpolateFluxToCentroids(BaseIFFAB< Real > a_centroidFlux[SpaceDim], const BaseIFFAB< Real > *const a_fluxInterpolant[SpaceDim], const IntVectSet &a_irregIVS)
Definition: EBFaceFAB.H:28
Definition: EBAdvectPatchIntegrator.H:38
Real m_maxVal
Definition: EBAdvectPatchIntegrator.H:217
const int SpaceDim
Definition: SPACE.H:38
void finalExtrap2D(EBCellFAB a_primMinu[SpaceDim], EBCellFAB a_primPlus[SpaceDim], const BaseIVFAB< Real > a_coveredFluxNormMinu[SpaceDim], const BaseIVFAB< Real > a_coveredFluxNormPlus[SpaceDim], const Vector< VolIndex > a_coveredFaceNormMinu[SpaceDim], const Vector< VolIndex > a_coveredFaceNormPlus[SpaceDim], const EBFaceFAB a_fluxOne[SpaceDim], const EBCellFAB &a_primState, const Real &a_time, const Real &a_dt)
void pointGetSlopes(Real &a_dql, Real &a_dqr, Real &a_dqc, bool &a_hasFacesLeft, bool &a_hasFacesRigh, const VolIndex &a_vof, const EBCellFAB &a_primState, const int &a_dir, const int &a_ivar, const bool &a_verbose)
Vector< VolIndex > m_coveredFaceMinuG4[SpaceDim]
Definition: EBAdvectPatchIntegrator.H:233
A EBFaceFAB-like container for edge-centered fluxes.
Definition: EBFluxFAB.H:25
IntVectSet m_coveredSetsPlusG4[SpaceDim]
Definition: EBAdvectPatchIntegrator.H:230
RealVect m_dx
Definition: EBAdvectPatchIntegrator.H:225
void finalExtrap3D(EBCellFAB a_primMinu[SpaceDim], EBCellFAB a_primPlus[SpaceDim], const BaseIVFAB< Real > a_coveredFluxMinu3D[SpaceDim][SpaceDim], const BaseIVFAB< Real > a_coveredFluxPlus3D[SpaceDim][SpaceDim], const EBFaceFAB a_fluxTwo[SpaceDim][SpaceDim], const EBCellFAB &a_primState, const Real &a_time, const Real &a_dt)
Real m_minVal
Definition: EBAdvectPatchIntegrator.H:218
static int s_doingVel
Definition: EBAdvectPatchIntegrator.H:237
bool m_useLimiting
Definition: EBAdvectPatchIntegrator.H:216
void upwindSlope(EBCellFAB &a_slopeUpWi, const EBCellFAB &a_primState, const int &a_dir, const Box &a_box)
Definition: EBCellFAB.H:29
bool m_isBCSet
Definition: EBAdvectPatchIntegrator.H:221
double Real
Definition: REAL.H:33
void floorPrimitives(EBCellFAB &a_primState, const Box &a_box)
floors if m_isMaxMinSet
Box m_validBoxG4
Definition: EBAdvectPatchIntegrator.H:227
Vector< VolIndex > m_coveredFacePlusG4[SpaceDim]
Definition: EBAdvectPatchIntegrator.H:232
void updatePrim(EBCellFAB &a_primMinu, EBCellFAB &a_primPlus, const EBFaceFAB &a_primFace, const BaseIVFAB< Real > &a_coveredPrimMinu, const BaseIVFAB< Real > &a_coveredPrimPlus, const Vector< VolIndex > &a_coveredFaceMinu, const Vector< VolIndex > &a_coveredFacePlus, const int &a_faceDir, const Box &a_box, const Real &a_scale)
void doNormalDerivativeExtr3D(EBCellFAB a_primMinu[SpaceDim], EBCellFAB a_primPlus[SpaceDim], EBFaceFAB a_fluxOne[SpaceDim], BaseIVFAB< Real > a_coveredFluxNormMinu[SpaceDim], BaseIVFAB< Real > a_coveredFluxNormPlus[SpaceDim], Vector< VolIndex > a_coveredFaceNormMinu[SpaceDim], Vector< VolIndex > a_coveredFaceNormPlus[SpaceDim], const EBCellFAB &a_primState, const EBCellFAB &a_source, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
IntVectSet m_coveredSetsMinuG4[SpaceDim]
Definition: EBAdvectPatchIntegrator.H:231
LoHiSide
Definition: LoHiSide.H:27
void coveredExtrapSlopes(Real &a_dq, const VolIndex &a_vof, const EBCellFAB &a_primState, const int &a_dir, const int &a_ivar)
void incrementWithSource(EBCellFAB &a_primState, const EBCellFAB &a_source, const Real &a_scale, const Box &a_box)
void transversePred(EBCellFAB &a_rhoLo, EBCellFAB &a_rhoHi, const EBCellFAB &a_rho, const EBCellFAB &a_dRho, const Real &a_dtbydx, const int &a_dir, const Box &a_box)
ProblemDomain m_domain
Definition: EBAdvectPatchIntegrator.H:223
static int getDoingVel()
Definition: EBAdvectPatchIntegrator.H:181
Definition: EBPhysIBCFactory.H:25
IntVectSet m_cfivs
Definition: EBAdvectPatchIntegrator.H:226
void riemann(BaseIVFAB< Real > &a_coveredPrim, const BaseIVFAB< Real > &a_exteState, const EBCellFAB &a_primState, const Vector< VolIndex > &a_vofset, const int &a_faceDir, const Side::LoHiSide &a_sd, const Box &a_box)
virtual void define(const ProblemDomain &a_domain, const RealVect &a_dx)=0
A Rectangular Domain on an Integer Lattice.
Definition: Box.H:469
A Real vector in SpaceDim-dimensional space.
Definition: RealVect.H:41
Definition: DataIndex.H:114
Definition: BaseIFFAB.H:34
EBISBox m_ebisBox
Definition: EBAdvectPatchIntegrator.H:224
void extrapolatePrim3D(EBCellFAB a_primMinu[SpaceDim], EBCellFAB a_primPlus[SpaceDim], const EBCellFAB &a_consState, const EBCellFAB &a_source, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
internal functions (all the madness below probably needs to get cleaned up)
const EBCellFAB * m_normalVelPtr
Definition: EBAdvectPatchIntegrator.H:213
EBAdvectPatchIntegrator()
weak construction is bad.
void extrapToCoveredFaces(BaseIVFAB< Real > &a_extendedPrim, const EBFaceFAB &a_primFace, const EBCellFAB &a_primState, const Vector< VolIndex > &a_coveredFaces, const int &a_faceDir, const Side::LoHiSide &a_sd, const Box &a_box)
FaceStencil getInterpStencil(const FaceIndex &a_face) const
static int s_curComp
these exist because special things have to be done for velocity
Definition: EBAdvectPatchIntegrator.H:236
Box m_validBox
Definition: EBAdvectPatchIntegrator.H:222
RefCountedPtr< EBPhysIBC > m_bc
Definition: EBAdvectPatchIntegrator.H:220
Vector< VolIndex > m_irregVoFs
Definition: EBAdvectPatchIntegrator.H:228
Volume of Fluid Index.
Definition: VolIndex.H:31
void setEBPhysIBC(const EBPhysIBCFactory &a_bc)
Definition: EBAdvectPatchIntegrator.H:98
void kappaDivergenceFlux(EBCellFAB &a_kappaDivF, const EBFluxFAB &a_centroidFlux, const Box &a_validBox)
virtual EBPhysIBC * create() const =0
Real bilinearFunc(const Real a_WVal[2][2], const Real &a_xd1, const Real &a_xd2)
void extrapolatePrim(EBFluxFAB &a_flux, Vector< BaseIVFAB< Real > * > &a_coveredFluxMinu, Vector< BaseIVFAB< Real > * > &a_coveredFluxPlus, const Vector< IntVectSet > &a_coveredSetsMinu, const Vector< IntVectSet > &a_coveredSetsPlus, const Vector< Vector< VolIndex > > &a_coveredFaceMinu, const Vector< Vector< VolIndex > > &a_coveredFacePlus, const EBCellFAB &a_consState, const EBCellFAB &a_source, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
void do111coupling(EBFaceFAB a_fluxTwo[SpaceDim][SpaceDim], BaseIVFAB< Real > a_coveredFluxMinu3D[SpaceDim][SpaceDim], BaseIVFAB< Real > a_coveredFluxPlus3D[SpaceDim][SpaceDim], const EBCellFAB a_primMinu[SpaceDim], const EBCellFAB a_primPlus[SpaceDim], const BaseIVFAB< Real > a_coveredFluxNormMinu[SpaceDim], const BaseIVFAB< Real > a_coveredFluxNormPlus[SpaceDim], const Vector< VolIndex > a_coveredFaceNormMinu[SpaceDim], const Vector< VolIndex > a_coveredFaceNormPlus[SpaceDim], const EBFaceFAB a_fluxOne[SpaceDim], const EBCellFAB &a_primState, const DataIndex &a_dit, const Real &a_time, const Real &a_dt)
void pointExtrapToCovered3D(Vector< Real > &a_extrapVal, const EBFaceFAB &a_primFace, const EBCellFAB &a_primState, const int &a_faceDir, const VolIndex &a_vof, const RealVect &a_normal, const Side::LoHiSide &a_sd, const int &a_numPrim)
static int getCurComp()
Definition: EBAdvectPatchIntegrator.H:185
void averageVelToCC(EBCellFAB &a_normalVel, const EBFluxFAB &a_advectionVel, const Vector< BaseIVFAB< Real > * > &a_coveredVeloLo, const Vector< BaseIVFAB< Real > * > &a_coveredVeloHi, const Vector< Vector< VolIndex > > &a_coveredFaceLo, const Vector< Vector< VolIndex > > &a_coveredFaceHi, const Box &a_box) const
void advectiveDerivative(EBCellFAB &a_uDotDelRho, const EBFluxFAB &a_faceRho, const EBFluxFAB &a_faceVel, const Vector< BaseIVFAB< Real > * > &a_coveredRhoLo, const Vector< BaseIVFAB< Real > * > &a_coveredRhoHi, const Vector< BaseIVFAB< Real > * > &a_coveredVelLo, const Vector< BaseIVFAB< Real > * > &a_coveredVelHi, const Vector< Vector< VolIndex > > &a_coveredFaceLo, const Vector< Vector< VolIndex > > &a_coveredFaceHi, const Box &a_box)
static void setDoingVel(int a_yesorno)
Definition: EBAdvectPatchIntegrator.H:176
static void setCurComp(int a_curComp)
here are a couple of awful hooks necessary to get the minutiae of the algorithm correct ...
Definition: EBAdvectPatchIntegrator.H:171