Chombo + EB + MF  3.2
MFPoissonOp.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 // BVS, Nov 3, 2004
12 
13 #ifndef _MFPOISSONOP_H_
14 #define _MFPOISSONOP_H_
15 
16 #include "AMRMultiGrid.H"
17 #include "REAL.H"
18 #include "Box.H"
19 #include "MFCellFAB.H"
20 #include "EBAMRPoissonOp.H"
21 #include "MFIndexSpace.H"
22 #include "MFCellFAB.H"
23 #include "MFFluxFAB.H"
24 #include "RefCountedPtr.H"
25 #include "BaseDomainBC.H"
26 #include "BaseBCValue.H"
27 #include "BaseEBBC.H"
28 #include "BaseIVFAB.H"
29 #include "InterfaceJump.H"
30 #include "LevelDataOps.H"
31 #include "AMRTGA.H"
32 #include "NamespaceHeader.H"
33 
34 /// Multifluid poisson operator -- computes (alpha + div(Beta Grad))
35 /**
36  */
37 class MFPoissonOp : public TGAHelmOp< LevelData<MFCellFAB> >
38 {
39 public:
40  /// Default constructor
42  {
43  }
44 
45  /// destructor
46  virtual ~MFPoissonOp();
47  /**
48  \name LinearOp functions */
49  /*@{*/
50 
51  /// full define function for AMRLevelOp with both coarser and finer levels
52  void define(const MFIndexSpace& a_mfis,
53  int a_ncomp,
54  const DisjointBoxLayout& a_grids,
55  const DisjointBoxLayout& a_gridsCoarMG,
56  const bool& a_hasMGObjects,
57  const bool& a_layoutChanged,
58  const DisjointBoxLayout& a_gridsFiner,
59  const DisjointBoxLayout& a_gridsCoarser,
60  const RealVect& a_dxLevel,
61  int a_refRatio,
62  int a_refRatioFiner,
63  const ProblemDomain& a_domain,
64  const Vector<RefCountedPtr<BaseDomainBC> >& a_bc,
65  const IntVect& a_ghostPhi,
66  const IntVect& a_ghostRHS,
67  bool hasCoarser,
68  bool hasFiner ,
69  const Vector<Real>& a_alpha,
70  const Vector<Real>& a_beta
71  );
72 
73  // (TGA) reset constants in the equation
74  virtual void setAlphaAndBeta(const Real& a_alpha,
75  const Real& a_beta);
76 
77  /// (TGA) set diagonal scale of the operator
78  virtual void diagonalScale(LevelData<MFCellFAB>& a_rhs);
79 
80  ///TGA --no op in this case
82  {
83  }
84  /// (TGA) apply operator without any boundary or coarse-fine
85  /// boundary conditions and no finer level
86  virtual void applyOpNoBoundary(LevelData<MFCellFAB>& a_opPhi,
87  const LevelData<MFCellFAB>& a_phi);
88 
89  //conforms to AMRTGA
90  virtual void setTime(Real a_time);
91 
92  ///
93  virtual void residual( LevelData<MFCellFAB>& a_lhs,
94  const LevelData<MFCellFAB>& a_phi,
95  const LevelData<MFCellFAB>& a_rhs,
96  bool a_homogeneous = false);
97 
98  /// Apply the preconditioner
99  virtual void preCond( LevelData<MFCellFAB>& a_correction,
100  const LevelData<MFCellFAB>& a_residual);
101 
102  ///
103  virtual void applyOp( LevelData<MFCellFAB>& a_lhs,
104  const LevelData<MFCellFAB>& a_phi,
105  DataIterator& a_dit,
106  bool a_homogeneous = false);
107 
108  ///
109  virtual void applyOp( LevelData<MFCellFAB>& a_lhs,
110  const LevelData<MFCellFAB>& a_phi,
111  bool a_homogeneous = false);
112 
113  /// create a clone of this MFPoissonOp
114  virtual void create( LevelData<MFCellFAB>& a_lhs,
115  const LevelData<MFCellFAB>& a_rhs);
116 
117  ///
118  virtual void createCoarsened( LevelData<MFCellFAB>& a_lhs,
119  const LevelData<MFCellFAB>& a_rhs,
120  const int& a_refRat);
121 
122  ///
123  virtual void assign( LevelData<MFCellFAB>& a_lhs,
124  const LevelData<MFCellFAB>& a_rhs) ;
125 
126  ///
127  virtual Real dotProduct(const LevelData<MFCellFAB>& a_1,
128  const LevelData<MFCellFAB>& a_2) ;
129 
130  ///
131  virtual void incr( LevelData<MFCellFAB>& a_lhs,
132  const LevelData<MFCellFAB>& a_x,
133  Real a_scale) ;
134 
135  ///
136  virtual void axby( LevelData<MFCellFAB>& a_lhs,
137  const LevelData<MFCellFAB>& a_x,
138  const LevelData<MFCellFAB>& a_y,
139  Real a, Real b) ;
140 
141  ///
142  virtual void scale(LevelData<MFCellFAB>& a_lhs, const Real& a_scale) ;
143 
144  ///
145  virtual Real norm(const LevelData<MFCellFAB>& a_x, int a_ord);
146 
147  ///
148  virtual void setToZero( LevelData<MFCellFAB>& a_x);
149  /*@}*/
150 
151  /**
152  \name MGLevelOp functions */
153  /*@{*/
154 
155  ///
156  virtual void relax(LevelData<MFCellFAB>& a_e,
157  const LevelData<MFCellFAB>& a_residual,
158  int iterations);
159 
160  ///
161  virtual void createCoarser(LevelData<MFCellFAB>& a_coarse,
162  const LevelData<MFCellFAB>& a_fine,
163  bool ghosted);
164 
165  ///
166  /**
167  calculate restricted residual
168  a_resCoarse[2h] = I[h->2h] (rhsFine[h] - L[h](phiFine[h])
169  */
170  virtual void restrictResidual(LevelData<MFCellFAB>& a_resCoarse,
171  LevelData<MFCellFAB>& a_phiFine,
172  const LevelData<MFCellFAB>& a_rhsFine);
173 
174 
175  ///
176  /**
177  correct the fine solution based on coarse correction
178  a_phiThisLevel += I[2h->h](a_correctCoarse)
179  */
180  virtual void prolongIncrement(LevelData<MFCellFAB>& a_phiThisLevel,
181  const LevelData<MFCellFAB>& a_correctCoarse);
182 
183  /*@}*/
184 
185  /**
186  \name AMRLevelOp functions */
187  /*@{*/
188 
189  ///
190  /** returns 1 when there are no coarser AMRLevelOp objects */
191  virtual int refToCoarser()
192  {
193  return m_refToCoarser;
194  }
195 
196  ///
197  /** a_residual = a_rhs - L(a_phi, a_phiFine, a_phiCoarse) */
198  virtual void AMRResidual(LevelData<MFCellFAB>& a_residual,
199  const LevelData<MFCellFAB>& a_phiFine,
200  const LevelData<MFCellFAB>& a_phi,
201  const LevelData<MFCellFAB>& a_phiCoarse,
202  const LevelData<MFCellFAB>& a_rhs,
203  bool a_homogeneousBC,
204  AMRLevelOp<LevelData<MFCellFAB> >* a_finerOp);
205  ///
206  /** residual assuming no more coarser AMR levels */
207  virtual void AMRResidualNC(LevelData<MFCellFAB>& a_residual,
208  const LevelData<MFCellFAB>& a_phiFine,
209  const LevelData<MFCellFAB>& a_phi,
210  const LevelData<MFCellFAB>& a_rhs,
211  bool a_homogeneousBC,
212  AMRLevelOp<LevelData<MFCellFAB> >* a_finerOp);
213 
214  /** a_residual = a_rhs - L(a_phi, a_phiCoarse) */
215  virtual void AMRResidualNF(LevelData<MFCellFAB>& a_residual,
216  const LevelData<MFCellFAB>& a_phi,
217  const LevelData<MFCellFAB>& a_phiCoarse,
218  const LevelData<MFCellFAB>& a_rhs, bool a_homogeneousBC);
219 
220 
221  ///
222  /** apply AMR operator, including coarse-fine matching conditions */
223  virtual void AMROperator(LevelData<MFCellFAB>& a_LofPhi,
224  const LevelData<MFCellFAB>& a_phiFine,
225  const LevelData<MFCellFAB>& a_phi,
226  const LevelData<MFCellFAB>& a_phiCoarse,
227  bool a_homogeneousBC,
228  AMRLevelOp<LevelData<MFCellFAB> >* a_finerOp);
229  ///
230  /** AMR operator assuming no more coarser AMR levels */
231  virtual void AMROperatorNC(LevelData<MFCellFAB>& a_LofPhi,
232  const LevelData<MFCellFAB>& a_phiFine,
233  const LevelData<MFCellFAB>& a_phi,
234  bool a_homogeneousBC,
235  AMRLevelOp<LevelData<MFCellFAB> >* a_finerOp);
236 
237  /** AMR operator assuming no finer level */
238  virtual void AMROperatorNF(LevelData<MFCellFAB>& a_LofPhi,
239  const LevelData<MFCellFAB>& a_phi,
240  const LevelData<MFCellFAB>& a_phiCoarse,
241  bool a_homogeneousBC);
242 
243 
244 
245 
246  ///
247  /** a_resCoarse = I[h-2h]( a_residual - L(a_correction, a_coarseCorrection))
248  it is assumed that a_resCoarse has already been filled in with the coarse
249  version of AMRResidualNF and that this operation is free to overwrite
250  in the overlap regions.
251  */
252  virtual void AMRRestrict(LevelData<MFCellFAB>& a_resCoarse,
253  const LevelData<MFCellFAB>& a_residual,
254  const LevelData<MFCellFAB>& a_correction,
255  const LevelData<MFCellFAB>& a_coarseCorrection,
256  bool a_skip_res);
257 
258  ///
259  /** a_correction += I[h->h](a_coarseCorrection) */
260  virtual void AMRProlong(LevelData<MFCellFAB>& a_correction,
261  const LevelData<MFCellFAB>& a_coarseCorrection);
262 
263  ///
264  /** a_residual = a_residual - L(a_correction, a_coarseCorrection) */
265  virtual void AMRUpdateResidual(LevelData<MFCellFAB>& a_residual,
266  const LevelData<MFCellFAB>& a_correction,
267  const LevelData<MFCellFAB>& a_coarseCorrection);
268 
269  ///
270  /**
271  compute norm over all cells on coarse not covered by finer
272  */
273  virtual Real AMRNorm(const LevelData<MFCellFAB>& a_coarseResid,
274  const LevelData<MFCellFAB>& a_fineResid,
275  const int& a_refRat,
276  const int& a_ord);
277 
278  /*@}*/
279 
280  /// set the jump conditions at the multifluid interface
281  void setJump(const Real& gD, const Real& gN);
282  void setJump(const RealVect& a_gD, const RealVect& a_gN);
283 
284  ///
285  /**
286  version where we want to specify the interface jumps
287  through analytic function
288  */
289  void setJump(const Vector< RefCountedPtr<BaseBCValue> >& a_phiValVect,
290  const Vector< RefCountedPtr<BaseBCValue> >& a_flxValVect);
291 
292  void setVal(LevelData<MFCellFAB>& a_phi, const Vector<Real> a_values) const;
293 
294  ///
295  EBAMRPoissonOp* ebOp(int phase)
296  {
297  return m_ebops[phase];
298  }
299 
300  ///
301  /**
302  return total flux across all irregular faces in a_phase
303  */
304  Real totalBoundaryFlux(int a_phase,
305  const LevelData<MFCellFAB>& a_phi,
306  Real a_factor = 1.0,
307  bool a_divideByTotalArea = true);
308 
310  LevelData<MFCellFAB>& a_dPhi_dN,
311  Real a_invalidVal = 1.2345678e90);
312 
313  Real exactBoundaryFlux(int a_phase,
315  RealVect& a_origin,
316  const Real& a_time);
317 
318 
319  ///
320  /**
321  dump stencil as matrix to stdout
322  */
324  {
325  public:
327  int& a_phase)
328  {
329  m_vof = a_vof;
330  m_phase = a_phase;
331  }
332 
334  {
335  MayDay::Error("No weak construction of StencilIndex class.");
336  }
337 
339  {
340  return *this;
341  }
342 
343  VolIndex vof() const
344  {
345  return m_vof;
346  }
347 
348  int phase() const
349  {
350  return m_phase;
351  }
352 
353  protected:
355  int m_phase;
356  };
357 
359  {
360  public:
361  bool operator() (const StencilIndex& a_s1, const StencilIndex& a_s2) const
362  {
363  /*
364  int p1 = a_s1.phase();
365  int p2 = a_s2.phase();
366  if (p1 == p2)
367  {
368  return (a_s1.vof()<a_s2.vof());
369  }
370  else
371  {
372  const IntVect& iv1 = a_s1.vof().gridIndex();
373  const IntVect& iv2 = a_s2.vof().gridIndex();
374  if (iv1 == iv2)
375  {
376  return (p1<p2);
377  }
378  else
379  {
380  return (iv1<iv2);
381  }
382  }
383  */
384  const IntVect& iv1 = a_s1.vof().gridIndex();
385  const IntVect& iv2 = a_s2.vof().gridIndex();
386  for (int idir=0; idir<SpaceDim; ++idir)
387  {
388  if (iv1[idir] != iv2[idir])
389  {
390  return (iv1[idir]<iv2[idir]);
391  }
392  }
393  int p1 = a_s1.phase();
394  int p2 = a_s2.phase();
395  if (p1 == p2)
396  {
397  int ci1 = a_s1.vof().cellIndex();
398  int ci2 = a_s2.vof().cellIndex();
399  return (ci1<ci2);
400  }
401  else
402  {
403  return (p1<p2);
404  }
405  }
406  };
407 
408  void dumpStencilMatrix();
410 
411  ///
412  /**
413  return my domain
414  */
416  {
417  return m_domain;
418  }
419 
420  ///
421  /**
422  return fluxes at cell boundaries. at present only does regular faces.
423  */
424  void getFlux(MFFluxFAB& a_flux,
425  const LevelData<MFCellFAB>& a_data,
426  const Box& a_grid,
427  const DataIndex& a_dit,
428  Real a_scale);
429 
430  ///
431  int m_relax;
432 
434 
435 protected:
440 
447  LevelData<MFCellFAB> m_tmp; // temp of rhs/residual;
449 
452  InterfaceJump m_jump;// only one for now, just two-phase.
453 
454  void computeBoundaryN(const LevelData<MFCellFAB>& a_phi, bool a_homogeneous);
455 
456  void levelJacobi( LevelData<MFCellFAB>& a_phi,
457  const LevelData<MFCellFAB>& a_rhs);
458 
459  void levelGSRB( LevelData<MFCellFAB>& a_phi,
460  const LevelData<MFCellFAB>& a_rhs);
461 
463  const LevelData<MFCellFAB>& a_rhs);
464 
465  Real kappaNorm(Real& a_volume,
466  const LevelData<MFCellFAB>& a_data,
467  int a_p) const;
468 
471  int m_phases;
472  int m_ncomp;
474 };
475 
476 #include "NamespaceFooter.H"
477 #endif
virtual Real dotProduct(const LevelData< MFCellFAB > &a_1, const LevelData< MFCellFAB > &a_2)
StencilIndex()
Definition: MFPoissonOp.H:333
virtual void relax(LevelData< MFCellFAB > &a_e, const LevelData< MFCellFAB > &a_residual, int iterations)
Definition: MFIndexSpace.H:17
VolIndex m_vof
Definition: MFPoissonOp.H:354
int m_relax
Definition: MFPoissonOp.H:431
virtual Real AMRNorm(const LevelData< MFCellFAB > &a_coarseResid, const LevelData< MFCellFAB > &a_fineResid, const int &a_refRat, const int &a_ord)
A class to facilitate interaction with physical boundary conditions.
Definition: ProblemDomain.H:141
int phase() const
Definition: MFPoissonOp.H:348
virtual void setAlphaAndBeta(const Real &a_alpha, const Real &a_beta)
int m_ncomp
Definition: MFPoissonOp.H:472
void dumpReferenceStencilMatrix()
Vector< Real > m_bCoef
Definition: MFPoissonOp.H:437
virtual void prolongIncrement(LevelData< MFCellFAB > &a_phiThisLevel, const LevelData< MFCellFAB > &a_correctCoarse)
void getFlux(MFFluxFAB &a_flux, const LevelData< MFCellFAB > &a_data, const Box &a_grid, const DataIndex &a_dit, Real a_scale)
one dimensional dynamic array
Definition: Vector.H:53
virtual void applyOp(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_phi, DataIterator &a_dit, bool a_homogeneous=false)
LevelData< BaseIVFAB< Real > > m_boundaryD[2]
Definition: MFPoissonOp.H:450
Vector< LevelData< EBCellFAB > * > m_alias
Definition: MFPoissonOp.H:445
Multifluid poisson operator – computes (alpha + div(Beta Grad))
Definition: MFPoissonOp.H:37
IntVect m_ghostRHS
Definition: MFPoissonOp.H:473
virtual void AMRProlong(LevelData< MFCellFAB > &a_correction, const LevelData< MFCellFAB > &a_coarseCorrection)
virtual void scale(LevelData< MFCellFAB > &a_lhs, const Real &a_scale)
virtual int refToCoarser()
Definition: MFPoissonOp.H:191
void levelJacobi(LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_rhs)
virtual void create(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_rhs)
create a clone of this MFPoissonOp
LevelDataOps< MFCellFAB > m_ops
Definition: MFPoissonOp.H:446
void setVal(LevelData< MFCellFAB > &a_phi, const Vector< Real > a_values) const
Definition: DataIterator.H:190
Vector< Real > m_aCoef
Definition: MFPoissonOp.H:439
void levelGSRB(LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_rhs)
virtual void createCoarsened(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_rhs, const int &a_refRat)
VolIndex vof() const
Definition: MFPoissonOp.H:343
int m_phase
Definition: MFPoissonOp.H:355
virtual void AMRRestrict(LevelData< MFCellFAB > &a_resCoarse, const LevelData< MFCellFAB > &a_residual, const LevelData< MFCellFAB > &a_correction, const LevelData< MFCellFAB > &a_coarseCorrection, bool a_skip_res)
virtual void diagonalScale(LevelData< MFCellFAB > &a_rhs)
(TGA) set diagonal scale of the operator
Definition: AMRTGA.H:31
virtual void applyOpNoBoundary(LevelData< MFCellFAB > &a_opPhi, const LevelData< MFCellFAB > &a_phi)
const int SpaceDim
Definition: SPACE.H:38
int m_refToCoarser
Definition: MFPoissonOp.H:469
Definition: AMRMultiGrid.H:39
virtual Real norm(const LevelData< MFCellFAB > &a_x, int a_ord)
Definition: MFPoissonOp.H:358
virtual void AMROperatorNF(LevelData< MFCellFAB > &a_LofPhi, const LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_phiCoarse, bool a_homogeneousBC)
void setJump(const Real &gD, const Real &gN)
set the jump conditions at the multifluid interface
int cellIndex() const
Definition: VolIndex.H:133
virtual void AMRResidual(LevelData< MFCellFAB > &a_residual, const LevelData< MFCellFAB > &a_phiFine, const LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_phiCoarse, const LevelData< MFCellFAB > &a_rhs, bool a_homogeneousBC, AMRLevelOp< LevelData< MFCellFAB > > *a_finerOp)
IntVect m_ghostPhi
Definition: MFPoissonOp.H:473
Definition: EBAMRPoissonOp.H:76
MFPoissonOp()
Default constructor.
Definition: MFPoissonOp.H:41
Vector< Real > m_beta
Definition: MFPoissonOp.H:436
const IntVect & gridIndex() const
Definition: VolIndex.H:125
virtual void AMRUpdateResidual(LevelData< MFCellFAB > &a_residual, const LevelData< MFCellFAB > &a_correction, const LevelData< MFCellFAB > &a_coarseCorrection)
LevelData< BaseIVFAB< Real > > m_boundaryN[2]
Definition: MFPoissonOp.H:451
ProblemDomain getDomain()
Definition: MFPoissonOp.H:415
void dumpStencilMatrix()
virtual void divideByIdentityCoef(LevelData< MFCellFAB > &a_rhs)
TGA –no op in this case.
Definition: MFPoissonOp.H:81
int m_phases
Definition: MFPoissonOp.H:471
virtual void residual(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_rhs, bool a_homogeneous=false)
virtual void AMRResidualNC(LevelData< MFCellFAB > &a_residual, const LevelData< MFCellFAB > &a_phiFine, const LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_rhs, bool a_homogeneousBC, AMRLevelOp< LevelData< MFCellFAB > > *a_finerOp)
double Real
Definition: REAL.H:33
virtual void preCond(LevelData< MFCellFAB > &a_correction, const LevelData< MFCellFAB > &a_residual)
Apply the preconditioner.
Container for face-centered fluxes for multifluid.
Definition: MFFluxFAB.H:23
A BoxLayout that has a concept of disjointedness.
Definition: DisjointBoxLayout.H:30
void getBoundaryValues(LevelData< MFCellFAB > &a_phi, LevelData< MFCellFAB > &a_dPhi_dN, Real a_invalidVal=1.2345678e90)
bool operator()(const StencilIndex &a_s1, const StencilIndex &a_s2) const
Definition: MFPoissonOp.H:361
LevelData< MFCellFAB > m_tmp
Definition: MFPoissonOp.H:447
virtual ~MFPoissonOp()
destructor
void levelMulticolorGS(LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_rhs)
RealVect m_dx
Definition: MFPoissonOp.H:441
virtual void setToZero(LevelData< MFCellFAB > &a_x)
static void Error(const char *const a_msg=m_nullString, int m_exitCode=CH_DEFAULT_ERROR_CODE)
Print out message to cerr and exit with the specified exit code.
virtual void axby(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_x, const LevelData< MFCellFAB > &a_y, Real a, Real b)
Vector< IntVect > m_colors
Definition: MFPoissonOp.H:433
virtual void assign(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_rhs)
Vector< Real > m_alpha
Definition: MFPoissonOp.H:438
Real kappaNorm(Real &a_volume, const LevelData< MFCellFAB > &a_data, int a_p) const
Definition: InterfaceJump.H:22
A Rectangular Domain on an Integer Lattice.
Definition: Box.H:469
A Real vector in SpaceDim-dimensional space.
Definition: RealVect.H:41
StencilIndex & operator=(const StencilIndex &a_sin)
Definition: MFPoissonOp.H:338
Definition: MFPoissonOp.H:323
void computeBoundaryN(const LevelData< MFCellFAB > &a_phi, bool a_homogeneous)
Definition: DataIndex.H:114
virtual void createCoarser(LevelData< MFCellFAB > &a_coarse, const LevelData< MFCellFAB > &a_fine, bool ghosted)
Real totalBoundaryFlux(int a_phase, const LevelData< MFCellFAB > &a_phi, Real a_factor=1.0, bool a_divideByTotalArea=true)
ProblemDomain m_domain
Definition: MFPoissonOp.H:443
virtual void AMROperatorNC(LevelData< MFCellFAB > &a_LofPhi, const LevelData< MFCellFAB > &a_phiFine, const LevelData< MFCellFAB > &a_phi, bool a_homogeneousBC, AMRLevelOp< LevelData< MFCellFAB > > *a_finerOp)
virtual void AMRResidualNF(LevelData< MFCellFAB > &a_residual, const LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_phiCoarse, const LevelData< MFCellFAB > &a_rhs, bool a_homogeneousBC)
virtual void incr(LevelData< MFCellFAB > &a_lhs, const LevelData< MFCellFAB > &a_x, Real a_scale)
An integer Vector in SpaceDim-dimensional space.
Definition: CHArray.H:42
virtual void AMROperator(LevelData< MFCellFAB > &a_LofPhi, const LevelData< MFCellFAB > &a_phiFine, const LevelData< MFCellFAB > &a_phi, const LevelData< MFCellFAB > &a_phiCoarse, bool a_homogeneousBC, AMRLevelOp< LevelData< MFCellFAB > > *a_finerOp)
int m_refToFiner
Definition: MFPoissonOp.H:470
virtual void restrictResidual(LevelData< MFCellFAB > &a_resCoarse, LevelData< MFCellFAB > &a_phiFine, const LevelData< MFCellFAB > &a_rhsFine)
StencilIndex(VolIndex &a_vof, int &a_phase)
Definition: MFPoissonOp.H:326
RealVect m_dxCrse
Definition: MFPoissonOp.H:442
Volume of Fluid Index.
Definition: VolIndex.H:31
void define(const MFIndexSpace &a_mfis, int a_ncomp, const DisjointBoxLayout &a_grids, const DisjointBoxLayout &a_gridsCoarMG, const bool &a_hasMGObjects, const bool &a_layoutChanged, const DisjointBoxLayout &a_gridsFiner, const DisjointBoxLayout &a_gridsCoarser, const RealVect &a_dxLevel, int a_refRatio, int a_refRatioFiner, const ProblemDomain &a_domain, const Vector< RefCountedPtr< BaseDomainBC > > &a_bc, const IntVect &a_ghostPhi, const IntVect &a_ghostRHS, bool hasCoarser, bool hasFiner, const Vector< Real > &a_alpha, const Vector< Real > &a_beta)
full define function for AMRLevelOp with both coarser and finer levels
virtual void setTime(Real a_time)
Vector< EBAMRPoissonOp * > m_ebops
Definition: MFPoissonOp.H:444
Real exactBoundaryFlux(int a_phase, RefCountedPtr< BaseBCValue > a_flxVal, RealVect &a_origin, const Real &a_time)
EBAMRPoissonOp * ebOp(int phase)
Definition: MFPoissonOp.H:295
LevelData< MFCellFAB > m_weights
Definition: MFPoissonOp.H:448
InterfaceJump m_jump
Definition: MFPoissonOp.H:452