Arcane  v3.15.3.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ItemGroupComputeFunctor.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2023 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 de calcul des éléments d'un groupe en fonction d'un autre groupe */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/ITraceMng.h"
15#include "arcane/utils/FatalErrorException.h"
16
17#include "arcane/Item.h"
18#include "arcane/ItemGroupComputeFunctor.h"
19#include "arcane/ItemGroupImpl.h"
20#include "arcane/ItemGroup.h"
21#include "arcane/IMesh.h"
22#include "arcane/IItemFamily.h"
23#include "arcane/Properties.h"
24
25/*---------------------------------------------------------------------------*/
26/*---------------------------------------------------------------------------*/
27
28namespace Arcane
29{
30
31/*---------------------------------------------------------------------------*/
32/*---------------------------------------------------------------------------*/
33//! Calcul des entités propres du groupe
34void OwnItemGroupComputeFunctor::
35executeFunctor()
36{
37 ITraceMng* trace = m_group->mesh()->traceMng();
38 ItemGroup parent(m_group->parent());
39
40 m_group->beginTransaction();
41 Int32UniqueArray items_lid;
42
43 ENUMERATE_ITEM(iitem,parent){
44 Item item = *iitem;
45 if (item.isOwn())
46 items_lid.add(iitem.itemLocalId());
47 }
48 m_group->setItems(items_lid);
49 m_group->endTransaction();
50
51 trace->debug() << "OwnItemGroupComputeFunctor::execute()"
52 << " this=" << m_group
53 << " parent_name=" << parent.name()
54 << " name=" << m_group->name()
55 << " parent_count=" << parent.size()
56 << " mysize=" << m_group->size();
57}
58
59/*---------------------------------------------------------------------------*/
60/*---------------------------------------------------------------------------*/
61
62void GhostItemGroupComputeFunctor::
63executeFunctor()
64{
65 ITraceMng* trace = m_group->mesh()->traceMng();
66 ItemGroup parent(m_group->parent());
67 m_group->beginTransaction();
68 Int32UniqueArray items_lid;
69
70 ENUMERATE_ITEM(iitem,parent){
71 Item item = *iitem;
72 if (!item.isOwn())
73 items_lid.add(iitem.itemLocalId());
74 }
75
76 m_group->setItems(items_lid);
77 m_group->endTransaction();
78
79 trace->debug() << "GhostItemGroupComputeFunctor::execute()"
80 << " this=" << m_group
81 << " parent_name=" << parent.name()
82 << " name=" << m_group->name()
83 << " parent_count=" << parent.size()
84 << " mysize=" << m_group->size();
85}
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
89
90void InterfaceItemGroupComputeFunctor::
91executeFunctor()
92{
93 ITraceMng* trace = m_group->mesh()->traceMng();
94 IItemFamily* family = m_group->itemFamily();
95 ItemGroup parent(m_group->parent());
96
97 if (family->itemKind() != IK_Face){
98 trace->fatal() << "InterfaceGroupComputeFunctor::executeFunctor()"
99 << " Incoherent family expected=" << IK_Face << " current=" << family->itemKind();
100 }
101
102 m_group->beginTransaction();
103 Int32UniqueArray items_lid;
104
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 Fonctor pour calculer un groupe contenant les entités connectées
135 * aux entités du groupe parent.
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 } else {
498 BoolUniqueArray markers(parent_family->maxLocalId());
499 markers.fill(false);
500 ENUMERATE_CELL(icell,parent) {
501 markers[icell.localId()] = true;
502 }
503 ENUMERATE_FACE(iface,family->allItems()) {
504 const Face & face = *iface;
505 if (face.isSubDomainBoundary()) {
506 if (face.isOwn() && face.boundaryCell().isActive() && markers[face.boundaryCell().localId()])
507 items_lid.add(face.localId());
508 }
509 else if (face.isOwn() &&
510 markers[face.backCell().localId()] && face.backCell().isActive() &&
511 markers[face.frontCell().localId()] && face.frontCell().isActive())
512 items_lid.add(face.localId());
513 }
514 }
515
516 m_group->setItems(items_lid);
517 m_group->endTransaction();
518
519 trace->debug() << "OwnActiveFaceItemGroupComputeFunctor::execute()"
520 << " this=" << m_group
521 << " parent_name=" << parent.name()
522 << " name=" << m_group->name()
523 << " parent_count=" << parent.size()
524 << " mysize=" << m_group->size();
525}
526
527/*---------------------------------------------------------------------------*/
528/*---------------------------------------------------------------------------*/
529
530void InnerActiveFaceItemGroupComputeFunctor::
531executeFunctor()
532{
533 ITraceMng* trace = m_group->mesh()->traceMng();
534 IItemFamily* family = m_group->itemFamily();
535 ItemGroup parent(m_group->parent());
536 IItemFamily* parent_family = parent.itemFamily();
537 m_group->beginTransaction();
538 Int32UniqueArray items_lid;
539
540 if (parent.isAllItems()) {
541 ENUMERATE_FACE(iface,family->allItems()){
542 Face face = *iface;
543 if (face.isSubDomainBoundary())
544 continue;
545
546 if (face.backCell().isActive() && face.frontCell().isActive())
547 items_lid.add(face.localId());
548 }
549 }
550 else {
551 BoolUniqueArray markers(parent_family->maxLocalId());
552 markers.fill(false);
553 ENUMERATE_CELL(icell,parent) {
554 markers[icell.localId()] = true;
555 }
556 ENUMERATE_FACE(iface,family->allItems()) {
557 Face face = *iface;
558 if (face.isSubDomainBoundary())
559 continue;
560
561 Cell bcell = face.backCell();
562 Cell fcell = face.frontCell();
563 if (((markers[bcell.localId()]) && markers[fcell.localId()]) &&
564 (bcell.isActive() && fcell.isActive()))
565 items_lid.add(face.localId());
566 }
567 }
568
569 m_group->setItems(items_lid);
570 m_group->endTransaction();
571
572 trace->debug() << "InnerActiveFaceItemGroupComputeFunctor::execute()"
573 << " this=" << m_group
574 << " parent_name=" << parent.name()
575 << " name=" << m_group->name()
576 << " parent_count=" << parent.size()
577 << " mysize=" << m_group->size();
578}
579
580/*---------------------------------------------------------------------------*/
581/*---------------------------------------------------------------------------*/
582
583void OuterActiveFaceItemGroupComputeFunctor::
584executeFunctor()
585{
586 ITraceMng* trace = m_group->mesh()->traceMng();
587 IItemFamily* family = m_group->itemFamily();
588 ItemGroup parent(m_group->parent());
589 IItemFamily* parent_family = parent.itemFamily();
590 m_group->beginTransaction();
591 Int32UniqueArray items_lid;
592
593 if (parent.isAllItems()) {
594 ENUMERATE_FACE(iface,family->allItems()){
595 const Face& face = *iface;
596 if (face.isSubDomainBoundary() && face.boundaryCell().isActive())
597 items_lid.add(face.localId());
598 }
599 }
600 else {
601 BoolUniqueArray markers(parent_family->maxLocalId());
602 markers.fill(false);
603 ENUMERATE_CELL(icell,parent) {
604 markers[icell.localId()] = true;
605 }
606 ENUMERATE_FACE(iface,family->allItems()) {
607 Face face = *iface;
608 if (face.isSubDomainBoundary()){
609 Cell bcell= face.boundaryCell();
610 if(bcell.isActive() && markers[bcell.localId()])
611 items_lid.add(face.localId());
612 }
613 }
614 }
615
616 m_group->setItems(items_lid);
617 m_group->endTransaction();
618
619 trace->debug() << "OuterActiveFaceItemGroupComputeFunctor::execute()"
620 << " this=" << m_group
621 << " parent_name=" << parent.name()
622 << " name=" << m_group->name()
623 << " parent_count=" << parent.size()
624 << " mysize=" << m_group->size();
625}
626
627/*---------------------------------------------------------------------------*/
628/*---------------------------------------------------------------------------*/
629
630template class ItemItemGroupComputeFunctor<Node>;
631template class ItemItemGroupComputeFunctor<Edge>;
632template class ItemItemGroupComputeFunctor<Face>;
633template class ItemItemGroupComputeFunctor<Cell>;
634
635/*---------------------------------------------------------------------------*/
636/*---------------------------------------------------------------------------*/
637
638}
639
640/*---------------------------------------------------------------------------*/
641/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:778
ENUMERATE_FACE
#define ENUMERATE_FACE(name, group)
Enumérateur générique d'un groupe de faces.
Definition ItemEnumerator.h:424
ENUMERATE_CELL
#define ENUMERATE_CELL(name, group)
Enumérateur générique d'un groupe de mailles.
Definition ItemEnumerator.h:427
ENUMERATE_ITEM
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
Definition ItemEnumerator.h:413
Arcane::Cell
Maille d'un maillage.
Definition Item.h:1191
Arcane::Cell::isActive
bool isActive() const
Definition Item.h:1320
Arcane::Cell::level
Int32 level() const
Definition Item.h:1342
Arcane::Face
Face d'une maille.
Definition Item.h:944
Arcane::Face::frontCell
Cell frontCell() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1620
Arcane::Face::isSubDomainBoundary
bool isSubDomainBoundary() const
Indique si la face est au bord du sous-domaine (i.e nbCell()==1)
Definition Item.h:1038
Arcane::Face::boundaryCell
Cell boundaryCell() const
Maille associée à cette face frontière (maille nulle si aucune)
Definition Item.h:1608
Arcane::Face::backCell
Cell backCell() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1614
Arcane::GhostItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Exécute la méthode associé
Definition ItemGroupComputeFunctor.cc:63
Arcane::IItemFamily
Interface d'une famille d'entités.
Definition IItemFamily.h:111
Arcane::IItemFamily::allItems
virtual ItemGroup allItems() const =0
Groupe de toutes les entités.
Arcane::IItemFamily::maxLocalId
virtual Int32 maxLocalId() const =0
Arcane::IItemFamily::itemKind
virtual eItemKind itemKind() const =0
Genre des entités.
Arcane::IMeshBase::traceMng
virtual ITraceMng * traceMng()=0
Gestionnaire de message associé
Arcane::IMesh::properties
virtual Properties * properties()=0
Propriétés associées à ce maillage.
Arcane::InterfaceItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Exécute la méthode associé
Definition ItemGroupComputeFunctor.cc:91
Arcane::ItemBase
Classe de base pour les entités du maillage.
Definition ItemInternal.h:433
Arcane::ItemEnumerator
Enumérateur sur une liste d'entités.
Definition ItemEnumerator.h:58
Arcane::ItemGroupImpl::setItems
void setItems(Int32ConstArrayView items_local_id)
Positionne les entités du groupe à items_local_id.
Definition ItemGroupImpl.cc:927
Arcane::ItemGroupImpl::endTransaction
void endTransaction()
Termine une transaction.
Definition ItemGroupImpl.cc:221
Arcane::ItemGroupImpl::parent
ItemGroupImpl * parent() const
Groupe parent (0 si aucun)
Definition ItemGroupImpl.cc:254
Arcane::ItemGroupImpl::mesh
IMesh * mesh() const
Maillage auquel appartient le groupe (0 pour le groupe nul).
Definition ItemGroupImpl.cc:263
Arcane::ItemGroupImpl::size
Integer size() const
Nombre d'entités du groupe.
Definition ItemGroupImpl.cc:183
Arcane::ItemGroupImpl::itemFamily
IItemFamily * itemFamily() const
Familly à laquelle appartient le groupe (ou 0 si aucune)
Definition ItemGroupImpl.cc:272
Arcane::ItemGroupImpl::beginTransaction
void beginTransaction()
Débute une transaction.
Definition ItemGroupImpl.cc:210
Arcane::ItemGroupImpl::name
const String & name() const
Nom du groupe.
Definition ItemGroupImpl.cc:165
Arcane::ItemGroup
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Arcane::ItemGroup::name
const String & name() const
Nom du groupe.
Definition ItemGroup.h:76
Arcane::ItemGroup::size
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
Arcane::ItemGroup::itemFamily
IItemFamily * itemFamily() const
Famille d'entité à laquelle appartient ce groupe (0 pour le group nul)
Definition ItemGroup.h:123
Arcane::ItemGroup::isAllItems
bool isAllItems() const
Indique si le groupe est celui de toutes les entités.
Definition ItemGroup.cc:609
Arcane::ItemItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Fonctor pour calculer un groupe contenant les entités connectées aux entités du groupe parent.
Definition ItemGroupComputeFunctor.cc:139
Arcane::Item
Classe de base d'un élément de maillage.
Definition Item.h:83
Arcane::Item::localId
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:219
Arcane::Item::isOwn
bool isOwn() const
true si l'entité est appartient au sous-domaine
Definition Item.h:253
Arcane::OwnItemGroupComputeFunctor::executeFunctor
void executeFunctor() override
Calcul des entités propres du groupe.
Definition ItemGroupComputeFunctor.cc:35
Arccore::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arccore::ITraceMng::debug
virtual TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium)=0
Flot pour un message de debug.
Arccore::ITraceMng::fatal
virtual TraceMessage fatal()=0
Flot pour un message d'erreur fatale.
Arccore::Ref
Référence à une instance.
Definition arccore/src/base/arccore/base/Ref.h:143
Arccore::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1826
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AbstractCaseDocumentVisitor.cc:20
Arcane::eItemKind
eItemKind
Genre d'entité de maillage.
Definition ArcaneTypes.h:162
Arcane::IK_Cell
@ IK_Cell
Entité de maillage de genre maille.
Definition ArcaneTypes.h:166
Arcane::IK_Face
@ IK_Face
Entité de maillage de genre face.
Definition ArcaneTypes.h:165
Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arccore::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184