Arcane  4.1.12.0
User documentation
Loading...
Searching...
No Matches
ItemGroupComputeFunctor.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ItemGroupComputeFunctor.cc (C) 2000-2023 */
9/* */
10/* Functors for calculating elements of one group based on another group */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/ITraceMng.h"
15#include "arcane/utils/FatalErrorException.h"
16
17#include "arcane/core/Item.h"
18#include "arcane/core/ItemGroupComputeFunctor.h"
19#include "arcane/core/ItemGroupImpl.h"
20#include "arcane/core/ItemGroup.h"
21#include "arcane/core/IMesh.h"
22#include "arcane/core/IItemFamily.h"
23#include "arcane/core/Properties.h"
24
25/*---------------------------------------------------------------------------*/
26/*---------------------------------------------------------------------------*/
27
28namespace Arcane
29{
30
31/*---------------------------------------------------------------------------*/
32/*---------------------------------------------------------------------------*/
33
34//! Calculation of the group's own entities
35void OwnItemGroupComputeFunctor::
36executeFunctor()
37{
38 ITraceMng* trace = m_group->mesh()->traceMng();
39 ItemGroup parent(m_group->parent());
40
41 m_group->beginTransaction();
42 Int32UniqueArray items_lid;
43
44 ENUMERATE_ITEM (iitem, parent) {
45 Item item = *iitem;
46 if (item.isOwn())
47 items_lid.add(iitem.itemLocalId());
48 }
49 m_group->setItems(items_lid);
50 m_group->endTransaction();
51
52 trace->debug() << "OwnItemGroupComputeFunctor::execute()"
53 << " this=" << m_group
54 << " parent_name=" << parent.name()
55 << " name=" << m_group->name()
56 << " parent_count=" << parent.size()
57 << " mysize=" << m_group->size();
58}
59
60/*---------------------------------------------------------------------------*/
61/*---------------------------------------------------------------------------*/
62
63void GhostItemGroupComputeFunctor::
64executeFunctor()
65{
66 ITraceMng* trace = m_group->mesh()->traceMng();
67 ItemGroup parent(m_group->parent());
68 m_group->beginTransaction();
69 Int32UniqueArray items_lid;
70
71 ENUMERATE_ITEM (iitem, parent) {
72 Item item = *iitem;
73 if (!item.isOwn())
74 items_lid.add(iitem.itemLocalId());
75 }
76
77 m_group->setItems(items_lid);
78 m_group->endTransaction();
79
80 trace->debug() << "GhostItemGroupComputeFunctor::execute()"
81 << " this=" << m_group
82 << " parent_name=" << parent.name()
83 << " name=" << m_group->name()
84 << " parent_count=" << parent.size()
85 << " mysize=" << m_group->size();
86}
87
88/*---------------------------------------------------------------------------*/
89/*---------------------------------------------------------------------------*/
90
91void InterfaceItemGroupComputeFunctor::
92executeFunctor()
93{
94 ITraceMng* trace = m_group->mesh()->traceMng();
95 IItemFamily* family = m_group->itemFamily();
96 ItemGroup parent(m_group->parent());
97
98 if (family->itemKind() != IK_Face) {
99 trace->fatal() << "InterfaceGroupComputeFunctor::executeFunctor()"
100 << " Incoherent family expected=" << IK_Face << " current=" << family->itemKind();
101 }
102
103 m_group->beginTransaction();
104 Int32UniqueArray items_lid;
105
106 ENUMERATE_FACE (iface, parent) {
107 Face face = *iface;
108 Cell bcell = face.backCell();
109 Cell fcell = face.frontCell();
110 if (!bcell.null() && !fcell.null()) {
111 const bool isBackOwn = bcell.isOwn();
112 const bool isFrontOwn = fcell.isOwn();
113 if (isBackOwn != isFrontOwn) {
114 items_lid.add(face.localId());
115 }
116 }
117 }
118
119 m_group->setItems(items_lid);
120 m_group->endTransaction();
121
122 trace->debug() << "InterfaceItemGroupComputeFunctor::execute()"
123 << " this=" << m_group
124 << " parent_name=" << parent.name()
125 << " name=" << m_group->name()
126 << " parent_count=" << parent.size()
127 << " mysize=" << m_group->size();
128}
129
130/*---------------------------------------------------------------------------*/
131/*---------------------------------------------------------------------------*/
132
133/*!
134 * \brief Functor to calculate a group containing entities connected
135 * to the entities of the parent group.
136 */
137template <typename ItemType> void
138ItemItemGroupComputeFunctor<ItemType>::
139executeFunctor()
140{
141 IMesh* mesh = m_group->mesh();
142 ITraceMng* trace = m_group->mesh()->traceMng();
143 IItemFamily* family = m_group->itemFamily();
144 ItemGroup parent(m_group->parent());
145
146 eItemKind ik = ItemTraitsT<ItemType>::kind();
147 if (ik != family->itemKind()) {
148 ARCANE_FATAL("Incoherent family wanted={0} current={1} v={2}",
149 ik, family->itemKind(), m_group->itemKind());
150 }
151
152 m_group->beginTransaction();
153 Int32UniqueArray items_lid;
154 Int32UniqueArray markers(family->maxLocalId());
155 markers.fill(0);
156 ItemType* null_type = 0;
157 ENUMERATE_ITEM (iitem, parent) {
158 impl::ItemBase i = (*iitem).itemBase();
159 for (ItemEnumerator iitem2(i.itemList(null_type)); iitem2.hasNext(); ++iitem2) {
160 Int32 lid = iitem2.localId();
161 if (markers[lid] == 0) {
162 markers[lid] = 1;
163 items_lid.add(lid);
164 }
165 }
166 }
167 bool do_sort = mesh->properties()->getBoolWithDefault("sort-subitemitem-group", false);
168
169 m_group->setItems(items_lid, do_sort);
170 m_group->endTransaction();
171
172 trace->debug() << "ItemItemGroupComputeFunctor::execute()"
173 << " this=" << m_group
174 << " parent_name=" << parent.name()
175 << " name=" << m_group->name()
176 << " parent_count=" << parent.size()
177 << " mysize=" << m_group->size()
178 << " mysize2=" << items_lid.size();
179}
180
181/*---------------------------------------------------------------------------*/
182/*---------------------------------------------------------------------------*/
183
184void InnerFaceItemGroupComputeFunctor::
185executeFunctor()
186{
187 ITraceMng* trace = m_group->mesh()->traceMng();
188 IItemFamily* family = m_group->itemFamily();
189 ItemGroup parent(m_group->parent());
190 IItemFamily* parent_family = parent.itemFamily();
191 m_group->beginTransaction();
192 Int32UniqueArray items_lid;
193
194 if (parent.isAllItems()) {
195 ENUMERATE_FACE (iface, family->allItems()) {
196 const Face& face = *iface;
197 if (!face.isSubDomainBoundary())
198 items_lid.add(face.localId());
199 }
200 }
201 else {
202 BoolUniqueArray markers(parent_family->maxLocalId());
203 markers.fill(false);
204 ENUMERATE_CELL (icell, parent) {
205 markers[icell.localId()] = true;
206 }
207 ENUMERATE_FACE (iface, family->allItems()) {
208 Face face = *iface;
209 Cell bcell = face.backCell();
210 Cell fcell = face.frontCell();
211 if ((!bcell.null() && markers[bcell.localId()]) &&
212 (!fcell.null() && markers[fcell.localId()]))
213 items_lid.add(face.localId());
214 }
215 }
216
217 m_group->setItems(items_lid);
218 m_group->endTransaction();
219
220 trace->debug() << "InnerFaceItemGroupComputeFunctor::execute()"
221 << " this=" << m_group
222 << " parent_name=" << parent.name()
223 << " name=" << m_group->name()
224 << " parent_count=" << parent.size()
225 << " mysize=" << m_group->size();
226}
227
228/*---------------------------------------------------------------------------*/
229/*---------------------------------------------------------------------------*/
230
231void OuterFaceItemGroupComputeFunctor::
232executeFunctor()
233{
234 ITraceMng* trace = m_group->mesh()->traceMng();
235 IItemFamily* family = m_group->itemFamily();
236 ItemGroup parent(m_group->parent());
237 IItemFamily* parent_family = parent.itemFamily();
238 m_group->beginTransaction();
239 Int32UniqueArray items_lid;
240
241 if (parent.isAllItems()) {
242 ENUMERATE_FACE (iface, family->allItems()) {
243 const Face& face = *iface;
244 if (face.isSubDomainBoundary())
245 items_lid.add(face.localId());
246 }
247 }
248 else {
249 BoolUniqueArray markers(parent_family->maxLocalId());
250 markers.fill(false);
251 ENUMERATE_CELL (icell, parent) {
252 markers[icell.localId()] = true;
253 }
254 ENUMERATE_FACE (iface, family->allItems()) {
255 Face face = *iface;
256 Cell bcell = face.backCell();
257 Cell fcell = face.frontCell();
258 if ((!bcell.null() && markers[bcell.localId()]) ^
259 (!fcell.null() && markers[fcell.localId()]))
260 items_lid.add(face.localId());
261 }
262 }
263
264 m_group->setItems(items_lid);
265 m_group->endTransaction();
266
267 trace->debug() << "OuterFaceItemGroupComputeFunctor::execute()"
268 << " this=" << m_group
269 << " parent_name=" << parent.name()
270 << " name=" << m_group->name()
271 << " parent_count=" << parent.size()
272 << " mysize=" << m_group->size();
273}
274
275/*---------------------------------------------------------------------------*/
276/*---------------------------------------------------------------------------*/
277
278void ActiveCellGroupComputeFunctor::
279executeFunctor()
280{
281 ITraceMng* trace = m_group->mesh()->traceMng();
282 IItemFamily* family = m_group->itemFamily();
283 ItemGroup parent(m_group->parent());
284
285 if (family->itemKind() != IK_Cell) {
286 trace->fatal() << "AllActiveCellGroupComputeFunctor::executeFunctor()"
287 << " Incoherent family expected=" << IK_Cell << " current=" << family->itemKind();
288 }
289
290 m_group->beginTransaction();
291 Int32UniqueArray items_lid;
292 ENUMERATE_CELL (iitem, parent) {
293 Cell item = *iitem;
294 if (item.isActive())
295 items_lid.add(item.localId());
296 }
297 m_group->setItems(items_lid);
298 m_group->endTransaction();
299
300 trace->debug() << "AllActiveCellGroupComputeFunctor::execute()"
301 << " this=" << m_group
302 << " parent_name=" << parent.name()
303 << " name=" << m_group->name()
304 << " parent_count=" << parent.size()
305 << " mysize=" << m_group->size();
306}
307
308/*---------------------------------------------------------------------------*/
309/*---------------------------------------------------------------------------*/
310
311void OwnActiveCellGroupComputeFunctor::
312executeFunctor()
313{
314 ITraceMng* trace = m_group->mesh()->traceMng();
315 IItemFamily* family = m_group->itemFamily();
316 ItemGroup parent(m_group->parent());
317
318 if (family->itemKind() != IK_Cell) {
319 trace->fatal() << "OwnActiveCellGroupComputeFunctor::executeFunctor()"
320 << " Incoherent family expected=" << IK_Cell << " current=" << family->itemKind();
321 }
322
323 m_group->beginTransaction();
324
325 Int32UniqueArray items_lid;
326 ENUMERATE_CELL (iitem, parent) {
327 Cell item = *iitem;
328 if (item.isOwn() && item.isActive())
329 items_lid.add(item.localId());
330 }
331 m_group->setItems(items_lid);
332 m_group->endTransaction();
333
334 trace->debug() << "OwnActiveCellGroupComputeFunctor::execute()"
335 << " this=" << m_group
336 << " parent_name=" << parent.name()
337 << " name=" << m_group->name()
338 << " parent_count=" << parent.size()
339 << " mysize=" << m_group->size();
340}
341
342/*---------------------------------------------------------------------------*/
343/*---------------------------------------------------------------------------*/
344
345void LevelCellGroupComputeFunctor::
346executeFunctor()
347{
348 ITraceMng* trace = m_group->mesh()->traceMng();
349 IItemFamily* family = m_group->itemFamily();
350 ItemGroup parent(m_group->parent());
351
352 if (family->itemKind() != IK_Cell) {
353 trace->fatal() << "LevelCellGroupComputeFunctor::executeFunctor()"
354 << " Incoherent family expected=" << IK_Cell << " current=" << family->itemKind();
355 }
356
357 m_group->beginTransaction();
358 Int32UniqueArray items_lid;
359
360 ENUMERATE_CELL (iitem, parent) {
361 Cell item = *iitem;
362 if (item.level() == m_level)
363 items_lid.add(item.localId());
364 }
365 m_group->setItems(items_lid);
366 m_group->endTransaction();
367
368 trace->debug() << "LevelCellGroupComputeFunctor::execute()"
369 << " this=" << m_group
370 << " parent_name=" << parent.name()
371 << " name=" << m_group->name()
372 << " parent_count=" << parent.size()
373 << " mysize=" << m_group->size();
374}
375
376/*---------------------------------------------------------------------------*/
377/*---------------------------------------------------------------------------*/
378
379void OwnLevelCellGroupComputeFunctor::
380executeFunctor()
381{
382 ITraceMng* trace = m_group->mesh()->traceMng();
383 IItemFamily* family = m_group->itemFamily();
384 ItemGroup parent(m_group->parent());
385
386 m_group->beginTransaction();
387 Int32UniqueArray items_lid;
388 if (family->itemKind() != IK_Cell) {
389 trace->fatal() << "LevelCellGroupComputeFunctor::executeFunctor()"
390 << " Incoherent family expected=" << IK_Cell << " current=" << family->itemKind();
391 }
392 ENUMERATE_CELL (iitem, parent) {
393 Cell item = *iitem;
394 if (item.isOwn() && (item.level() == m_level))
395 items_lid.add(item.localId());
396 }
397 m_group->setItems(items_lid);
398 m_group->endTransaction();
399
400 trace->debug() << "OwnLevelItemGroupComputeFunctor::execute()"
401 << " this=" << m_group
402 << " parent_name=" << parent.name()
403 << " name=" << m_group->name()
404 << " parent_count=" << parent.size()
405 << " mysize=" << m_group->size();
406}
407
408/*---------------------------------------------------------------------------*/
409/*---------------------------------------------------------------------------*/
410
411void ActiveFaceItemGroupComputeFunctor::
412executeFunctor()
413{
414 ITraceMng* trace = m_group->mesh()->traceMng();
415 IItemFamily* family = m_group->itemFamily();
416 ItemGroup parent(m_group->parent());
417 IItemFamily* parent_family = parent.itemFamily();
418 m_group->beginTransaction();
419 Int32UniqueArray items_lid;
420 Integer counter_0 = 0;
421 Integer counter_1 = 0;
422 Integer counter_2 = 0;
423 Integer counter = 0;
424 if (parent.isAllItems()) {
425 ENUMERATE_FACE (iface, family->allItems()) {
426 Face face = *iface;
427 counter++;
428 if (face.isSubDomainBoundary()) {
429 counter_0++;
430 if (face.boundaryCell().isActive()) {
431 items_lid.add(face.localId());
432 counter_1++;
433 }
434 }
435 else if (face.backCell().isActive() && face.frontCell().isActive()) {
436 items_lid.add(face.localId());
437 counter_2++;
438 }
439 }
440 }
441 else {
442 BoolUniqueArray markers(parent_family->maxLocalId());
443 markers.fill(false);
444 ENUMERATE_CELL (icell, parent) {
445 markers[icell.localId()] = true;
446 }
447 ENUMERATE_FACE (iface, family->allItems()) {
448 const Face& face = *iface;
449 if (face.isSubDomainBoundary()) {
450 if (face.boundaryCell().isActive() && markers[face.boundaryCell().localId()])
451 items_lid.add(face.localId());
452 }
453 else if ((face.backCell().isActive() && face.frontCell().isActive()) &&
454 (markers[face.backCell().localId()] || markers[face.frontCell().localId()]))
455 items_lid.add(face.localId());
456 }
457 }
458 trace->debug() << "NUMBER OF ALL FACES= " << counter
459 << "\n NUNMBER OF BOUNDARY FACES= " << counter_0
460 << "\n NUMBER OF ACTIVE BOUNDARY FACES= " << counter_1
461 << "\n NUMBER OF ACTIVE INTERIOR FACES= " << counter_2 << "\n";
462 m_group->setItems(items_lid);
463 m_group->endTransaction();
464
465 trace->debug() << "ActiveFaceItemGroupComputeFunctor::execute()"
466 << " this=" << m_group
467 << " parent_name=" << parent.name()
468 << " name=" << m_group->name()
469 << " parent_count=" << parent.size()
470 << " mysize=" << m_group->size();
471}
472
473/*---------------------------------------------------------------------------*/
474/*---------------------------------------------------------------------------*/
475
476void OwnActiveFaceItemGroupComputeFunctor::
477executeFunctor()
478{
479 ITraceMng* trace = m_group->mesh()->traceMng();
480 IItemFamily* family = m_group->itemFamily();
481 ItemGroup parent(m_group->parent());
482 IItemFamily* parent_family = parent.itemFamily();
483 m_group->beginTransaction();
484 Int32UniqueArray items_lid;
485
486 if (parent.isAllItems()) {
487 ENUMERATE_FACE (iface, family->allItems()) {
488 const Face& face = *iface;
489 if (face.isSubDomainBoundary()) {
490 if (face.isOwn() && face.boundaryCell().isActive())
491 items_lid.add(face.localId());
492 }
493 else if (face.isOwn() && face.backCell().isActive() && face.frontCell().isActive()) {
494 items_lid.add(face.localId());
495 }
496 }
497 }
498 else {
499 BoolUniqueArray markers(parent_family->maxLocalId());
500 markers.fill(false);
501 ENUMERATE_CELL (icell, parent) {
502 markers[icell.localId()] = true;
503 }
504 ENUMERATE_FACE (iface, family->allItems()) {
505 const Face& face = *iface;
506 if (face.isSubDomainBoundary()) {
507 if (face.isOwn() && face.boundaryCell().isActive() && markers[face.boundaryCell().localId()])
508 items_lid.add(face.localId());
509 }
510 else if (face.isOwn() &&
511 markers[face.backCell().localId()] && face.backCell().isActive() &&
512 markers[face.frontCell().localId()] && face.frontCell().isActive())
513 items_lid.add(face.localId());
514 }
515 }
516
517 m_group->setItems(items_lid);
518 m_group->endTransaction();
519
520 trace->debug() << "OwnActiveFaceItemGroupComputeFunctor::execute()"
521 << " this=" << m_group
522 << " parent_name=" << parent.name()
523 << " name=" << m_group->name()
524 << " parent_count=" << parent.size()
525 << " mysize=" << m_group->size();
526}
527
528/*---------------------------------------------------------------------------*/
529/*---------------------------------------------------------------------------*/
530
531void InnerActiveFaceItemGroupComputeFunctor::
532executeFunctor()
533{
534 ITraceMng* trace = m_group->mesh()->traceMng();
535 IItemFamily* family = m_group->itemFamily();
536 ItemGroup parent(m_group->parent());
537 IItemFamily* parent_family = parent.itemFamily();
538 m_group->beginTransaction();
539 Int32UniqueArray items_lid;
540
541 if (parent.isAllItems()) {
542 ENUMERATE_FACE (iface, family->allItems()) {
543 Face face = *iface;
544 if (face.isSubDomainBoundary())
545 continue;
546
547 if (face.backCell().isActive() && face.frontCell().isActive())
548 items_lid.add(face.localId());
549 }
550 }
551 else {
552 BoolUniqueArray markers(parent_family->maxLocalId());
553 markers.fill(false);
554 ENUMERATE_CELL (icell, parent) {
555 markers[icell.localId()] = true;
556 }
557 ENUMERATE_FACE (iface, family->allItems()) {
558 Face face = *iface;
559 if (face.isSubDomainBoundary())
560 continue;
561
562 Cell bcell = face.backCell();
563 Cell fcell = face.frontCell();
564 if (((markers[bcell.localId()]) && markers[fcell.localId()]) &&
565 (bcell.isActive() && fcell.isActive()))
566 items_lid.add(face.localId());
567 }
568 }
569
570 m_group->setItems(items_lid);
571 m_group->endTransaction();
572
573 trace->debug() << "InnerActiveFaceItemGroupComputeFunctor::execute()"
574 << " this=" << m_group
575 << " parent_name=" << parent.name()
576 << " name=" << m_group->name()
577 << " parent_count=" << parent.size()
578 << " mysize=" << m_group->size();
579}
580
581/*---------------------------------------------------------------------------*/
582/*---------------------------------------------------------------------------*/
583
584void OuterActiveFaceItemGroupComputeFunctor::
585executeFunctor()
586{
587 ITraceMng* trace = m_group->mesh()->traceMng();
588 IItemFamily* family = m_group->itemFamily();
589 ItemGroup parent(m_group->parent());
590 IItemFamily* parent_family = parent.itemFamily();
591 m_group->beginTransaction();
592 Int32UniqueArray items_lid;
593
594 if (parent.isAllItems()) {
595 ENUMERATE_FACE (iface, family->allItems()) {
596 const Face& face = *iface;
597 if (face.isSubDomainBoundary() && face.boundaryCell().isActive())
598 items_lid.add(face.localId());
599 }
600 }
601 else {
602 BoolUniqueArray markers(parent_family->maxLocalId());
603 markers.fill(false);
604 ENUMERATE_CELL (icell, parent) {
605 markers[icell.localId()] = true;
606 }
607 ENUMERATE_FACE (iface, family->allItems()) {
608 Face face = *iface;
609 if (face.isSubDomainBoundary()) {
610 Cell bcell = face.boundaryCell();
611 if (bcell.isActive() && markers[bcell.localId()])
612 items_lid.add(face.localId());
613 }
614 }
615 }
616
617 m_group->setItems(items_lid);
618 m_group->endTransaction();
619
620 trace->debug() << "OuterActiveFaceItemGroupComputeFunctor::execute()"
621 << " this=" << m_group
622 << " parent_name=" << parent.name()
623 << " name=" << m_group->name()
624 << " parent_count=" << parent.size()
625 << " mysize=" << m_group->size();
626}
627
628/*---------------------------------------------------------------------------*/
629/*---------------------------------------------------------------------------*/
630
631template class ItemItemGroupComputeFunctor<Node>;
632template class ItemItemGroupComputeFunctor<Edge>;
633template class ItemItemGroupComputeFunctor<Face>;
634template class ItemItemGroupComputeFunctor<Cell>;
635
636/*---------------------------------------------------------------------------*/
637/*---------------------------------------------------------------------------*/
638
639} // namespace Arcane
640
641/*---------------------------------------------------------------------------*/
642/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro throwing a FatalErrorException.
Definition ArcaneGlobal.h:749
ENUMERATE_FACE
#define ENUMERATE_FACE(name, group)
Generic enumerator for a face group.
Definition ItemEnumerator.h:443
ENUMERATE_CELL
#define ENUMERATE_CELL(name, group)
Generic enumerator for a cell group.
Definition ItemEnumerator.h:446
ENUMERATE_ITEM
#define ENUMERATE_ITEM(name, group)
Generic enumerator for a node group.
Definition ItemEnumerator.h:432
Arcane::AbstractArray::size
Integer size() const
Number of elements in the vector.
Definition AbstractArray.h:302
Arcane::ActiveCellGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:279
Arcane::ActiveFaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:412
Arcane::Array::fill
void fill(ConstReferenceType value)
Fills the array with the value value.
Definition arccore/src/common/arccore/common/Array.h:417
Arcane::Array::add
void add(ConstReferenceType val)
Adds element val to the end of the array.
Definition arccore/src/common/arccore/common/Array.h:207
Arcane::Cell
Cell of a mesh.
Definition Item.h:1300
Arcane::Cell::isActive
bool isActive() const
Definition Item.h:1451
Arcane::Cell::level
Int32 level() const
Definition Item.h:1473
Arcane::Face
Face of a cell.
Definition Item.h:1032
Arcane::Face::frontCell
Cell frontCell() const
Cell in front of the face (null cell if none).
Definition Item.h:1780
Arcane::Face::isSubDomainBoundary
bool isSubDomainBoundary() const
Indicates if the face is on the subdomain boundary (i.e nbCell()==1).
Definition Item.h:1148
Arcane::Face::boundaryCell
Cell boundaryCell() const
Cell associated with this boundary face (null cell if none).
Definition Item.h:1768
Arcane::Face::backCell
Cell backCell() const
Cell behind the face (null cell if none).
Definition Item.h:1774
Arcane::GhostItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:64
Arcane::IItemFamily
Interface of an entity family.
Definition IItemFamily.h:83
Arcane::IItemFamily::allItems
virtual ItemGroup allItems() const =0
Group of all entities.
Arcane::IItemFamily::maxLocalId
virtual Int32 maxLocalId() const =0
Arcane::IItemFamily::itemKind
virtual eItemKind itemKind() const =0
Entity kind.
Arcane::ITraceMng::fatal
virtual TraceMessage fatal()=0
Stream for a fatal error message.
Arcane::ITraceMng::debug
virtual TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium)=0
Stream for a debug message.
Arcane::InnerActiveFaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:532
Arcane::InnerFaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:185
Arcane::InterfaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:92
Arcane::ItemEnumeratorBase::hasNext
constexpr bool hasNext()
True if the end of the enumerator has not been reached (index()<count()).
Definition ItemEnumeratorBase.h:125
Arcane::ItemEnumerator
Enumerator over a list of entities.
Definition ItemEnumerator.h:60
Arcane::ItemGroup
Mesh entity group.
Definition ItemGroup.h:51
Arcane::ItemGroup::name
const String & name() const
Group name.
Definition ItemGroup.h:81
Arcane::ItemGroup::size
Integer size() const
Number of elements in the group.
Definition ItemGroup.h:93
Arcane::ItemGroup::itemFamily
IItemFamily * itemFamily() const
Entity family to which this group belongs (0 for the null group).
Definition ItemGroup.h:128
Arcane::ItemGroup::isAllItems
bool isAllItems() const
Indicates if the group is that of all entities.
Definition ItemGroup.cc:607
Arcane::ItemItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Functor to calculate a group containing entities connected to the entities of the parent group.
Definition ItemGroupComputeFunctor.cc:139
Arcane::ItemTraitsT::kind
static eItemKind kind()
Entity kind.
Definition ItemTypes.h:629
Arcane::Item
Base class for a mesh element.
Definition Item.h:84
Arcane::Item::localId
constexpr Int32 localId() const
Local identifier of the entity in the processor subdomain.
Definition Item.h:233
Arcane::Item::null
constexpr bool null() const
true if the entity is null (i.e. not connected to the mesh)
Definition Item.h:230
Arcane::Item::isOwn
constexpr bool isOwn() const
true if the entity belongs to the subdomain
Definition Item.h:267
Arcane::LevelCellGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:346
Arcane::OuterActiveFaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:585
Arcane::OuterFaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:232
Arcane::OwnActiveCellGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:312
Arcane::OwnActiveFaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:477
Arcane::OwnItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Calculation of the group's own entities.
Definition ItemGroupComputeFunctor.cc:36
Arcane::OwnLevelCellGroupComputeFunctor::executeFunctor
void executeFunctor() override
Executes the associated method.
Definition ItemGroupComputeFunctor.cc:380
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition AbstractCaseDocumentVisitor.cc:21
Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293
Arcane::BoolUniqueArray
UniqueArray< bool > BoolUniqueArray
Dynamic 1D array of booleans.
Definition UtilsTypes.h:357
Arcane::Int32UniqueArray
UniqueArray< Int32 > Int32UniqueArray
Dynamic 1D array of 32-bit integers.
Definition UtilsTypes.h:341
Arcane::eItemKind
eItemKind
Mesh entity type.
Definition ArcaneTypes.h:225
Arcane::IK_Cell
@ IK_Cell
Cell mesh entity.
Definition ArcaneTypes.h:229
Arcane::IK_Face
@ IK_Face
Face mesh entity.
Definition ArcaneTypes.h:228
Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233