Chombo + EB + MF  3.2
GraphNode.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 // ANAG, LBNL
12 
13 #ifndef _GRAPHNODE_H_
14 #define _GRAPHNODE_H_
15 
16 #include "REAL.H"
17 #include "ProblemDomain.H"
18 #include "IntVect.H"
19 #include "VolIndex.H"
20 #include "FaceIndex.H"
21 #include "Vector.H"
22 #include "Arena.H"
23 #include "NamespaceHeader.H"
24 
25 ///
26 /**
27  This is the graph data held for each irregular node.
28  Warning: each GraphNode holds a <EM>Vector</EM> of GraphNodeImplems.
29  */
31 {
32 public:
33  ///
34  inline
36 
37  ///
38  inline
40 
41  ///
42  GraphNodeImplem& operator=(const GraphNodeImplem& a_impin);
43 
44  ///
45  GraphNodeImplem(const GraphNodeImplem& a_impin);
46 
47  /// If true, this represents a regular cell and only m_coarserNode will be valid
49 
50  /// Used to mark a GraphNode as invalid - used in getting connected components of the graph
51  bool m_isValid;
52 
53  ///
54  /**
55  Cell indicies of neighboring cells.
56  If the arc is a boundary face, the int = -1
57  */
59 
60  /// Cell index of this vof is the index into the vector
61 
62  /// Cell index of next coarser vof
64 
65  /// Index into node vector (for construction).
66  int m_nodeInd;
67 
68  /// List of finer vofs
70 
71  /// Return the index into the arc vector
72  inline int index(int a_idir, Side::LoHiSide a_side) const;
73 
74  ///
75  int linearSize() const;
76 
77  ///
78  void linearOut(void* buffer ) const;
79 
80  ///
81  void linearIn(void* buffer );
82 
83  friend class EBISLevel;
84 };
85 
86 ///
87 /**
88  This is a list showing the connectivity of a given cell. This
89  has the special property of also being able to set itself to regular
90  or covered by setting the current nodeimplem pointer to 1 or 0.
91  */
92 class GraphNode
93 {
94 public:
95  ///
96  /**
97  Constructor sets node to regular as default.
98  */
99  inline GraphNode();
100 
101  ///
102  /**
103  */
104  inline ~GraphNode();
105 
106  ///
107  int size() const;
108 
109  ///
110  /**
111  Deletes memory if it has been allocated and sets
112  members to 0
113  */
114  inline void clear();
115 
116  ///
117  /**
118  Return true if the node is covered (m_cellList==0).
119  */
120  inline bool isCovered() const;
121 
122  ///
123  /**
124  Return true if the node is regular.
125  */
126  inline bool isRegular() const;
127 
128  ///
129  /**
130  Return true if the node is regular and has a single-valued parent
131  (m_cellList==1).
132  */
133  inline bool isRegularWithSingleValuedParent() const;
134 
135  ///
136  /**
137  Return true if the node is regular and has a multi-valued parent
138  (m_cellList is a valid pointer)
139  */
140  inline bool isRegularWithMultiValuedParent() const;
141 
142  ///
143  /**
144  Return true if the node is neither regular or covered.
145  */
146  inline bool isIrregular() const;
147 
148  ///
149  /**
150  Return true if the node has a valid m_cellList pointer
151  */
152  inline bool hasValidCellList() const;
153 
154  ///
155  /**
156  Set Node to regular. If previously set to irregular,
157  deletes their memory.
158  */
159  inline void defineAsRegular();
160 
161  ///
162  /**
163  Set Node to covered. If previously set to irregular,
164  deletes their memory.
165  */
166  inline void defineAsCovered();
167 
168  ///
169  /**
170  Get the faces in the direction and side
171  for the vof in the list. if the vof's cell
172  index is not found in the list, abort.
173  Use the input vof's grid index for a the grid index
174  of the list.
175  */
177  getFaces(const VolIndex& a_vof,
178  const int& a_idir,
179  const Side::LoHiSide& a_sd,
180  const ProblemDomain& a_domain) const;
181 
182  ///
184  getFaces(const IntVect& a_iv,
185  const int& a_idir,
186  const Side::LoHiSide& a_sd,
187  const ProblemDomain& a_domain) const;
188 
189  ///
190  /**
191  Return all the vofs in the list, using the input
192  intvect for the gridIndex
193  */
195  getVoFs(const IntVect& a_iv) const;
196 
197  ///
198  const GraphNode& operator=(const GraphNode& ebiin);
199 
200  ///
201  GraphNode(const GraphNode& ebiin);
202 
203  ///
204  /**
205  Returns the corresponding set of VoFs from the next finer
206  EBGraph (factor of two refinement). The result is only
207  defined if this {\tt EBGraph} was defined by coarsening.
208  */
209  Vector<VolIndex> refine(const VolIndex& a_coarVoF) const;
210 
211  ///
212  /**
213  Returns the corresponding VoF from the next coarser
214  EBGraph (same solution location, different index space, factor
215  of two refinement ratio).
216  */
217  VolIndex coarsen(const VolIndex& a_fineVoF) const;
218 
219  ///
220  /**
221  */
222  void addIrregularNode(const GraphNodeImplem& a_nodein, int cellIndex);
223  ///
224  /**
225  */
226  void addIrregularNode(const GraphNodeImplem& a_nodein);
227 
228  ///
229  /**
230  Get all sets of connected vofs within the box (used in coarsening)
231  */
232  Vector<Vector<VolIndex> > getVoFSets(const Box& a_box) const;
233 
234  ///
235  int linearSize() const;
236 
237  ///
238  void linearOut(void* buffer ) const;
239 
240  ///
241  void linearIn(void* buffer );
242 
243  /// internal use only
244  inline void setDefaults();
245 
246  void* alloc();
247  ///
248  /**
249  The connectivity data at this point.
250  If m_cellList == 0, node is covered.
251  If m_cellList == 1, node is regular and parent is single-valued.
252  otherwise, it is a real list (node may still be regular).
253  */
255 
256  static BArena s_Arena;
257 
258  friend class EBISLevel;
259 };
260 
261 /* Inline functions */
262 /*******************************/
264 {
265  clear();
266 }
267 
268 /*******************************/
269 inline bool GraphNode::isCovered() const
270 {
271  return (m_cellList == ((Vector<GraphNodeImplem>*) 0));
272 }
273 
274 /*******************************/
275 inline bool GraphNode::isRegular() const
276 {
279 }
280 
281 /*******************************/
283 {
284  return (m_cellList == ((Vector<GraphNodeImplem>*) 1));
285 }
286 
287 /*******************************/
289 {
290  return (((m_cellList != ((Vector<GraphNodeImplem>*) 0)) &&
291  ((*m_cellList).size() == 1) &&
292  ((*m_cellList)[0]).m_isRegular));
293 }
294 
295 /*******************************/
296 inline bool GraphNode::hasValidCellList() const
297 {
298  return (!isCovered() && !isRegularWithSingleValuedParent());
299 }
300 
301 /*******************************/
302 inline bool GraphNode::isIrregular() const
303 {
304  return ((!isRegular()) && (!isCovered()));
305 }
306 
307 /*******************************/
309 {
311 }
312 
313 /*******************************/
315 {
316  setDefaults();
317 }
318 
319 /*******************************/
320 inline void GraphNode::clear()
321 {
322  if (hasValidCellList())
323  {
324  // delete m_cellList;
327 #ifdef CH_USE_MEMORY_TRACKING
328  ch_memcount-=sizeof(Vector<GraphNodeImplem>);
329  s_Arena.bytes -= sizeof(Vector<GraphNodeImplem>);
330  CH_assert(s_Arena.bytes >= 0);
331 #endif
332  }
333  setDefaults();
334 }
335 
336 /*******************************/
338 {
339  clear();
341 }
342 
343 /*******************************/
345 {
346  clear();
348 }
349 
350 /*******************************/
352  : m_isRegular(false),
353  m_isValid(true),
354  m_coarserNode(-1),
355  m_nodeInd(-1)
356 {
357 }
358 
359 /*******************************/
361 {
362 }
363 
364 /*******************************/
365 inline int GraphNodeImplem::index(int a_idir,
366  Side::LoHiSide a_sd) const
367 {
368  CH_assert(a_idir >= 0 && a_idir < SpaceDim);
369  return a_idir + a_sd*CH_SPACEDIM;
370 }
371 
372 /*
373  if (a_sd == Side::Lo)
374  {
375  retval = a_idir;
376  }
377  else
378  {
379  retval = a_idir + SpaceDim;
380  }
381  return retval;
382 }
383 */
384 
385 #include "NamespaceFooter.H"
386 
387 #endif
virtual void free(void *a_pt)
Deletes the arena pointed to by a_pt.
bool hasValidCellList() const
Definition: GraphNode.H:296
void linearIn(void *buffer)
#define CH_SPACEDIM
Definition: SPACE.H:51
#define CH_assert(cond)
Definition: CHArray.H:37
A class to facilitate interaction with physical boundary conditions.
Definition: ProblemDomain.H:141
Vector< Vector< VolIndex > > getVoFSets(const Box &a_box) const
void linearIn(void *buffer)
Vector< VolIndex > getVoFs(const IntVect &a_iv) const
void addIrregularNode(const GraphNodeImplem &a_nodein, int cellIndex)
bool m_isValid
Used to mark a GraphNode as invalid - used in getting connected components of the graph...
Definition: GraphNode.H:51
Definition: EBISLevel.H:84
GraphNodeImplem & operator=(const GraphNodeImplem &a_impin)
void defineAsCovered()
Definition: GraphNode.H:344
virtual ~Vector()
Definition: Vector.H:72
void * alloc()
int m_coarserNode
Cell index of this vof is the index into the vector.
Definition: GraphNode.H:63
VolIndex coarsen(const VolIndex &a_fineVoF) const
~GraphNodeImplem()
Definition: GraphNode.H:360
A Concrete Class for Dynamic Memory Management.
Definition: Arena.H:124
bool m_isRegular
If true, this represents a regular cell and only m_coarserNode will be valid.
Definition: GraphNode.H:48
const int SpaceDim
Definition: SPACE.H:38
const GraphNode & operator=(const GraphNode &ebiin)
int m_nodeInd
Index into node vector (for construction).
Definition: GraphNode.H:66
~GraphNode()
Definition: GraphNode.H:263
Vector< VolIndex > m_finerNodes
List of finer vofs.
Definition: GraphNode.H:69
bool isRegular() const
Definition: GraphNode.H:275
int index(int a_idir, Side::LoHiSide a_side) const
Return the index into the arc vector.
Definition: GraphNode.H:365
GraphNode()
Definition: GraphNode.H:314
void setDefaults()
internal use only
Definition: GraphNode.H:308
int size() const
GraphNodeImplem()
Definition: GraphNode.H:351
int linearSize() const
LoHiSide
Definition: LoHiSide.H:27
void clear()
Definition: GraphNode.H:320
static BArena s_Arena
Definition: GraphNode.H:256
A Rectangular Domain on an Integer Lattice.
Definition: Box.H:469
bool isIrregular() const
Definition: GraphNode.H:302
int linearSize() const
void linearOut(void *buffer) const
An integer Vector in SpaceDim-dimensional space.
Definition: CHArray.H:42
Definition: GraphNode.H:30
Vector< VolIndex > refine(const VolIndex &a_coarVoF) const
Volume of Fluid Index.
Definition: VolIndex.H:31
Vector< FaceIndex > getFaces(const VolIndex &a_vof, const int &a_idir, const Side::LoHiSide &a_sd, const ProblemDomain &a_domain) const
Vector< int > m_arc[2 *SpaceDim]
Definition: GraphNode.H:58
void defineAsRegular()
Definition: GraphNode.H:337
bool isCovered() const
Definition: GraphNode.H:269
Vector< GraphNodeImplem > * m_cellList
Definition: GraphNode.H:254
Definition: GraphNode.H:92
bool isRegularWithMultiValuedParent() const
Definition: GraphNode.H:288
void linearOut(void *buffer) const
bool isRegularWithSingleValuedParent() const
Definition: GraphNode.H:282